public virtual void Test001_Initalize()
{
FilePath gitdir = new FilePath(trash, Constants.DOT_GIT);
FilePath hooks = new FilePath(gitdir, "hooks");
FilePath objects = new FilePath(gitdir, "objects");
FilePath objects_pack = new FilePath(objects, "pack");
FilePath objects_info = new FilePath(objects, "info");
FilePath refs = new FilePath(gitdir, "refs");
FilePath refs_heads = new FilePath(refs, "heads");
FilePath refs_tags = new FilePath(refs, "tags");
FilePath HEAD = new FilePath(gitdir, "HEAD");
NUnit.Framework.Assert.IsTrue(trash.IsDirectory(), "Exists " + trash);
NUnit.Framework.Assert.IsTrue(hooks.IsDirectory(), "Exists " + hooks);
NUnit.Framework.Assert.IsTrue(objects.IsDirectory(), "Exists " + objects);
NUnit.Framework.Assert.IsTrue(objects_pack.IsDirectory(), "Exists " + objects_pack
);
NUnit.Framework.Assert.IsTrue(objects_info.IsDirectory(), "Exists " + objects_info
);
NUnit.Framework.Assert.AreEqual(2L, objects.ListFiles().Length);
NUnit.Framework.Assert.IsTrue(refs.IsDirectory(), "Exists " + refs);
NUnit.Framework.Assert.IsTrue(refs_heads.IsDirectory(), "Exists " + refs_heads);
NUnit.Framework.Assert.IsTrue(refs_tags.IsDirectory(), "Exists " + refs_tags);
NUnit.Framework.Assert.IsTrue(HEAD.IsFile(), "Exists " + HEAD);
NUnit.Framework.Assert.AreEqual(23, HEAD.Length());
}
public BlobStore(string path)
{
this.path = path;
FilePath directory = new FilePath(path);
directory.Mkdirs();
if (!directory.IsDirectory()) {
throw new InvalidOperationException(string.Format("Unable to create directory for: {0}", directory));
}
}
public static FilePath[] RecursiveListFiles(FilePath dir, FileFilter filter)
{
if (!dir.IsDirectory())
{
throw new ArgumentException(dir + " is not a directory");
}
IList<FilePath> fileList = new List<FilePath>();
RecursiveListFilesHelper(dir, filter, fileList);
return Sharpen.Collections.ToArray(fileList, new FilePath[fileList.Count]);
}
public static bool DeleteRecursive(FilePath fileOrDirectory)
{
if (fileOrDirectory.IsDirectory())
{
foreach (FilePath child in fileOrDirectory.ListFiles())
{
DeleteRecursive(child);
}
}
bool result = fileOrDirectory.Delete() || !fileOrDirectory.Exists();
return result;
}
public override bool Accept(FilePath f)
{
if (f.IsDirectory())
{
return true;
}
string name = f.GetName();
int i = name.LastIndexOf('.');
if (i > 0 && i < name.Length - 1)
{
string ext = Sharpen.Runtime.Substring(name, i + 1).ToLower();
if (ext.Equals("js"))
{
return true;
}
}
return false;
}
public BlobStore(string path, SymmetricKey encryptionKey)
{
if (path == null) {
throw new ArgumentNullException("path");
}
_path = path;
EncryptionKey = encryptionKey;
FilePath directory = new FilePath(path);
if (directory.Exists() && directory.IsDirectory()) {
// Existing blob-store.
VerifyExistingStore();
} else {
// New blob store; create directory:
directory.Mkdirs();
if (!directory.IsDirectory()) {
throw new InvalidOperationException(string.Format("Unable to create directory for: {0}", directory));
}
if (encryptionKey != null) {
MarkEncrypted(true);
}
}
}
/// <exception cref="System.IO.IOException"></exception>
internal virtual void PrescanTwoTrees()
{
new IndexTreeWalker(index, head, merge, root, new _AbstractIndexTreeVisitor_267(this
)).Walk();
// if there's a conflict, don't list it under
// to-be-removed, since that messed up our next
// section
removed.RemoveAll(conflicts);
foreach (string path in updated.Keys)
{
if (index.GetEntry(path) == null)
{
FilePath file = new FilePath(root, path);
if (file.IsFile())
{
conflicts.AddItem(path);
}
else
{
if (file.IsDirectory())
{
CheckConflictsWithFile(file);
}
}
}
}
conflicts.RemoveAll(removed);
}
public FileInfo TempDir()
{
FilePath directory = new FilePath(path);
FilePath tempDirectory = new FilePath(directory, "temp_attachments");
tempDirectory.Mkdirs();
if (!tempDirectory.IsDirectory())
{
throw new InvalidOperationException(string.Format("Unable to create directory for: {0}"
, tempDirectory));
}
return tempDirectory;
}
/// <summary>Get submodule repository at path</summary>
/// <param name="parent"></param>
/// <param name="path"></param>
/// <returns>repository or null if repository doesn't exist</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
public static Repository GetSubmoduleRepository(FilePath parent, string path)
{
FilePath subWorkTree = new FilePath(parent, path);
if (!subWorkTree.IsDirectory())
{
return null;
}
FilePath workTree = new FilePath(parent, path);
try
{
return new RepositoryBuilder().SetMustExist(true).SetFS(FS.DETECTED).SetWorkTree(
workTree).Build();
}
catch (RepositoryNotFoundException)
{
//
//
//
//
return null;
}
}
public Manager(Context context, ManagerOptions options)
{
Log.I(Database.Tag, "Starting Manager version: %s", Couchbase.Lite.Manager.Version
);
this.context = context;
this.directoryFile = context.GetFilesDir();
this.options = (options != null) ? options : DefaultOptions;
this.databases = new Dictionary<string, Database>();
this.replications = new AList<Replication>();
directoryFile.Mkdirs();
if (!directoryFile.IsDirectory())
{
throw new IOException(string.Format("Unable to create directory for: %s", directoryFile
));
}
UpgradeOldDatabaseFiles(directoryFile);
workExecutor = Executors.NewSingleThreadScheduledExecutor();
}
public virtual void TestMergeNonVersionedPaths()
{
Git git = new Git(db);
WriteTrashFile("a", "1\na\n3\n");
WriteTrashFile("b", "1\nb\n3\n");
WriteTrashFile("c/c/c", "1\nc\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").AddFilepattern("c/c/c").Call();
RevCommit initialCommit = git.Commit().SetMessage("initial").Call();
CreateBranch(initialCommit, "refs/heads/side");
CheckoutBranch("refs/heads/side");
WriteTrashFile("a", "1\na(side)\n3\n");
WriteTrashFile("b", "1\nb(side)\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("b").Call();
RevCommit secondCommit = git.Commit().SetMessage("side").Call();
NUnit.Framework.Assert.AreEqual("1\nb(side)\n3\n", Read(new FilePath(db.WorkTree,
"b")));
CheckoutBranch("refs/heads/master");
NUnit.Framework.Assert.AreEqual("1\nb\n3\n", Read(new FilePath(db.WorkTree, "b"))
);
WriteTrashFile("a", "1\na(main)\n3\n");
WriteTrashFile("c/c/c", "1\nc(main)\n3\n");
git.Add().AddFilepattern("a").AddFilepattern("c/c/c").Call();
git.Commit().SetMessage("main").Call();
WriteTrashFile("d", "1\nd\n3\n");
NUnit.Framework.Assert.IsTrue(new FilePath(db.WorkTree, "e").Mkdir());
MergeCommandResult result = git.Merge().Include(secondCommit.Id).SetStrategy(MergeStrategy
.RESOLVE).Call();
NUnit.Framework.Assert.AreEqual(MergeStatus.CONFLICTING, result.GetMergeStatus());
NUnit.Framework.Assert.AreEqual("1\n<<<<<<< HEAD\na(main)\n=======\na(side)\n>>>>>>> 86503e7e397465588cc267b65d778538bffccb83\n3\n"
, Read(new FilePath(db.WorkTree, "a")));
NUnit.Framework.Assert.AreEqual("1\nb(side)\n3\n", Read(new FilePath(db.WorkTree,
"b")));
NUnit.Framework.Assert.AreEqual("1\nc(main)\n3\n", Read(new FilePath(db.WorkTree,
"c/c/c")));
NUnit.Framework.Assert.AreEqual("1\nd\n3\n", Read(new FilePath(db.WorkTree, "d"))
);
FilePath dir = new FilePath(db.WorkTree, "e");
NUnit.Framework.Assert.IsTrue(dir.IsDirectory());
NUnit.Framework.Assert.AreEqual(1, result.GetConflicts().Count);
NUnit.Framework.Assert.AreEqual(3, result.GetConflicts().Get("a")[0].Length);
NUnit.Framework.Assert.AreEqual(RepositoryState.MERGING, db.GetRepositoryState());
}
/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
/// <exception cref="System.IO.IOException"></exception>
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="NGit.Errors.CheckoutConflictException"></exception>
/// <exception cref="NGit.Errors.IndexWriteException"></exception>
private bool DoCheckout()
{
toBeDeleted.Clear();
ObjectReader objectReader = repo.ObjectDatabase.NewReader();
try
{
if (headCommitTree != null)
{
PreScanTwoTrees();
}
else
{
PrescanOneTree();
}
if (!conflicts.IsEmpty())
{
if (failOnConflict)
{
throw new NGit.Errors.CheckoutConflictException(Sharpen.Collections.ToArray(conflicts
, new string[conflicts.Count]));
}
else
{
CleanUpConflicts();
}
}
// update our index
builder.Finish();
FilePath file = null;
string last = string.Empty;
// when deleting files process them in the opposite order as they have
// been reported. This ensures the files are deleted before we delete
// their parent folders
for (int i = removed.Count - 1; i >= 0; i--)
{
string r = removed[i];
file = new FilePath(repo.WorkTree, r);
if (!file.Delete() && file.Exists())
{
// The list of stuff to delete comes from the index
// which will only contain a directory if it is
// a submodule, in which case we shall not attempt
// to delete it. A submodule is not empty, so it
// is safe to check this after a failed delete.
if (!file.IsDirectory())
{
toBeDeleted.AddItem(r);
}
}
else
{
if (!IsSamePrefix(r, last))
{
RemoveEmptyParents(new FilePath(repo.WorkTree, last));
}
last = r;
}
}
if (file != null)
{
RemoveEmptyParents(file);
}
foreach (string path in updated.Keys)
{
// ... create/overwrite this file ...
file = new FilePath(repo.WorkTree, path);
if (!file.GetParentFile().Mkdirs())
{
}
// ignore
DirCacheEntry entry = dc.GetEntry(path);
// submodules are handled with separate operations
if (FileMode.GITLINK.Equals(entry.RawMode))
{
continue;
}
CheckoutEntry(repo, file, entry, objectReader);
}
// commit the index builder - a new index is persisted
if (!builder.Commit())
{
throw new IndexWriteException();
}
}
finally
{
objectReader.Release();
}
return toBeDeleted.Count == 0;
}
// Oh well. They don't have a known hosts in home.
// Oh well. They don't have a known hosts in home.
private static void Identities(JSch sch, FS fs)
{
FilePath home = fs.UserHome();
if (home == null)
{
return;
}
FilePath sshdir = new FilePath(home, ".ssh");
if (sshdir.IsDirectory())
{
LoadIdentity(sch, new FilePath(sshdir, "identity"));
LoadIdentity(sch, new FilePath(sshdir, "id_rsa"));
LoadIdentity(sch, new FilePath(sshdir, "id_dsa"));
}
}
public bool Accept(FilePath pathname)
{
return pathname.IsDirectory() && !pathname.GetName().Equals("CVS");
}
/// <summary>
/// Creates the directory named by this abstract pathname, including any
/// necessary but nonexistent parent directories.
/// </summary>
/// <remarks>
/// Creates the directory named by this abstract pathname, including any
/// necessary but nonexistent parent directories. Note that if this operation
/// fails it may have succeeded in creating some of the necessary parent
/// directories.
/// </remarks>
/// <param name="d">directory to be created</param>
/// <param name="skipExisting">
/// if
/// <code>true</code>
/// skip creation of the given directory if it
/// already exists in the file system
/// </param>
/// <exception cref="System.IO.IOException">
/// if creation of
/// <code>d</code>
/// fails. This may occur if
/// <code>d</code>
/// did exist when the method was called. This can therefore
/// cause IOExceptions during race conditions when multiple
/// concurrent threads all try to create the same directory.
/// </exception>
public static void Mkdirs(FilePath d, bool skipExisting)
{
if (!d.Mkdirs())
{
if (skipExisting && d.IsDirectory())
{
return;
}
throw new IOException(MessageFormat.Format(JGitText.Get().mkDirsFailed, d.GetAbsolutePath
()));
}
}
private void CheckConflictsWithFile(FilePath file)
{
if (file.IsDirectory())
{
AList<string> childFiles = ListFiles(file);
Sharpen.Collections.AddAll(conflicts, childFiles);
}
else
{
FilePath parent = file.GetParentFile();
while (!parent.Equals(root))
{
if (parent.IsDirectory())
{
break;
}
if (parent.IsFile())
{
conflicts.AddItem(Repository.StripWorkDir(root, parent));
break;
}
parent = parent.GetParentFile();
}
}
}
internal FileEntry(FilePath f, FS fs)
{
file = f;
if (f.IsDirectory())
{
if (new FilePath(f, Constants.DOT_GIT).Exists())
{
mode = FileMode.GITLINK;
}
else
{
mode = FileMode.TREE;
}
}
else
{
if (fs.CanExecute(file))
{
mode = FileMode.EXECUTABLE_FILE;
}
else
{
mode = FileMode.REGULAR_FILE;
}
}
}
public virtual void TestMkdir()
{
FilePath d = new FilePath(trash, "test");
FileUtils.Mkdir(d);
NUnit.Framework.Assert.IsTrue(d.Exists() && d.IsDirectory());
try
{
FileUtils.Mkdir(d);
NUnit.Framework.Assert.Fail("creation of existing directory must fail");
}
catch (IOException)
{
}
// expected
FileUtils.Mkdir(d, true);
NUnit.Framework.Assert.IsTrue(d.Exists() && d.IsDirectory());
NUnit.Framework.Assert.IsTrue(d.Delete());
FilePath f = new FilePath(trash, "test");
FileUtils.CreateNewFile(f);
try
{
FileUtils.Mkdir(d);
NUnit.Framework.Assert.Fail("creation of directory having same path as existing file must"
+ " fail");
}
catch (IOException)
{
}
// expected
NUnit.Framework.Assert.IsTrue(f.Delete());
}
/// <exception cref="System.IO.IOException"></exception>
public static void CopyFolder(FilePath src, FilePath dest)
{
if (src.IsDirectory())
{
//if directory not exists, create it
if (!dest.Exists())
{
dest.Mkdir();
}
//list all the directory contents
string[] files = src.List();
foreach (string file in files)
{
//construct the src and dest file structure
FilePath srcFile = new FilePath(src, file);
FilePath destFile = new FilePath(dest, file);
//recursive copy
CopyFolder(srcFile, destFile);
}
}
else
{
CopyFile(src, dest);
}
}
public virtual void TestMkdirs()
{
FilePath root = new FilePath(trash, "test");
NUnit.Framework.Assert.IsTrue(root.Mkdir());
FilePath d = new FilePath(root, "test/test");
FileUtils.Mkdirs(d);
NUnit.Framework.Assert.IsTrue(d.Exists() && d.IsDirectory());
try
{
FileUtils.Mkdirs(d);
NUnit.Framework.Assert.Fail("creation of existing directory hierarchy must fail");
}
catch (IOException)
{
}
// expected
FileUtils.Mkdirs(d, true);
NUnit.Framework.Assert.IsTrue(d.Exists() && d.IsDirectory());
FileUtils.Delete(root, FileUtils.RECURSIVE);
FilePath f = new FilePath(trash, "test");
FileUtils.CreateNewFile(f);
try
{
FileUtils.Mkdirs(d);
NUnit.Framework.Assert.Fail("creation of directory having path conflicting with existing"
+ " file must fail");
}
catch (IOException)
{
}
// expected
NUnit.Framework.Assert.IsTrue(f.Delete());
}
/// <summary>Delete file or folder</summary>
/// <param name="f">
/// <code>File</code>
/// to be deleted
/// </param>
/// <param name="options">
/// deletion options,
/// <code>RECURSIVE</code>
/// for recursive deletion of
/// a subtree,
/// <code>RETRY</code>
/// to retry when deletion failed.
/// Retrying may help if the underlying file system doesn't allow
/// deletion of files being read by another thread.
/// </param>
/// <exception cref="System.IO.IOException">
/// if deletion of
/// <code>f</code>
/// fails. This may occur if
/// <code>f</code>
/// didn't exist when the method was called. This can therefore
/// cause IOExceptions during race conditions when multiple
/// concurrent threads all try to delete the same file.
/// </exception>
public static void Delete(FilePath f, int options)
{
if ((options & SKIP_MISSING) != 0 && !f.Exists())
{
return;
}
if ((options & RECURSIVE) != 0 && f.IsDirectory())
{
FilePath[] items = f.ListFiles();
if (items != null)
{
foreach (FilePath c in items)
{
Delete(c, options);
}
}
}
if (!f.Delete())
{
if ((options & RETRY) != 0 && f.Exists())
{
for (int i = 1; i < 10; i++)
{
try
{
Sharpen.Thread.Sleep(100);
}
catch (Exception)
{
}
// ignore
if (f.Delete())
{
return;
}
}
}
throw new IOException(MessageFormat.Format(JGitText.Get().deleteFileFailed, f.GetAbsolutePath
()));
}
}
/// <exception cref="NSch.SftpException"></exception>
public virtual void Get(string src, string dst, SftpProgressMonitor monitor, int
mode)
{
// System.out.println("get: "+src+" "+dst);
src = RemoteAbsolutePath(src);
dst = LocalAbsolutePath(dst);
try
{
ArrayList v = Glob_remote(src);
int vsize = v.Count;
if (vsize == 0)
{
throw new SftpException(SSH_FX_NO_SUCH_FILE, "No such file");
}
FilePath dstFile = new FilePath(dst);
bool isDstDir = dstFile.IsDirectory();
StringBuilder dstsb = null;
if (isDstDir)
{
if (!dst.EndsWith(file_separator))
{
dst += file_separator;
}
dstsb = new StringBuilder(dst);
}
else
{
if (vsize > 1)
{
throw new SftpException(SSH_FX_FAILURE, "Copying multiple files, but destination is missing or a file."
);
}
}
for (int j = 0; j < vsize; j++)
{
string _src = (string)(v[j]);
SftpATTRS attr = _stat(_src);
if (attr.IsDir())
{
throw new SftpException(SSH_FX_FAILURE, "not supported to get directory " + _src);
}
string _dst = null;
if (isDstDir)
{
int i = _src.LastIndexOf('/');
if (i == -1)
{
dstsb.Append(_src);
}
else
{
dstsb.Append(Sharpen.Runtime.Substring(_src, i + 1));
}
_dst = dstsb.ToString();
dstsb.Delete(dst.Length, _dst.Length);
}
else
{
_dst = dst;
}
if (mode == RESUME)
{
long size_of_src = attr.GetSize();
long size_of_dst = new FilePath(_dst).Length();
if (size_of_dst > size_of_src)
{
throw new SftpException(SSH_FX_FAILURE, "failed to resume for " + _dst);
}
if (size_of_dst == size_of_src)
{
return;
}
}
if (monitor != null)
{
monitor.Init(SftpProgressMonitor.GET, _src, _dst, attr.GetSize());
if (mode == RESUME)
{
monitor.Count(new FilePath(_dst).Length());
}
}
FileOutputStream fos = null;
try
{
if (mode == OVERWRITE)
{
fos = new FileOutputStream(_dst);
}
else
{
fos = new FileOutputStream(_dst, true);
}
// append
// System.err.println("_get: "+_src+", "+_dst);
_get(_src, fos, monitor, mode, new FilePath(_dst).Length());
}
finally
{
if (fos != null)
{
fos.Close();
}
}
}
}
catch (Exception e)
{
if (e is SftpException)
{
throw (SftpException)e;
}
if (e is Exception)
{
throw new SftpException(SSH_FX_FAILURE, string.Empty, (Exception)e);
}
throw new SftpException(SSH_FX_FAILURE, string.Empty);
}
}
/// <exception cref="System.IO.IOException"></exception>
private void CreateDir(FilePath f)
{
if (!f.IsDirectory() && !f.Mkdirs())
{
FilePath p = f;
while (p != null && !p.Exists())
{
p = p.GetParentFile();
}
if (p == null || p.IsDirectory())
{
throw new IOException(JGitText.Get().cannotCreateDirectory);
}
FileUtils.Delete(p);
if (!f.Mkdirs())
{
throw new IOException(JGitText.Get().cannotCreateDirectory);
}
}
}
public Manager(FilePath directoryFile, ManagerOptions options)
{
this.directoryFile = directoryFile;
this.options = (options != null) ? options : DefaultOptions;
this.databases = new Dictionary<string, Database>();
this.replications = new AList<Replication>();
directoryFile.Mkdirs();
if (!directoryFile.IsDirectory())
{
throw new IOException(string.Format("Unable to create directory for: %s", directoryFile
));
}
UpgradeOldDatabaseFiles(directoryFile);
workExecutor = Executors.NewSingleThreadScheduledExecutor();
}