public JGitFileSystemProvider() { fullHostName = DAEMON_ENABLED ? DAEMON_HOST + ":" + DAEMON_PORT : null; final String[] repos = FILE_REPOSITORIES_ROOT.list( new FilenameFilter() { @Override public boolean accept( final File dir, String name ) { return name.endsWith( DOT_GIT_EXT ); } } ); if ( repos != null ) { for ( final String repo : repos ) { final File repoDir = new File( FILE_REPOSITORIES_ROOT, repo ); if ( repoDir.isDirectory() ) { final String name = repoDir.getName().substring( 0, repoDir.getName().indexOf( DOT_GIT_EXT ) ); final JGitFileSystem fs = new JGitFileSystem( this, fullHostName, newRepository( repoDir, true ), name, ALL, buildCredential( null ) ); fileSystems.put( name, fs ); repoIndex.put( fs.gitRepo().getRepository(), fs ); } } } if ( DAEMON_ENABLED ) { buildAndStartDaemon(); } else { daemonService = null; } }
@Override public String uri() { return fs.getPath( commit.name(), path ).toUri().toString(); } } );
@Before public void setup() { when(fs.getSeparator()).thenReturn("/"); when(fs.provider()).thenReturn(fsp); when(fsp.isDefault()).thenReturn(false); when(fsp.getScheme()).thenReturn("git"); }
@Override public Path getPath( final String first, final String... more ) throws InvalidPathException { checkClose(); if ( first == null || first.trim().isEmpty() ) { return new JGitFSPath( this ); } if ( more == null || more.length == 0 ) { return JGitPathImpl.create( this, first, JGitPathImpl.DEFAULT_REF_TREE + "@" + name, false ); } final StringBuilder sb = new StringBuilder(); for ( final String segment : more ) { if ( segment.length() > 0 ) { if ( sb.length() > 0 ) { sb.append( getSeparator() ); } sb.append( segment ); } } return JGitPathImpl.create( this, sb.toString(), first + "@" + name, false ); }
private boolean deleteRepo( final FileSystem fileSystem ) { final File gitDir = ( (JGitFileSystem) fileSystem ).gitRepo().getRepository().getDirectory(); fileSystem.close(); try { FileUtils.delete( gitDir, FileUtils.RECURSIVE ); closedFileSystems.remove( fileSystem ); fileSystems.remove( ( (JGitFileSystem) fileSystem ).id() ); return true; } catch ( java.io.IOException e ) { throw new IOException( e ); } }
@Test(expected = IllegalStateException.class) public void testClose() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); assertThat( fileSystem.isReadOnly() ).isFalse(); assertThat( fileSystem.getSeparator() ).isEqualTo( "/" ); assertThat( fileSystem.getName() ).isEqualTo( "my-repo" ); assertThat( fileSystem.isOpen() ).isTrue(); assertThat( fileSystem.getFileStores() ).isNotNull(); fileSystem.close(); assertThat( fileSystem.isOpen() ).isFalse(); assertThat( fileSystem.getFileStores() ).isNotNull(); }
@Test public void testOnlyLocalRoot() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); assertThat( fileSystem.isReadOnly() ).isFalse(); assertThat( fileSystem.getSeparator() ).isEqualTo( "/" ); assertThat( fileSystem.getName() ).isEqualTo( "my-repo" ); assertThat( fileSystem.getRootDirectories() ).hasSize( 1 ); final Path root = fileSystem.getRootDirectories().iterator().next(); assertThat( root.toString() ).isEqualTo( "/" ); assertThat( root.getRoot().toString() ).isEqualTo( "/" ); }
@Test public void testPathEqualsWithDifferentRepos() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git1 = setupGit(); final JGitFileSystem fileSystem1 = new JGitFileSystem( fsProvider, null, git1, "my-repo1", CredentialsProvider.getDefault() ); final Git git2 = setupGit(); final JGitFileSystem fileSystem2 = new JGitFileSystem( fsProvider, null, git2, "my-repo2", CredentialsProvider.getDefault() ); final Path path1 = fileSystem1.getPath( "master", "/path/to/some.txt" ); final Path path2 = fileSystem2.getPath( "master", "/path/to/some.txt" ); assertThat( path1 ).isNotEqualTo( path2 ); assertThat( path1 ).isEqualTo( fileSystem1.getPath( "/path/to/some.txt" ) ); }
@Test public void testProvider() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); assertThat( fileSystem.getName() ).isEqualTo( "my-repo" ); assertThat( fileSystem.isReadOnly() ).isFalse(); assertThat( fileSystem.getSeparator() ).isEqualTo( "/" ); assertThat( fileSystem.provider() ).isEqualTo( fsProvider ); }
@Override public Repository open( final DaemonClient client, final String name ) throws RepositoryNotFoundException, ServiceNotAuthorizedException, ServiceNotEnabledException, ServiceMayNotContinueException { final JGitFileSystem fs = fileSystems.get( name ); if ( fs == null ) { throw new RepositoryNotFoundException( name ); } return fs.gitRepo().getRepository(); } }
@Test public void testSupportedFileAttributeViews() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); assertThat( fileSystem.isReadOnly() ).isFalse(); assertThat( fileSystem.getSeparator() ).isEqualTo( "/" ); assertThat( fileSystem.getName() ).isEqualTo( "my-repo" ); assertThat( fileSystem.supportedFileAttributeViews() ).isNotEmpty().hasSize( 2 ).contains( "basic", "version" ); }
final ObjectId newHead ) { final String host = tree + "@" + fs.getName(); final Path root = JGitPathImpl.createRoot( fs, "/", host, false ); final List<DiffEntry> diff = getDiff( fs.gitRepo().getRepository(), oldHead, newHead ); final List<WatchEvent<?>> events = new ArrayList<WatchEvent<?>>( diff.size() ); JGitPathInfo pathInfo = resolvePath( fs.gitRepo(), tree, diffEntry.getNewPath() ); newPath = JGitPathImpl.create( fs, "/" + pathInfo.getPath(), host, pathInfo.getObjectId(), false ); } else { fs.publishEvents( root, events );
@Test public void testSimpleBranchedGitRoot() { when(fs.getSeparator()).thenReturn("/"); final Path path = JGitPathImpl.create(fs, "/", "master@my-host", false); assertThat(path).isNotNull(); assertThat(path.isAbsolute()).isTrue(); assertThat(path.toString()).isEqualTo("/"); assertThat(path.toUri().toString()).isEqualTo("git://master@my-host/"); assertThat(path.getRoot().toString()).isEqualTo("/"); assertThat(path.getNameCount()).isEqualTo(0); }
@Test(expected = UnsupportedOperationException.class) public void testGetUserPrincipalLookupService() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); fileSystem.getUserPrincipalLookupService(); }
@Test(expected = UnsupportedOperationException.class) public void testGetPathMatcher() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); fileSystem.getPathMatcher( "*" ); } }
@Override public FileSystem getFileSystem( final URI uri ) throws IllegalArgumentException, FileSystemNotFoundException, SecurityException { checkNotNull( "uri", uri ); checkCondition( "uri scheme not supported", uri.getScheme().equals( getScheme() ) || uri.getScheme().equals( "default" ) ); checkURI( "uri", uri ); final JGitFileSystem fileSystem = fileSystems.get( extractRepoName( uri ) ); if ( fileSystem == null ) { throw new FileSystemNotFoundException( "No filesystem for uri (" + uri + ") found." ); } if ( hasSyncFlag( uri ) ) { try { final String treeRef = "master"; final ObjectId oldHead = JGitUtil.getTreeRefObjectId( fileSystem.gitRepo().getRepository(), treeRef ); final Map<String, String> params = getQueryParams( uri ); syncRepository( fileSystem.gitRepo(), fileSystem.getCredential(), params.get( "sync" ), hasForceFlag( uri ) ); final ObjectId newHead = JGitUtil.getTreeRefObjectId( fileSystem.gitRepo().getRepository(), treeRef ); notifyDiffs( fileSystem, treeRef, "<system>", "<system>", oldHead, newHead ); } catch ( final Exception ex ) { throw new IOException( ex ); } } return fileSystem; }
@Test(expected = UnsupportedOperationException.class) @Ignore public void testNewWatchService() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final Git git = setupGit(); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); fileSystem.newWatchService(); }
@Test public void testFileStore() throws IOException, GitAPIException { final JGitFileSystemProvider fsProvider = mock( JGitFileSystemProvider.class ); final File tempDir = createTempDirectory(); final Git git = setupGit( tempDir ); final JGitFileSystem fileSystem = new JGitFileSystem( fsProvider, null, git, "my-repo", CredentialsProvider.getDefault() ); assertThat( fileSystem.getFileStores() ).hasSize( 1 ); final FileStore fileStore = fileSystem.getFileStores().iterator().next(); assertThat( fileStore ).isNotNull(); assertThat( fileStore.getTotalSpace() ).isEqualTo( tempDir.getTotalSpace() ); assertThat( fileStore.getUsableSpace() ).isEqualTo( tempDir.getUsableSpace() ); }
@Override public File toFile() throws UnsupportedOperationException { if ( file == null ) { synchronized ( this ) { if ( isRegularFile() ) { try { file = File.createTempFile( "git", "temp" ); final InputStream in = getFileSystem().provider().newInputStream( this ); final OutputStream out = new FileOutputStream( file ); internalCopy( in, out ); in.close(); out.close(); } catch ( final Exception ex ) { file = null; } } else { throw new UnsupportedOperationException(); } } } return file; }
@Override public Set<String> supportedFileAttributeViews() { checkClose(); return SUPPORTED_ATTR_VIEWS; }