motiejus
/
jgit
1
Fork 0
Code Releases Activity

daemon: Use HTTP's resolver and factory pattern 

Using a resolver and factory pattern for the anonymous git:// Daemon
class makes transport.Daemon more useful on non-file storage systems,
or in embedded applications where the caller wants more precise
control over the work tasks constructed within the daemon.

Rather than defining new interfaces, move the existing HTTP ones
into transport.resolver and make them generic on the connection
handle type.  For HTTP, continue to use HttpServletRequest, and
for transport.Daemon use DaemonClient.

To remain compatible with transport.Daemon, FileResolver needs to
learn how to use multiple base directories, and how to export any
Repository instance at a fixed name.

Change-Id: I1efa6b2bd7c6567e983fbbf346947238ea2e847e
Signed-off-by: Shawn O. Pearce <spearce@spearce.org>
This commit is contained in:
Shawn O. Pearce 2011-02-06 16:38:02 -08:00
parent 8235b88a4b
commit 1b7a5a2960
38 changed files with 406 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
org.eclipse.jgit.http.server/META-INF/MANIFEST.MF
View File

@ -19,5 +19,6 @@ Import-Package: javax.servlet;version="[2.5.0,3.0.0)",
org.eclipse.jgit.revwalk;version="[0.12.0,0.13.0)", org.eclipse.jgit.revwalk;version="[0.12.0,0.13.0)",
org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)", org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport;version="[0.12.0,0.13.0)", org.eclipse.jgit.transport;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport.resolver;version="[0.12.0,0.13.0)",
org.eclipse.jgit.util;version="[0.12.0,0.13.0)", org.eclipse.jgit.util;version="[0.12.0,0.13.0)",
org.eclipse.jgit.util.io;version="[0.12.0,0.13.0)" org.eclipse.jgit.util.io;version="[0.12.0,0.13.0)"

2
org.eclipse.jgit.http.server/resources/org/eclipse/jgit/http/server/HttpServerText.properties
View File

@ -13,8 +13,6 @@ noResolverAvailable=No resolver available
parameterNotSet=Parameter {0} not set parameterNotSet=Parameter {0} not set
pathForParamNotFound={0} (for {1}) not found pathForParamNotFound={0} (for {1}) not found
pathNotSupported={0} not supported pathNotSupported={0} not supported
serviceNotEnabled=Service not enabled
serviceNotPermitted=Service not permitted
servletAlreadyInitialized=Servlet already initialized servletAlreadyInitialized=Servlet already initialized
servletMustNotBeNull=servlet must not be null servletMustNotBeNull=servlet must not be null
servletWasAlreadyBound=servlet was already bound servletWasAlreadyBound=servlet was already bound

4
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/AsIsFileFilter.java
View File

@ -59,9 +59,9 @@
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.http.server.resolver.AsIsFileService; import org.eclipse.jgit.http.server.resolver.AsIsFileService;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
class AsIsFileFilter implements Filter { class AsIsFileFilter implements Filter {
private final AsIsFileService asIs; private final AsIsFileService asIs;

29
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/GitServlet.java
View File

@ -48,6 +48,7 @@
import javax.servlet.ServletConfig; import javax.servlet.ServletConfig;
import javax.servlet.ServletException; import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.http.server.glue.ErrorServlet; import org.eclipse.jgit.http.server.glue.ErrorServlet;
@ -56,14 +57,14 @@
import org.eclipse.jgit.http.server.glue.ServletBinder; import org.eclipse.jgit.http.server.glue.ServletBinder;
import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory; import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.DefaultUploadPackFactory; import org.eclipse.jgit.http.server.resolver.DefaultUploadPackFactory;
import org.eclipse.jgit.http.server.resolver.FileResolver;
import org.eclipse.jgit.http.server.resolver.AsIsFileService; import org.eclipse.jgit.http.server.resolver.AsIsFileService;
import org.eclipse.jgit.http.server.resolver.ReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.http.server.resolver.UploadPackFactory;
import org.eclipse.jgit.transport.ReceivePack; import org.eclipse.jgit.transport.ReceivePack;
import org.eclipse.jgit.transport.UploadPack; import org.eclipse.jgit.transport.UploadPack;
import org.eclipse.jgit.transport.resolver.FileResolver;
import org.eclipse.jgit.transport.resolver.ReceivePackFactory;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.UploadPackFactory;
import org.eclipse.jgit.util.StringUtils; import org.eclipse.jgit.util.StringUtils;
/** /**
@ -105,13 +106,13 @@ public class GitServlet extends MetaServlet {
private volatile boolean initialized; private volatile boolean initialized;
private RepositoryResolver resolver; private RepositoryResolver<HttpServletRequest> resolver;
private AsIsFileService asIs = new AsIsFileService(); private AsIsFileService asIs = new AsIsFileService();
private UploadPackFactory uploadPackFactory = new DefaultUploadPackFactory(); private UploadPackFactory<HttpServletRequest> uploadPackFactory = new DefaultUploadPackFactory();
private ReceivePackFactory receivePackFactory = new DefaultReceivePackFactory(); private ReceivePackFactory<HttpServletRequest> receivePackFactory = new DefaultReceivePackFactory();
/** /**
* New servlet that will load its base directory from {@code web.xml}. * New servlet that will load its base directory from {@code web.xml}.
@ -132,7 +133,7 @@ public GitServlet() {
* parameter table during init, which usually comes from the * parameter table during init, which usually comes from the
* {@code web.xml} file of the web application. * {@code web.xml} file of the web application.
*/ */
public void setRepositoryResolver(RepositoryResolver resolver) { public void setRepositoryResolver(RepositoryResolver<HttpServletRequest> resolver) {
assertNotInitialized(); assertNotInitialized();
this.resolver = resolver; this.resolver = resolver;
} }
@ -153,9 +154,10 @@ public void setAsIsFileService(AsIsFileService f) {
* the factory to construct and configure an {@link UploadPack} * the factory to construct and configure an {@link UploadPack}
* session when a fetch or clone is requested by a client. * session when a fetch or clone is requested by a client.
*/ */
public void setUploadPackFactory(UploadPackFactory f) { @SuppressWarnings("unchecked")
public void setUploadPackFactory(UploadPackFactory<HttpServletRequest> f) {
assertNotInitialized(); assertNotInitialized();
this.uploadPackFactory = f != null ? f : UploadPackFactory.DISABLED; this.uploadPackFactory = f != null ? f : (UploadPackFactory<HttpServletRequest>)UploadPackFactory.DISABLED;
} }
/** /**
@ -163,9 +165,10 @@ public void setUploadPackFactory(UploadPackFactory f) {
* the factory to construct and configure a {@link ReceivePack} * the factory to construct and configure a {@link ReceivePack}
* session when a push is requested by a client. * session when a push is requested by a client.
*/ */
public void setReceivePackFactory(ReceivePackFactory f) { @SuppressWarnings("unchecked")
public void setReceivePackFactory(ReceivePackFactory<HttpServletRequest> f) {
assertNotInitialized(); assertNotInitialized();
this.receivePackFactory = f != null ? f : ReceivePackFactory.DISABLED; this.receivePackFactory = f != null ? f : (ReceivePackFactory<HttpServletRequest>)ReceivePackFactory.DISABLED;
} }
private void assertNotInitialized() { private void assertNotInitialized() {
@ -180,7 +183,7 @@ public void init(final ServletConfig config) throws ServletException {
if (resolver == null) { if (resolver == null) {
final File root = getFile("base-path"); final File root = getFile("base-path");
final boolean exportAll = getBoolean("export-all"); final boolean exportAll = getBoolean("export-all");
setRepositoryResolver(new FileResolver(root, exportAll)); setRepositoryResolver(new FileResolver<HttpServletRequest>(root, exportAll));
} }
initialized = true; initialized = true;

2
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/HttpServerText.java
View File

@ -73,8 +73,6 @@ public static HttpServerText get() {
/***/ public String parameterNotSet; /***/ public String parameterNotSet;
/***/ public String pathForParamNotFound; /***/ public String pathForParamNotFound;
/***/ public String pathNotSupported; /***/ public String pathNotSupported;
/***/ public String serviceNotEnabled;
/***/ public String serviceNotPermitted;
/***/ public String servletAlreadyInitialized; /***/ public String servletAlreadyInitialized;
/***/ public String servletMustNotBeNull; /***/ public String servletMustNotBeNull;
/***/ public String servletWasAlreadyBound; /***/ public String servletWasAlreadyBound;

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/ReceivePackServlet.java
View File

@ -56,12 +56,12 @@
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.http.server.resolver.ReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.ReceivePack; import org.eclipse.jgit.transport.ReceivePack;
import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser; import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser;
import org.eclipse.jgit.transport.resolver.ReceivePackFactory;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** Server side implementation of smart push over HTTP. */ /** Server side implementation of smart push over HTTP. */
class ReceivePackServlet extends HttpServlet { class ReceivePackServlet extends HttpServlet {

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/RepositoryFilter.java
View File

@ -63,10 +63,10 @@
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** /**
* Opens a repository named by the path info through {@link RepositoryResolver}. * Opens a repository named by the path info through {@link RepositoryResolver}.

4
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/SmartServiceInfoRefs.java
View File

@ -58,11 +58,11 @@
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.PacketLineOut; import org.eclipse.jgit.transport.PacketLineOut;
import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser; import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** Filter in front of {@link InfoRefsServlet} to catch smart service requests. */ /** Filter in front of {@link InfoRefsServlet} to catch smart service requests. */
abstract class SmartServiceInfoRefs implements Filter { abstract class SmartServiceInfoRefs implements Filter {

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/UploadPackServlet.java
View File

@ -56,12 +56,12 @@
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.http.server.resolver.UploadPackFactory;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.UploadPack; import org.eclipse.jgit.transport.UploadPack;
import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser; import org.eclipse.jgit.transport.RefAdvertiser.PacketLineOutRefAdvertiser;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.transport.resolver.UploadPackFactory;
/** Server side implementation of smart fetch over HTTP. */ /** Server side implementation of smart fetch over HTTP. */
class UploadPackServlet extends HttpServlet { class UploadPackServlet extends HttpServlet {

2
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/AsIsFileService.java
View File

@ -49,6 +49,8 @@
import org.eclipse.jgit.lib.Config; import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.Config.SectionParser; import org.eclipse.jgit.lib.Config.SectionParser;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** /**
* Controls access to bare files in a repository. * Controls access to bare files in a repository.

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/DefaultReceivePackFactory.java
View File

@ -50,6 +50,9 @@
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.Config.SectionParser; import org.eclipse.jgit.lib.Config.SectionParser;
import org.eclipse.jgit.transport.ReceivePack; import org.eclipse.jgit.transport.ReceivePack;
import org.eclipse.jgit.transport.resolver.ReceivePackFactory;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** /**
* Create and configure {@link ReceivePack} service instance. * Create and configure {@link ReceivePack} service instance.
@ -63,7 +66,8 @@
* </ul> * </ul>
* and explicitly rejected otherwise. * and explicitly rejected otherwise.
*/ */
public class DefaultReceivePackFactory implements ReceivePackFactory { public class DefaultReceivePackFactory implements
ReceivePackFactory<HttpServletRequest> {
private static final SectionParser<ServiceConfig> CONFIG = new SectionParser<ServiceConfig>() { private static final SectionParser<ServiceConfig> CONFIG = new SectionParser<ServiceConfig>() {
public ServiceConfig parse(final Config cfg) { public ServiceConfig parse(final Config cfg) {
return new ServiceConfig(cfg); return new ServiceConfig(cfg);

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/DefaultUploadPackFactory.java
View File

@ -49,6 +49,9 @@
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.Config.SectionParser; import org.eclipse.jgit.lib.Config.SectionParser;
import org.eclipse.jgit.transport.UploadPack; import org.eclipse.jgit.transport.UploadPack;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.transport.resolver.UploadPackFactory;
/** /**
* Create and configure {@link UploadPack} service instance. * Create and configure {@link UploadPack} service instance.
@ -56,7 +59,8 @@
* Reading by upload-pack is permitted unless {@code http.uploadpack} is * Reading by upload-pack is permitted unless {@code http.uploadpack} is
* explicitly set to false. * explicitly set to false.
*/ */
public class DefaultUploadPackFactory implements UploadPackFactory { public class DefaultUploadPackFactory implements
UploadPackFactory<HttpServletRequest> {
private static final SectionParser<ServiceConfig> CONFIG = new SectionParser<ServiceConfig>() { private static final SectionParser<ServiceConfig> CONFIG = new SectionParser<ServiceConfig>() {
public ServiceConfig parse(final Config cfg) { public ServiceConfig parse(final Config cfg) {
return new ServiceConfig(cfg); return new ServiceConfig(cfg);

1
org.eclipse.jgit.http.test/META-INF/MANIFEST.MF
View File

@ -32,6 +32,7 @@ Import-Package: javax.servlet;version="[2.5.0,3.0.0)",
org.eclipse.jgit.revwalk;version="[0.12.0,0.13.0)", org.eclipse.jgit.revwalk;version="[0.12.0,0.13.0)",
org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)", org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport;version="[0.12.0,0.13.0)", org.eclipse.jgit.transport;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport.resolver;version="[0.12.0,0.13.0)",
org.eclipse.jgit.util;version="[0.12.0,0.13.0)", org.eclipse.jgit.util;version="[0.12.0,0.13.0)",
org.eclipse.jgit.junit.http;version="[0.12.0,0.13.0)", org.eclipse.jgit.junit.http;version="[0.12.0,0.13.0)",
org.junit;version="[4.0.0,5.0.0)", org.junit;version="[4.0.0,5.0.0)",

8
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/AdvertiseErrorTest.java
View File

@ -56,9 +56,6 @@
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.http.server.GitServlet; import org.eclipse.jgit.http.server.GitServlet;
import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory; import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.TestRepository; import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.junit.http.HttpTestCase; import org.eclipse.jgit.junit.http.HttpTestCase;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.Constants;
@ -73,6 +70,9 @@
import org.eclipse.jgit.transport.RemoteRefUpdate; import org.eclipse.jgit.transport.RemoteRefUpdate;
import org.eclipse.jgit.transport.Transport; import org.eclipse.jgit.transport.Transport;
import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@ -90,7 +90,7 @@ public void setUp() throws Exception {
ServletContextHandler app = server.addContext("/git"); ServletContextHandler app = server.addContext("/git");
GitServlet gs = new GitServlet(); GitServlet gs = new GitServlet();
gs.setRepositoryResolver(new RepositoryResolver() { gs.setRepositoryResolver(new RepositoryResolver<HttpServletRequest>() {
public Repository open(HttpServletRequest req, String name) public Repository open(HttpServletRequest req, String name)
throws RepositoryNotFoundException, throws RepositoryNotFoundException,
ServiceNotEnabledException { ServiceNotEnabledException {

4
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/AsIsServiceTest.java
View File

@ -51,11 +51,11 @@
import org.eclipse.jetty.server.Request; import org.eclipse.jetty.server.Request;
import org.eclipse.jgit.http.server.resolver.AsIsFileService; import org.eclipse.jgit.http.server.resolver.AsIsFileService;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig; import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;

6
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/DefaultReceivePackFactoryTest.java
View File

@ -54,14 +54,14 @@
import org.eclipse.jetty.server.Request; import org.eclipse.jetty.server.Request;
import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory; import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.ReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig; import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.transport.ReceivePack; import org.eclipse.jgit.transport.ReceivePack;
import org.eclipse.jgit.transport.resolver.ReceivePackFactory;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;

6
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/DefaultUploadPackFactoryTest.java
View File

@ -53,13 +53,13 @@
import org.eclipse.jetty.server.Request; import org.eclipse.jetty.server.Request;
import org.eclipse.jgit.http.server.resolver.DefaultUploadPackFactory; import org.eclipse.jgit.http.server.resolver.DefaultUploadPackFactory;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.http.server.resolver.UploadPackFactory;
import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig; import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.transport.UploadPack; import org.eclipse.jgit.transport.UploadPack;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.transport.resolver.UploadPackFactory;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;

6
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/DumbClientSmartServerTest.java
View File

@ -65,8 +65,6 @@
import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.NotSupportedException;
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.http.server.GitServlet; import org.eclipse.jgit.http.server.GitServlet;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.TestRepository; import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.junit.http.AccessEvent; import org.eclipse.jgit.junit.http.AccessEvent;
import org.eclipse.jgit.junit.http.HttpTestCase; import org.eclipse.jgit.junit.http.HttpTestCase;
@ -81,6 +79,8 @@
import org.eclipse.jgit.transport.Transport; import org.eclipse.jgit.transport.Transport;
import org.eclipse.jgit.transport.TransportHttp; import org.eclipse.jgit.transport.TransportHttp;
import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@ -102,7 +102,7 @@ public void setUp() throws Exception {
ServletContextHandler app = server.addContext("/git"); ServletContextHandler app = server.addContext("/git");
GitServlet gs = new GitServlet(); GitServlet gs = new GitServlet();
gs.setRepositoryResolver(new RepositoryResolver() { gs.setRepositoryResolver(new RepositoryResolver<HttpServletRequest>() {
public Repository open(HttpServletRequest req, String name) public Repository open(HttpServletRequest req, String name)
throws RepositoryNotFoundException, throws RepositoryNotFoundException,
ServiceNotEnabledException { ServiceNotEnabledException {

4
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/FileResolverTest.java
View File

@ -53,10 +53,10 @@
import java.io.IOException; import java.io.IOException;
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.http.server.resolver.FileResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.resolver.FileResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.util.FileUtils; import org.eclipse.jgit.util.FileUtils;
import org.junit.Test; import org.junit.Test;

8
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/HookMessageTest.java
View File

@ -58,9 +58,6 @@
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.http.server.GitServlet; import org.eclipse.jgit.http.server.GitServlet;
import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory; import org.eclipse.jgit.http.server.resolver.DefaultReceivePackFactory;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.TestRepository; import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.junit.http.AccessEvent; import org.eclipse.jgit.junit.http.AccessEvent;
import org.eclipse.jgit.junit.http.HttpTestCase; import org.eclipse.jgit.junit.http.HttpTestCase;
@ -79,6 +76,9 @@
import org.eclipse.jgit.transport.RemoteRefUpdate; import org.eclipse.jgit.transport.RemoteRefUpdate;
import org.eclipse.jgit.transport.Transport; import org.eclipse.jgit.transport.Transport;
import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@ -96,7 +96,7 @@ public void setUp() throws Exception {
ServletContextHandler app = server.addContext("/git"); ServletContextHandler app = server.addContext("/git");
GitServlet gs = new GitServlet(); GitServlet gs = new GitServlet();
gs.setRepositoryResolver(new RepositoryResolver() { gs.setRepositoryResolver(new RepositoryResolver<HttpServletRequest>() {
public Repository open(HttpServletRequest req, String name) public Repository open(HttpServletRequest req, String name)
throws RepositoryNotFoundException, throws RepositoryNotFoundException,
ServiceNotEnabledException { ServiceNotEnabledException {

6
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/HttpClientTests.java
View File

@ -64,8 +64,6 @@
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.errors.TransportException;
import org.eclipse.jgit.http.server.GitServlet; import org.eclipse.jgit.http.server.GitServlet;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.TestRepository; import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.junit.http.AccessEvent; import org.eclipse.jgit.junit.http.AccessEvent;
import org.eclipse.jgit.junit.http.AppServer; import org.eclipse.jgit.junit.http.AppServer;
@ -81,6 +79,8 @@
import org.eclipse.jgit.transport.Transport; import org.eclipse.jgit.transport.Transport;
import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider; import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
public class HttpClientTests extends HttpTestCase { public class HttpClientTests extends HttpTestCase {
private TestRepository<FileRepository> remoteRepository; private TestRepository<FileRepository> remoteRepository;
@ -127,7 +127,7 @@ private ServletContextHandler dumb(final String path) {
private ServletContextHandler smart(final String path) { private ServletContextHandler smart(final String path) {
GitServlet gs = new GitServlet(); GitServlet gs = new GitServlet();
gs.setRepositoryResolver(new RepositoryResolver() { gs.setRepositoryResolver(new RepositoryResolver<HttpServletRequest>() {
public Repository open(HttpServletRequest req, String name) public Repository open(HttpServletRequest req, String name)
throws RepositoryNotFoundException, throws RepositoryNotFoundException,
ServiceNotEnabledException { ServiceNotEnabledException {

6
org.eclipse.jgit.http.test/tst/org/eclipse/jgit/http/test/SmartClientSmartServerTest.java
View File

@ -76,8 +76,6 @@
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.errors.TransportException;
import org.eclipse.jgit.http.server.GitServlet; import org.eclipse.jgit.http.server.GitServlet;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.junit.TestRepository; import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.junit.TestRng; import org.eclipse.jgit.junit.TestRng;
import org.eclipse.jgit.junit.http.AccessEvent; import org.eclipse.jgit.junit.http.AccessEvent;
@ -98,6 +96,8 @@
import org.eclipse.jgit.transport.Transport; import org.eclipse.jgit.transport.Transport;
import org.eclipse.jgit.transport.TransportHttp; import org.eclipse.jgit.transport.TransportHttp;
import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
@ -123,7 +123,7 @@ public void setUp() throws Exception {
ServletContextHandler app = server.addContext("/git"); ServletContextHandler app = server.addContext("/git");
GitServlet gs = new GitServlet(); GitServlet gs = new GitServlet();
gs.setRepositoryResolver(new RepositoryResolver() { gs.setRepositoryResolver(new RepositoryResolver<HttpServletRequest>() {
public Repository open(HttpServletRequest req, String name) public Repository open(HttpServletRequest req, String name)
throws RepositoryNotFoundException, throws RepositoryNotFoundException,
ServiceNotEnabledException { ServiceNotEnabledException {

1
org.eclipse.jgit.junit.http/META-INF/MANIFEST.MF
View File

@ -30,5 +30,6 @@ Import-Package: javax.servlet;version="[2.5.0,3.0.0)",
org.eclipse.jgit.revwalk;version="[0.12.0,0.13.0)", org.eclipse.jgit.revwalk;version="[0.12.0,0.13.0)",
org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)", org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport;version="[0.12.0,0.13.0)", org.eclipse.jgit.transport;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport.resolver;version="[0.12.0,0.13.0)",
org.junit;version="[4.0.0,5.0.0)" org.junit;version="[4.0.0,5.0.0)"
Export-Package: org.eclipse.jgit.junit.http;version="0.12.0" Export-Package: org.eclipse.jgit.junit.http;version="0.12.0"

6
org.eclipse.jgit.junit.http/src/org/eclipse/jgit/junit/http/SimpleHttpServer.java
View File

@ -52,11 +52,11 @@
import org.eclipse.jetty.servlet.ServletHolder; import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.http.server.GitServlet; import org.eclipse.jgit.http.server.GitServlet;
import org.eclipse.jgit.http.server.resolver.RepositoryResolver;
import org.eclipse.jgit.http.server.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.storage.file.FileRepository; import org.eclipse.jgit.storage.file.FileRepository;
import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.URIish;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** /**
* Simple http server for testing http access to Git repositories. * Simple http server for testing http access to Git repositories.
@ -92,7 +92,7 @@ public URIish getUri() {
private ServletContextHandler smart(final String path) { private ServletContextHandler smart(final String path) {
GitServlet gs = new GitServlet(); GitServlet gs = new GitServlet();
gs.setRepositoryResolver(new RepositoryResolver() { gs.setRepositoryResolver(new RepositoryResolver<HttpServletRequest>() {
public Repository open(HttpServletRequest req, String name) public Repository open(HttpServletRequest req, String name)
throws RepositoryNotFoundException, throws RepositoryNotFoundException,
ServiceNotEnabledException { ServiceNotEnabledException {

1
org.eclipse.jgit.pgm/META-INF/MANIFEST.MF
View File

@ -21,6 +21,7 @@ Import-Package: org.eclipse.jgit.api;version="[0.12.0,0.13.0)",
org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)", org.eclipse.jgit.storage.file;version="[0.12.0,0.13.0)",
org.eclipse.jgit.storage.pack;version="[0.12.0,0.13.0)", org.eclipse.jgit.storage.pack;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport;version="[0.12.0,0.13.0)", org.eclipse.jgit.transport;version="[0.12.0,0.13.0)",
org.eclipse.jgit.transport.resolver;version="[0.12.0,0.13.0)",
org.eclipse.jgit.treewalk;version="[0.12.0,0.13.0)", org.eclipse.jgit.treewalk;version="[0.12.0,0.13.0)",
org.eclipse.jgit.treewalk.filter;version="[0.12.0,0.13.0)", org.eclipse.jgit.treewalk.filter;version="[0.12.0,0.13.0)",
org.eclipse.jgit.util;version="[0.12.0,0.13.0)", org.eclipse.jgit.util;version="[0.12.0,0.13.0)",

16
org.eclipse.jgit.pgm/src/org/eclipse/jgit/pgm/Daemon.java
View File

@ -54,7 +54,9 @@
import org.eclipse.jgit.storage.file.WindowCache; import org.eclipse.jgit.storage.file.WindowCache;
import org.eclipse.jgit.storage.file.WindowCacheConfig; import org.eclipse.jgit.storage.file.WindowCacheConfig;
import org.eclipse.jgit.storage.pack.PackConfig; import org.eclipse.jgit.storage.pack.PackConfig;
import org.eclipse.jgit.transport.DaemonClient;
import org.eclipse.jgit.transport.DaemonService; import org.eclipse.jgit.transport.DaemonService;
import org.eclipse.jgit.transport.resolver.FileResolver;
import org.eclipse.jgit.util.FS; import org.eclipse.jgit.util.FS;
import org.kohsuke.args4j.Argument; import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option; import org.kohsuke.args4j.Option;
@ -123,13 +125,19 @@ protected void run() throws Exception {
if (1 < threads) if (1 < threads)
packConfig.setExecutor(Executors.newFixedThreadPool(threads)); packConfig.setExecutor(Executors.newFixedThreadPool(threads));
final org.eclipse.jgit.transport.Daemon d; final FileResolver<DaemonClient> resolver = new FileResolver<DaemonClient>();
for (final File f : directory) {
out.println(MessageFormat.format(CLIText.get().exporting, f.getAbsolutePath()));
resolver.exportDirectory(f);
}
resolver.setExportAll(exportAll);
final org.eclipse.jgit.transport.Daemon d;
d = new org.eclipse.jgit.transport.Daemon( d = new org.eclipse.jgit.transport.Daemon(
host != null ? new InetSocketAddress(host, port) host != null ? new InetSocketAddress(host, port)
: new InetSocketAddress(port)); : new InetSocketAddress(port));
d.setExportAll(exportAll);
d.setPackConfig(packConfig); d.setPackConfig(packConfig);
d.setRepositoryResolver(resolver);
if (0 <= timeout) if (0 <= timeout)
d.setTimeout(timeout); d.setTimeout(timeout);
@ -143,10 +151,6 @@ protected void run() throws Exception {
for (final String n : forbidOverride) for (final String n : forbidOverride)
service(d, n).setOverridable(false); service(d, n).setOverridable(false);
for (final File f : directory) {
out.println(MessageFormat.format(CLIText.get().exporting, f.getAbsolutePath()));
d.exportDirectory(f);
}
d.start(); d.start();
out.println(MessageFormat.format(CLIText.get().listeningOn, d.getAddress())); out.println(MessageFormat.format(CLIText.get().listeningOn, d.getAddress()));
} }

1
org.eclipse.jgit/META-INF/MANIFEST.MF
View File

@ -25,6 +25,7 @@ Export-Package: org.eclipse.jgit;version="0.12.0",
org.eclipse.jgit.storage.file;version="0.12.0", org.eclipse.jgit.storage.file;version="0.12.0",
org.eclipse.jgit.storage.pack;version="0.12.0", org.eclipse.jgit.storage.pack;version="0.12.0",
org.eclipse.jgit.transport;version="0.12.0", org.eclipse.jgit.transport;version="0.12.0",
org.eclipse.jgit.transport.resolver;version="0.12.0",
org.eclipse.jgit.treewalk;version="0.12.0", org.eclipse.jgit.treewalk;version="0.12.0",
org.eclipse.jgit.treewalk.filter;version="0.12.0", org.eclipse.jgit.treewalk.filter;version="0.12.0",
org.eclipse.jgit.util;version="0.12.0", org.eclipse.jgit.util;version="0.12.0",

2
org.eclipse.jgit/resources/org/eclipse/jgit/JGitText.properties
View File

@ -384,7 +384,9 @@ rewinding=Rewinding to commit {0}
searchForReuse=Finding sources searchForReuse=Finding sources
searchForSizes=Getting sizes searchForSizes=Getting sizes
sequenceTooLargeForDiffAlgorithm=Sequence too large for difference algorithm. sequenceTooLargeForDiffAlgorithm=Sequence too large for difference algorithm.
serviceNotEnabledNoName=Service not enabled
serviceNotPermitted={0} not permitted serviceNotPermitted={0} not permitted
serviceNotPermittedNoName=Service not permitted
shortCompressedStreamAt=Short compressed stream at {0} shortCompressedStreamAt=Short compressed stream at {0}
shortReadOfBlock=Short read of block. shortReadOfBlock=Short read of block.
shortReadOfOptionalDIRCExtensionExpectedAnotherBytes=Short read of optional DIRC extension {0}; expected another {1} bytes within the section. shortReadOfOptionalDIRCExtensionExpectedAnotherBytes=Short read of optional DIRC extension {0}; expected another {1} bytes within the section.

2
org.eclipse.jgit/src/org/eclipse/jgit/JGitText.java
View File

@ -444,7 +444,9 @@ public static JGitText get() {
/***/ public String searchForReuse; /***/ public String searchForReuse;
/***/ public String searchForSizes; /***/ public String searchForSizes;
/***/ public String sequenceTooLargeForDiffAlgorithm; /***/ public String sequenceTooLargeForDiffAlgorithm;
/***/ public String serviceNotEnabledNoName;
/***/ public String serviceNotPermitted; /***/ public String serviceNotPermitted;
/***/ public String serviceNotPermittedNoName;
/***/ public String shortCompressedStreamAt; /***/ public String shortCompressedStreamAt;
/***/ public String shortReadOfBlock; /***/ public String shortReadOfBlock;
/***/ public String shortReadOfOptionalDIRCExtensionExpectedAnotherBytes; /***/ public String shortReadOfOptionalDIRCExtensionExpectedAnotherBytes;

249
org.eclipse.jgit/src/org/eclipse/jgit/transport/Daemon.java
View File

@ -43,28 +43,26 @@
package org.eclipse.jgit.transport; package org.eclipse.jgit.transport;
import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.InterruptedIOException; import java.io.InterruptedIOException;
import java.io.OutputStream;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.InetSocketAddress; import java.net.InetSocketAddress;
import java.net.ServerSocket; import java.net.ServerSocket;
import java.net.Socket; import java.net.Socket;
import java.net.SocketAddress; import java.net.SocketAddress;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import org.eclipse.jgit.JGitText; import org.eclipse.jgit.JGitText;
import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.lib.PersonIdent; import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryCache;
import org.eclipse.jgit.lib.RepositoryCache.FileKey;
import org.eclipse.jgit.storage.pack.PackConfig; import org.eclipse.jgit.storage.pack.PackConfig;
import org.eclipse.jgit.util.FS; import org.eclipse.jgit.transport.resolver.ReceivePackFactory;
import org.eclipse.jgit.transport.resolver.RepositoryResolver;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
import org.eclipse.jgit.transport.resolver.UploadPackFactory;
/** Basic daemon for the anonymous <code>git://</code> transport protocol. */ /** Basic daemon for the anonymous <code>git://</code> transport protocol. */
public class Daemon { public class Daemon {
@ -79,12 +77,6 @@ public class Daemon {
private final ThreadGroup processors; private final ThreadGroup processors;
private volatile boolean exportAll;
private Map<String, Repository> exports;
private Collection<File> exportBase;
private boolean run; private boolean run;
private Thread acceptThread; private Thread acceptThread;
@ -93,6 +85,12 @@ public class Daemon {
private PackConfig packConfig; private PackConfig packConfig;
private volatile RepositoryResolver<DaemonClient> repositoryResolver;
private volatile UploadPackFactory<DaemonClient> uploadPackFactory;
private volatile ReceivePackFactory<DaemonClient> receivePackFactory;
/** Configure a daemon to listen on any available network port. */ /** Configure a daemon to listen on any available network port. */
public Daemon() { public Daemon() {
this(null); this(null);
@ -107,10 +105,40 @@ public Daemon() {
*/ */
public Daemon(final InetSocketAddress addr) { public Daemon(final InetSocketAddress addr) {
myAddress = addr; myAddress = addr;
exports = new ConcurrentHashMap<String, Repository>();
exportBase = new CopyOnWriteArrayList<File>();
processors = new ThreadGroup("Git-Daemon"); processors = new ThreadGroup("Git-Daemon");
repositoryResolver = (RepositoryResolver<DaemonClient>) RepositoryResolver.NONE;
uploadPackFactory = new UploadPackFactory<DaemonClient>() {
public UploadPack create(DaemonClient req, Repository db)
throws ServiceNotEnabledException,
ServiceNotAuthorizedException {
UploadPack up = new UploadPack(db);
up.setTimeout(getTimeout());
up.setPackConfig(getPackConfig());
return up;
}
};
receivePackFactory = new ReceivePackFactory<DaemonClient>() {
public ReceivePack create(DaemonClient req, Repository db)
throws ServiceNotEnabledException,
ServiceNotAuthorizedException {
ReceivePack rp = new ReceivePack(db);
InetAddress peer = req.getRemoteAddress();
String host = peer.getCanonicalHostName();
if (host == null)
host = peer.getHostAddress();
String name = "anonymous";
String email = name + "@" + host;
rp.setRefLogIdent(new PersonIdent(name, email));
rp.setTimeout(getTimeout());
return rp;
}
};
services = new DaemonService[] { services = new DaemonService[] {
new DaemonService("upload-pack", "uploadpack") { new DaemonService("upload-pack", "uploadpack") {
{ {
@ -119,12 +147,13 @@ public Daemon(final InetSocketAddress addr) {
@Override @Override
protected void execute(final DaemonClient dc, protected void execute(final DaemonClient dc,
final Repository db) throws IOException { final Repository db) throws IOException,
final UploadPack rp = new UploadPack(db); ServiceNotEnabledException,
final InputStream in = dc.getInputStream(); ServiceNotAuthorizedException {
rp.setTimeout(Daemon.this.getTimeout()); UploadPack up = uploadPackFactory.create(dc, db);
rp.setPackConfig(Daemon.this.packConfig); InputStream in = dc.getInputStream();
rp.upload(in, dc.getOutputStream(), null); OutputStream out = dc.getOutputStream();
up.upload(in, out, null);
} }
}, new DaemonService("receive-pack", "receivepack") { }, new DaemonService("receive-pack", "receivepack") {
{ {
@ -133,18 +162,13 @@ protected void execute(final DaemonClient dc,
@Override @Override
protected void execute(final DaemonClient dc, protected void execute(final DaemonClient dc,
final Repository db) throws IOException { final Repository db) throws IOException,
final InetAddress peer = dc.getRemoteAddress(); ServiceNotEnabledException,
String host = peer.getCanonicalHostName(); ServiceNotAuthorizedException {
if (host == null) ReceivePack rp = receivePackFactory.create(dc, db);
host = peer.getHostAddress(); InputStream in = dc.getInputStream();
final ReceivePack rp = new ReceivePack(db); OutputStream out = dc.getOutputStream();
final InputStream in = dc.getInputStream(); rp.receive(in, out, null);
final String name = "anonymous";
final String email = name + "@" + host;
rp.setRefLogIdent(new PersonIdent(name, email));
rp.setTimeout(Daemon.this.getTimeout());
rp.receive(in, dc.getOutputStream(), null);
} }
} }; } };
} }
@ -173,62 +197,6 @@ public synchronized DaemonService getService(String name) {
return null; return null;
} }
/**
* @return false if <code>git-daemon-export-ok</code> is required to export
* a repository; true if <code>git-daemon-export-ok</code> is
* ignored.
* @see #setExportAll(boolean)
*/
public boolean isExportAll() {
return exportAll;
}
/**
* Set whether or not to export all repositories.
* <p>
* If false (the default), repositories must have a
* <code>git-daemon-export-ok</code> file to be accessed through this
* daemon.
* <p>
* If true, all repositories are available through the daemon, whether or
* not <code>git-daemon-export-ok</code> exists.
*
* @param export
*/
public void setExportAll(final boolean export) {
exportAll = export;
}
/**
* Add a single repository to the set that is exported by this daemon.
* <p>
* The existence (or lack-thereof) of <code>git-daemon-export-ok</code> is
* ignored by this method. The repository is always published.
*
* @param name
* name the repository will be published under.
* @param db
* the repository instance.
*/
public void exportRepository(String name, final Repository db) {
if (!name.endsWith(Constants.DOT_GIT_EXT))
name = name + Constants.DOT_GIT_EXT;
exports.put(name, db);
RepositoryCache.register(db);
}
/**
* Recursively export all Git repositories within a directory.
*
* @param dir
* the directory to export. This directory must not itself be a
* git repository, but any directory below it which has a file
* named <code>git-daemon-export-ok</code> will be published.
*/
public void exportDirectory(final File dir) {
exportBase.add(dir);
}
/** @return timeout (in seconds) before aborting an IO operation. */ /** @return timeout (in seconds) before aborting an IO operation. */
public int getTimeout() { public int getTimeout() {
return timeout; return timeout;
@ -246,6 +214,11 @@ public void setTimeout(final int seconds) {
timeout = seconds; timeout = seconds;
} }
/** @return configuration controlling packing, may be null. */
public PackConfig getPackConfig() {
return packConfig;
}
/** /**
* Set the configuration used by the pack generator. * Set the configuration used by the pack generator.
* *
@ -257,6 +230,44 @@ public void setPackConfig(PackConfig pc) {
this.packConfig = pc; this.packConfig = pc;
} }
/**
* Set the resolver used to locate a repository by name.
*
* @param resolver
* the resolver instance.
*/
public void setRepositoryResolver(RepositoryResolver<DaemonClient> resolver) {
repositoryResolver = resolver;
}
/**
* Set the factory to construct and configure per-request UploadPack.
*
* @param factory
* the factory. If null upload-pack is disabled.
*/
@SuppressWarnings("unchecked")
public void setUploadPackFactory(UploadPackFactory<DaemonClient> factory) {
if (factory != null)
uploadPackFactory = factory;
else
uploadPackFactory = (UploadPackFactory<DaemonClient>) UploadPackFactory.DISABLED;
}
/**
* Set the factory to construct and configure per-request ReceivePack.
*
* @param factory
* the factory. If null receive-pack is disabled.
*/
@SuppressWarnings("unchecked")
public void setReceivePackFactory(ReceivePackFactory<DaemonClient> factory) {
if (factory != null)
receivePackFactory = factory;
else
receivePackFactory = (ReceivePackFactory<DaemonClient>) ReceivePackFactory.DISABLED;
}
/** /**
* Start this daemon on a background thread. * Start this daemon on a background thread.
* *
@ -325,6 +336,12 @@ private void startClient(final Socket s) {
public void run() { public void run() {
try { try {
dc.execute(s); dc.execute(s);
} catch (RepositoryNotFoundException e) {
// Ignored. Client cannot use this repository.
} catch (ServiceNotEnabledException e) {
// Ignored. Client cannot use this repository.
} catch (ServiceNotAuthorizedException e) {
// Ignored. Client cannot use this repository.
} catch (IOException e) { } catch (IOException e) {
// Ignore unexpected IO exceptions from clients // Ignore unexpected IO exceptions from clients
e.printStackTrace(); e.printStackTrace();
@ -352,7 +369,7 @@ synchronized DaemonService matchService(final String cmd) {
return null; return null;
} }
Repository openRepository(String name) { Repository openRepository(DaemonClient client, String name) {
// Assume any attempt to use \ was by a Windows client // Assume any attempt to use \ was by a Windows client
// and correct to the more typical / used in Git URIs. // and correct to the more typical / used in Git URIs.
// //
@ -363,48 +380,20 @@ Repository openRepository(String name) {
if (!name.startsWith("/")) if (!name.startsWith("/"))
return null; return null;
// Forbid Windows UNC paths as they might escape the base
//
if (name.startsWith("//"))
return null;
// Forbid funny paths which contain an up-reference, they
// might be trying to escape and read /../etc/password.
//
if (name.contains("/../"))
return null;
name = name.substring(1);
Repository db;
db = exports.get(name.endsWith(Constants.DOT_GIT_EXT) ? name : name
+ Constants.DOT_GIT_EXT);
if (db != null) {
db.incrementOpen();
return db;
}
for (final File baseDir : exportBase) {
final File gitdir = FileKey.resolve(new File(baseDir, name), FS.DETECTED);
if (gitdir != null && canExport(gitdir))
return openRepository(gitdir);
}
return null;
}
private static Repository openRepository(final File gitdir) {
try { try {
return RepositoryCache.open(FileKey.exact(gitdir, FS.DETECTED)); return repositoryResolver.open(client, name.substring(1));
} catch (IOException err) { } catch (RepositoryNotFoundException e) {
// null signals it "wasn't found", which is all that is suitable
// for the remote client to know.
return null;
} catch (ServiceNotAuthorizedException e) {
// null signals it "wasn't found", which is all that is suitable
// for the remote client to know.
return null;
} catch (ServiceNotEnabledException e) {
// null signals it "wasn't found", which is all that is suitable // null signals it "wasn't found", which is all that is suitable
// for the remote client to know. // for the remote client to know.
return null; return null;
} }
} }
private boolean canExport(final File d) {
if (isExportAll()) {
return true;
}
return new File(d, "git-daemon-export-ok").exists();
}
} }

7
org.eclipse.jgit/src/org/eclipse/jgit/transport/DaemonClient.java
View File

@ -51,6 +51,9 @@
import java.net.InetAddress; import java.net.InetAddress;
import java.net.Socket; import java.net.Socket;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** Active network client of {@link Daemon}. */ /** Active network client of {@link Daemon}. */
public class DaemonClient { public class DaemonClient {
private final Daemon daemon; private final Daemon daemon;
@ -89,8 +92,8 @@ public OutputStream getOutputStream() {
return rawOut; return rawOut;
} }
void execute(final Socket sock) void execute(final Socket sock) throws IOException,
throws IOException { ServiceNotEnabledException, ServiceNotAuthorizedException {
rawIn = new BufferedInputStream(sock.getInputStream()); rawIn = new BufferedInputStream(sock.getInputStream());
rawOut = new BufferedOutputStream(sock.getOutputStream()); rawOut = new BufferedOutputStream(sock.getOutputStream());

10
org.eclipse.jgit/src/org/eclipse/jgit/transport/DaemonService.java
View File

@ -49,6 +49,8 @@
import org.eclipse.jgit.lib.Config; import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.Config.SectionParser; import org.eclipse.jgit.lib.Config.SectionParser;
import org.eclipse.jgit.transport.resolver.ServiceNotAuthorizedException;
import org.eclipse.jgit.transport.resolver.ServiceNotEnabledException;
/** A service exposed by {@link Daemon} over anonymous <code>git://</code>. */ /** A service exposed by {@link Daemon} over anonymous <code>git://</code>. */
public abstract class DaemonService { public abstract class DaemonService {
@ -125,9 +127,10 @@ public boolean handles(final String commandLine) {
} }
void execute(final DaemonClient client, final String commandLine) void execute(final DaemonClient client, final String commandLine)
throws IOException { throws IOException, ServiceNotEnabledException,
ServiceNotAuthorizedException {
final String name = commandLine.substring(command.length() + 1); final String name = commandLine.substring(command.length() + 1);
final Repository db = client.getDaemon().openRepository(name); Repository db = client.getDaemon().openRepository(client, name);
if (db == null) if (db == null)
return; return;
try { try {
@ -145,5 +148,6 @@ private boolean isEnabledFor(final Repository db) {
} }
abstract void execute(DaemonClient client, Repository db) abstract void execute(DaemonClient client, Repository db)
throws IOException; throws IOException, ServiceNotEnabledException,
ServiceNotAuthorizedException;
} }

173
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/FileResolver.java → org.eclipse.jgit/src/org/eclipse/jgit/transport/resolver/FileResolver.java
View File

@ -41,24 +41,40 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package org.eclipse.jgit.http.server.resolver; package org.eclipse.jgit.transport.resolver;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.util.Collection;
import javax.servlet.http.HttpServletRequest; import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryCache; import org.eclipse.jgit.lib.RepositoryCache;
import org.eclipse.jgit.lib.RepositoryCache.FileKey; import org.eclipse.jgit.lib.RepositoryCache.FileKey;
import org.eclipse.jgit.util.FS; import org.eclipse.jgit.util.FS;
/** Default resolver serving from a single root path in local filesystem. */ /**
public class FileResolver implements RepositoryResolver { * Default resolver serving from the local filesystem.
private final File basePath; *
* @param <C>
* type of connection
*/
public class FileResolver<C> implements RepositoryResolver<C> {
private volatile boolean exportAll;
private final boolean exportAll; private final Map<String, Repository> exports;
private final Collection<File> exportBase;
/** Initialize an empty file based resolver. */
public FileResolver() {
exports = new ConcurrentHashMap<String, Repository>();
exportBase = new CopyOnWriteArrayList<File>();
}
/** /**
* Create a new resolver for the given path. * Create a new resolver for the given path.
@ -70,54 +86,121 @@ public class FileResolver implements RepositoryResolver {
* {@code git-daemon-export-ok} files. * {@code git-daemon-export-ok} files.
*/ */
public FileResolver(final File basePath, final boolean exportAll) { public FileResolver(final File basePath, final boolean exportAll) {
this.basePath = basePath; this();
this.exportAll = exportAll; exportDirectory(basePath);
setExportAll(exportAll);
} }
public Repository open(final HttpServletRequest req, public Repository open(final C req, final String name)
final String repositoryName) throws RepositoryNotFoundException, throws RepositoryNotFoundException, ServiceNotEnabledException {
ServiceNotEnabledException { if (isUnreasonableName(name))
if (isUnreasonableName(repositoryName)) throw new RepositoryNotFoundException(name);
throw new RepositoryNotFoundException(repositoryName);
final Repository db; Repository db = exports.get(nameWithDotGit(name));
try { if (db != null) {
final File gitdir = new File(basePath, repositoryName); db.incrementOpen();
db = RepositoryCache.open(FileKey.lenient(gitdir, FS.DETECTED), true); return db;
} catch (IOException e) {
throw new RepositoryNotFoundException(repositoryName, e);
} }
try { for (File base : exportBase) {
if (isExportOk(req, repositoryName, db)) { File dir = FileKey.resolve(new File(base, name), FS.DETECTED);
// We have to leak the open count to the caller, they if (dir == null)
// are responsible for closing the repository if we continue;
// complete successfully.
return db;
} else
throw new ServiceNotEnabledException();
} catch (RuntimeException e) { try {
db.close(); FileKey key = FileKey.exact(dir, FS.DETECTED);
throw new RepositoryNotFoundException(repositoryName, e); db = RepositoryCache.open(key, true);
} catch (IOException e) {
throw new RepositoryNotFoundException(name, e);
}
} catch (IOException e) { try {
db.close(); if (isExportOk(req, name, db)) {
throw new RepositoryNotFoundException(repositoryName, e); // We have to leak the open count to the caller, they
// are responsible for closing the repository if we
// complete successfully.
return db;
} else
throw new ServiceNotEnabledException();
} catch (ServiceNotEnabledException e) { } catch (RuntimeException e) {
db.close(); db.close();
throw e; throw new RepositoryNotFoundException(name, e);
} catch (IOException e) {
db.close();
throw new RepositoryNotFoundException(name, e);
} catch (ServiceNotEnabledException e) {
db.close();
throw e;
}
} }
if (exportBase.size() == 1) {
File dir = new File(exportBase.iterator().next(), name);
throw new RepositoryNotFoundException(name,
new RepositoryNotFoundException(dir));
}
throw new RepositoryNotFoundException(name);
} }
/** @return {@code true} if all repositories are to be exported. */ /**
protected boolean isExportAll() { * @return false if <code>git-daemon-export-ok</code> is required to export
* a repository; true if <code>git-daemon-export-ok</code> is
* ignored.
* @see #setExportAll(boolean)
*/
public boolean isExportAll() {
return exportAll; return exportAll;
} }
/** /**
* Check if this repository can be served over HTTP. * Set whether or not to export all repositories.
* <p>
* If false (the default), repositories must have a
* <code>git-daemon-export-ok</code> file to be accessed through this
* daemon.
* <p>
* If true, all repositories are available through the daemon, whether or
* not <code>git-daemon-export-ok</code> exists.
*
* @param export
*/
public void setExportAll(final boolean export) {
exportAll = export;
}
/**
* Add a single repository to the set that is exported by this daemon.
* <p>
* The existence (or lack-thereof) of <code>git-daemon-export-ok</code> is
* ignored by this method. The repository is always published.
*
* @param name
* name the repository will be published under.
* @param db
* the repository instance.
*/
public void exportRepository(String name, Repository db) {
exports.put(nameWithDotGit(name), db);
}
/**
* Recursively export all Git repositories within a directory.
*
* @param dir
* the directory to export. This directory must not itself be a
* git repository, but any directory below it which has a file
* named <code>git-daemon-export-ok</code> will be published.
*/
public void exportDirectory(final File dir) {
exportBase.add(dir);
}
/**
* Check if this repository can be served.
* <p> * <p>
* The default implementation of this method returns true only if either * The default implementation of this method returns true only if either
* {@link #isExportAll()} is true, or the {@code git-daemon-export-ok} file * {@link #isExportAll()} is true, or the {@code git-daemon-export-ok} file
@ -134,8 +217,8 @@ protected boolean isExportAll() {
* the repository could not be accessed, the caller will claim * the repository could not be accessed, the caller will claim
* the repository does not exist. * the repository does not exist.
*/ */
protected boolean isExportOk(HttpServletRequest req, String repositoryName, protected boolean isExportOk(C req, String repositoryName, Repository db)
Repository db) throws IOException { throws IOException {
if (isExportAll()) if (isExportAll())
return true; return true;
else if (db.getDirectory() != null) else if (db.getDirectory() != null)
@ -144,6 +227,12 @@ else if (db.getDirectory() != null)
return false; return false;
} }
private static String nameWithDotGit(String name) {
if (name.endsWith(Constants.DOT_GIT_EXT))
return name;
return name + Constants.DOT_GIT_EXT;
}
private static boolean isUnreasonableName(final String name) { private static boolean isUnreasonableName(final String name) {
if (name.length() == 0) if (name.length() == 0)
return true; // no empty paths return true; // no empty paths

27
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/ReceivePackFactory.java → org.eclipse.jgit/src/org/eclipse/jgit/transport/resolver/ReceivePackFactory.java
View File

@ -41,18 +41,21 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package org.eclipse.jgit.http.server.resolver; package org.eclipse.jgit.transport.resolver;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.ReceivePack; import org.eclipse.jgit.transport.ReceivePack;
/** Create and configure {@link ReceivePack} service instance. */ /**
public interface ReceivePackFactory { * Create and configure {@link ReceivePack} service instance.
/** A factory disabling the ReceivePack service for all repositories. */ *
public static final ReceivePackFactory DISABLED = new ReceivePackFactory() { * @param <C>
public ReceivePack create(HttpServletRequest req, Repository db) * type of connection
*/
public interface ReceivePackFactory<C> {
/** A factory disabling the ReceivePack service for all repositories */
public static final ReceivePackFactory<?> DISABLED = new ReceivePackFactory<Object>() {
public ReceivePack create(Object req, Repository db)
throws ServiceNotEnabledException { throws ServiceNotEnabledException {
throw new ServiceNotEnabledException(); throw new ServiceNotEnabledException();
} }
@ -62,8 +65,8 @@ public ReceivePack create(HttpServletRequest req, Repository db)
* Create and configure a new ReceivePack instance for a repository. * Create and configure a new ReceivePack instance for a repository.
* *
* @param req * @param req
* current HTTP request, in case information from the request may * current request, in case information from the request may help
* help configure the ReceivePack instance. * configure the ReceivePack instance.
* @param db * @param db
* the repository the receive would write into. * the repository the receive would write into.
* @return the newly configured ReceivePack instance, must not be null. * @return the newly configured ReceivePack instance, must not be null.
@ -74,6 +77,6 @@ public ReceivePack create(HttpServletRequest req, Repository db)
* this factory refuses to create the instance for this HTTP * this factory refuses to create the instance for this HTTP
* request and repository, such as due to a permission error. * request and repository, such as due to a permission error.
*/ */
ReceivePack create(HttpServletRequest req, Repository db) ReceivePack create(C req, Repository db) throws ServiceNotEnabledException,
throws ServiceNotEnabledException, ServiceNotAuthorizedException; ServiceNotAuthorizedException;
} }

28
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/RepositoryResolver.java → org.eclipse.jgit/src/org/eclipse/jgit/transport/resolver/RepositoryResolver.java
View File

@ -41,22 +41,33 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package org.eclipse.jgit.http.server.resolver; package org.eclipse.jgit.transport.resolver;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jgit.errors.RepositoryNotFoundException; import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
/** Locate a Git {@link Repository} by name from the URL. */ /**
public interface RepositoryResolver { * Locate a Git {@link Repository} by name from the URL.
*
* @param <C>
* type of connection.
*/
public interface RepositoryResolver<C> {
/** Resolver configured to open nothing. */
public static final RepositoryResolver<?> NONE = new RepositoryResolver<Object>() {
public Repository open(Object req, String name)
throws RepositoryNotFoundException {
throw new RepositoryNotFoundException(name);
}
};
/** /**
* Locate and open a reference to a {@link Repository}. * Locate and open a reference to a {@link Repository}.
* <p> * <p>
* The caller is responsible for closing the returned Repository. * The caller is responsible for closing the returned Repository.
* *
* @param req * @param req
* the current HTTP request, may be used to inspect session state * the current request, may be used to inspect session state
* including cookies or user authentication. * including cookies or user authentication.
* @param name * @param name
* name of the repository, as parsed out of the URL. * name of the repository, as parsed out of the URL.
@ -71,7 +82,6 @@ public interface RepositoryResolver {
* the repository exists, but HTTP access is not allowed on the * the repository exists, but HTTP access is not allowed on the
* target repository, by any user. * target repository, by any user.
*/ */
Repository open(HttpServletRequest req, String name) Repository open(C req, String name) throws RepositoryNotFoundException,
throws RepositoryNotFoundException, ServiceNotAuthorizedException, ServiceNotAuthorizedException, ServiceNotEnabledException;
ServiceNotEnabledException;
} }

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/ServiceNotAuthorizedException.java → org.eclipse.jgit/src/org/eclipse/jgit/transport/resolver/ServiceNotAuthorizedException.java
View File

@ -41,9 +41,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package org.eclipse.jgit.http.server.resolver; package org.eclipse.jgit.transport.resolver;
import org.eclipse.jgit.http.server.HttpServerText; import org.eclipse.jgit.JGitText;
/** Indicates the request service is not authorized for current user. */ /** Indicates the request service is not authorized for current user. */
public class ServiceNotAuthorizedException extends Exception { public class ServiceNotAuthorizedException extends Exception {
@ -51,6 +51,6 @@ public class ServiceNotAuthorizedException extends Exception {
/** Indicates the request service is not available. */ /** Indicates the request service is not available. */
public ServiceNotAuthorizedException() { public ServiceNotAuthorizedException() {
super(HttpServerText.get().serviceNotPermitted); super(JGitText.get().serviceNotPermittedNoName);
} }
} }

6
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/ServiceNotEnabledException.java → org.eclipse.jgit/src/org/eclipse/jgit/transport/resolver/ServiceNotEnabledException.java
View File

@ -41,9 +41,9 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package org.eclipse.jgit.http.server.resolver; package org.eclipse.jgit.transport.resolver;
import org.eclipse.jgit.http.server.HttpServerText; import org.eclipse.jgit.JGitText;
/** Indicates the request service is not enabled on a repository. */ /** Indicates the request service is not enabled on a repository. */
public class ServiceNotEnabledException extends Exception { public class ServiceNotEnabledException extends Exception {
@ -51,6 +51,6 @@ public class ServiceNotEnabledException extends Exception {
/** Indicates the request service is not available. */ /** Indicates the request service is not available. */
public ServiceNotEnabledException() { public ServiceNotEnabledException() {
super(HttpServerText.get().serviceNotEnabled); super(JGitText.get().serviceNotEnabledNoName);
} }
} }

25
org.eclipse.jgit.http.server/src/org/eclipse/jgit/http/server/resolver/UploadPackFactory.java → org.eclipse.jgit/src/org/eclipse/jgit/transport/resolver/UploadPackFactory.java
View File

@ -41,18 +41,21 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
package org.eclipse.jgit.http.server.resolver; package org.eclipse.jgit.transport.resolver;
import javax.servlet.http.HttpServletRequest;
import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.transport.UploadPack; import org.eclipse.jgit.transport.UploadPack;
/** Create and configure {@link UploadPack} service instance. */ /**
public interface UploadPackFactory { * Create and configure {@link UploadPack} service instance.
*
* @param <C>
* the connection type
*/
public interface UploadPackFactory<C> {
/** A factory disabling the UploadPack service for all repositories. */ /** A factory disabling the UploadPack service for all repositories. */
public static final UploadPackFactory DISABLED = new UploadPackFactory() { public static final UploadPackFactory<?> DISABLED = new UploadPackFactory<Object>() {
public UploadPack create(HttpServletRequest req, Repository db) public UploadPack create(Object req, Repository db)
throws ServiceNotEnabledException { throws ServiceNotEnabledException {
throw new ServiceNotEnabledException(); throw new ServiceNotEnabledException();
} }
@ -62,8 +65,8 @@ public UploadPack create(HttpServletRequest req, Repository db)
* Create and configure a new UploadPack instance for a repository. * Create and configure a new UploadPack instance for a repository.
* *
* @param req * @param req
* current HTTP request, in case information from the request may * current request, in case information from the request may help
* help configure the UploadPack instance. * configure the UploadPack instance.
* @param db * @param db
* the repository the upload would read from. * the repository the upload would read from.
* @return the newly configured UploadPack instance, must not be null. * @return the newly configured UploadPack instance, must not be null.
@ -74,6 +77,6 @@ public UploadPack create(HttpServletRequest req, Repository db)
* this factory refuses to create the instance for this HTTP * this factory refuses to create the instance for this HTTP
* request and repository, such as due to a permission error. * request and repository, such as due to a permission error.
*/ */
UploadPack create(HttpServletRequest req, Repository db) UploadPack create(C req, Repository db) throws ServiceNotEnabledException,
throws ServiceNotEnabledException, ServiceNotAuthorizedException; ServiceNotAuthorizedException;
} }