/// <summary>Execute this batch update.</summary>
/// <remarks>
/// Execute this batch update.
/// <p>
/// The default implementation of this method performs a sequential reference
/// update over each reference.
/// </remarks>
/// <param name="walk">
/// a RevWalk to parse tags in case the storage system wants to
/// store them pre-peeled, a common performance optimization.
/// </param>
/// <param name="update">progress monitor to receive update status on.</param>
/// <exception cref="System.IO.IOException">
/// the database is unable to accept the update. Individual
/// command status must be tested to determine if there is a
/// partial failure, or a total failure.
/// </exception>
public virtual void Execute(RevWalk walk, ProgressMonitor update)
{
update.BeginTask(JGitText.Get().updatingReferences, commands.Count);
foreach (ReceiveCommand cmd in commands)
{
try
{
update.Update(1);
if (cmd.GetResult() == ReceiveCommand.Result.NOT_ATTEMPTED)
{
cmd.UpdateType(walk);
RefUpdate ru = NewUpdate(cmd);
switch (cmd.GetType())
{
case ReceiveCommand.Type.DELETE:
{
cmd.SetResult(ru.Delete(walk));
continue;
goto case ReceiveCommand.Type.CREATE;
}
case ReceiveCommand.Type.CREATE:
case ReceiveCommand.Type.UPDATE:
case ReceiveCommand.Type.UPDATE_NONFASTFORWARD:
{
cmd.SetResult(ru.Update(walk));
continue;
}
}
}
}
catch (IOException err)
{
cmd.SetResult(ReceiveCommand.Result.REJECTED_OTHER_REASON, MessageFormat.Format(JGitText
.Get().lockError, err.Message));
}
}
update.EndTask();
}
/// <summary>
/// Check if an entry's content is different from the cache,
/// File status information is used and status is same we
/// consider the file identical to the state in the working
/// directory.
/// </summary>
/// <remarks>
/// Check if an entry's content is different from the cache,
/// File status information is used and status is same we
/// consider the file identical to the state in the working
/// directory. Native git uses more stat fields than we
/// have accessible in Java.
/// </remarks>
/// <param name="wd">working directory to compare content with</param>
/// <param name="forceContentCheck">
/// True if the actual file content
/// should be checked if modification time differs.
/// </param>
/// <returns>true if content is most likely different.</returns>
public virtual bool IsModified(FilePath wd, bool forceContentCheck)
{
if (this.IsAssumedValid())
{
return(false);
}
if (this.IsUpdateNeeded())
{
return(true);
}
FilePath file = this.GetFile(wd);
long length = file.Length();
if (length == 0)
{
if (!file.Exists())
{
return(true);
}
}
if (length != this.size)
{
return(true);
}
// JDK1.6 has file.canExecute
// if (file.canExecute() != FileMode.EXECUTABLE_FILE.equals(mode))
// return true;
int exebits = FileMode.EXECUTABLE_FILE.GetBits() ^ FileMode.REGULAR_FILE.GetBits(
);
if (this._enclosing.Config_filemode() && FileMode.EXECUTABLE_FILE.Equals(this.mode
))
{
if (!this._enclosing.File_canExecute(file) && this._enclosing.File_hasExecute())
{
return(true);
}
}
else
{
if (FileMode.REGULAR_FILE.Equals(this.mode & ~exebits))
{
if (!file.IsFile())
{
return(true);
}
if (this._enclosing.Config_filemode() && this._enclosing.File_canExecute(file) &&
this._enclosing.File_hasExecute())
{
return(true);
}
}
else
{
if (FileMode.SYMLINK.Equals(this.mode))
{
return(true);
}
else
{
if (FileMode.TREE.Equals(this.mode))
{
if (!file.IsDirectory())
{
return(true);
}
}
else
{
System.Console.Out.WriteLine(MessageFormat.Format(JGitText.Get().doesNotHandleMode
, this.mode, file));
return(true);
}
}
}
}
// Git under windows only stores seconds so we round the timestamp
// Java gives us if it looks like the timestamp in index is seconds
// only. Otherwise we compare the timestamp at millisecond prevision.
long javamtime = this.mtime / 1000000L;
long lastm = file.LastModified();
if (javamtime % 1000 == 0)
{
lastm = lastm - lastm % 1000;
}
if (lastm != javamtime)
{
if (!forceContentCheck)
{
return(true);
}
try
{
InputStream @is = new FileInputStream(file);
try
{
ObjectId newId = new ObjectInserter.Formatter().IdFor(Constants.OBJ_BLOB, file.Length
(), @is);
return(!newId.Equals(this.sha1));
}
catch (IOException e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
finally
{
try
{
@is.Close();
}
catch (IOException e)
{
// can't happen, but if it does we ignore it
Sharpen.Runtime.PrintStackTrace(e);
}
}
}
catch (FileNotFoundException e)
{
// should not happen because we already checked this
Sharpen.Runtime.PrintStackTrace(e);
throw new Error(e);
}
}
return(false);
}
/// <summary>Write content of index to disk.</summary>
/// <remarks>Write content of index to disk.</remarks>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
public virtual void Write()
{
CheckWriteOk();
FilePath tmpIndex = new FilePath(cacheFile.GetAbsoluteFile() + ".tmp");
FilePath Lock = new FilePath(cacheFile.GetAbsoluteFile() + ".lock");
if (!Lock.CreateNewFile())
{
throw new IOException(JGitText.Get().indexFileIsInUse);
}
try
{
FileOutputStream fileOutputStream = new FileOutputStream(tmpIndex);
FileChannel fc = fileOutputStream.GetChannel();
ByteBuffer buf = ByteBuffer.Allocate(4096);
MessageDigest newMessageDigest = Constants.NewMessageDigest();
header = new GitIndex.Header(entries);
header.Write(buf);
buf.Flip();
newMessageDigest.Update(((byte[])buf.Array()), buf.ArrayOffset(), buf.Limit());
fc.Write(buf);
buf.Flip();
buf.Clear();
for (Iterator i = entries.Values.Iterator(); i.HasNext();)
{
GitIndex.Entry e = (GitIndex.Entry)i.Next();
e.Write(buf);
buf.Flip();
newMessageDigest.Update(((byte[])buf.Array()), buf.ArrayOffset(), buf.Limit());
fc.Write(buf);
buf.Flip();
buf.Clear();
}
buf.Put(newMessageDigest.Digest());
buf.Flip();
fc.Write(buf);
fc.Close();
fileOutputStream.Close();
if (cacheFile.Exists())
{
if (db.FileSystem.RetryFailedLockFileCommit())
{
// file deletion fails on windows if another
// thread is reading the file concurrently
// So let's try 10 times...
bool deleted = false;
for (int i_1 = 0; i_1 < 10; i_1++)
{
if (cacheFile.Delete())
{
deleted = true;
break;
}
try
{
Sharpen.Thread.Sleep(100);
}
catch (Exception)
{
}
}
// ignore
if (!deleted)
{
throw new IOException(JGitText.Get().couldNotRenameDeleteOldIndex);
}
}
else
{
if (!cacheFile.Delete())
{
throw new IOException(JGitText.Get().couldNotRenameDeleteOldIndex);
}
}
}
if (!tmpIndex.RenameTo(cacheFile))
{
throw new IOException(JGitText.Get().couldNotRenameTemporaryIndexFileToIndex);
}
changed = false;
statDirty = false;
lastCacheTime = cacheFile.LastModified();
db.FireEvent(new IndexChangedEvent());
}
finally
{
if (!Lock.Delete())
{
throw new IOException(JGitText.Get().couldNotDeleteLockFileShouldNotHappen);
}
if (tmpIndex.Exists() && !tmpIndex.Delete())
{
throw new IOException(JGitText.Get().couldNotDeleteTemporaryIndexFileShouldNotHappen
);
}
}
}
/// <exception cref="System.IO.IOException"></exception>
private void ReadTree(byte[] raw)
{
int rawSize = raw.Length;
int rawPtr = 0;
TreeEntry[] temp;
int nextIndex = 0;
while (rawPtr < rawSize)
{
while (rawPtr < rawSize && raw[rawPtr] != 0)
{
rawPtr++;
}
rawPtr++;
rawPtr += Constants.OBJECT_ID_LENGTH;
nextIndex++;
}
temp = new TreeEntry[nextIndex];
rawPtr = 0;
nextIndex = 0;
while (rawPtr < rawSize)
{
int c = raw[rawPtr++];
if (c < '0' || c > '7')
{
throw new CorruptObjectException(GetId(), JGitText.Get().corruptObjectInvalidEntryMode
);
}
int mode = c - '0';
for (; ;)
{
c = raw[rawPtr++];
if (' ' == c)
{
break;
}
else
{
if (c < '0' || c > '7')
{
throw new CorruptObjectException(GetId(), JGitText.Get().corruptObjectInvalidMode
);
}
}
mode <<= 3;
mode += c - '0';
}
int nameLen = 0;
while (raw[rawPtr + nameLen] != 0)
{
nameLen++;
}
byte[] name = new byte[nameLen];
System.Array.Copy(raw, rawPtr, name, 0, nameLen);
rawPtr += nameLen + 1;
ObjectId id = ObjectId.FromRaw(raw, rawPtr);
rawPtr += Constants.OBJECT_ID_LENGTH;
TreeEntry ent;
if (FileMode.REGULAR_FILE.Equals(mode))
{
ent = new FileTreeEntry(this, id, name, false);
}
else
{
if (FileMode.EXECUTABLE_FILE.Equals(mode))
{
ent = new FileTreeEntry(this, id, name, true);
}
else
{
if (FileMode.TREE.Equals(mode))
{
ent = new NGit.Tree(this, id, name);
}
else
{
if (FileMode.SYMLINK.Equals(mode))
{
ent = new SymlinkTreeEntry(this, id, name);
}
else
{
if (FileMode.GITLINK.Equals(mode))
{
ent = new GitlinkTreeEntry(this, id, name);
}
else
{
throw new CorruptObjectException(GetId(), MessageFormat.Format(JGitText.Get().corruptObjectInvalidMode2
, Sharpen.Extensions.ToOctalString(mode)));
}
}
}
}
}
temp[nextIndex++] = ent;
}
contents = temp;
}
/// <summary>Parse an encoded type string into a type constant.</summary>
/// <remarks>Parse an encoded type string into a type constant.</remarks>
/// <param name="id">
/// object id this type string came from; may be null if that is
/// not known at the time the parse is occurring.
/// </param>
/// <param name="typeString">string version of the type code.</param>
/// <param name="endMark">
/// character immediately following the type string. Usually ' '
/// (space) or '\n' (line feed).
/// </param>
/// <param name="offset">
/// position within <code>typeString</code> where the parse
/// should start. Updated with the new position (just past
/// <code>endMark</code> when the parse is successful.
/// </param>
/// <returns>
/// a type code constant (one of
/// <see cref="OBJ_BLOB">OBJ_BLOB</see>
/// ,
/// <see cref="OBJ_COMMIT">OBJ_COMMIT</see>
/// ,
/// <see cref="OBJ_TAG">OBJ_TAG</see>
/// ,
/// <see cref="OBJ_TREE">OBJ_TREE</see>
/// .
/// </returns>
/// <exception cref="NGit.Errors.CorruptObjectException">there is no valid type identified by <code>typeString</code>.
/// </exception>
public static int DecodeTypeString(AnyObjectId id, byte[] typeString, byte endMark
, MutableInteger offset)
{
try
{
int position = offset.value;
switch (typeString[position])
{
case (byte)('b'):
{
if (typeString[position + 1] != 'l' || typeString[position + 2] != 'o' || typeString
[position + 3] != 'b' || typeString[position + 4] != endMark)
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
offset.value = position + 5;
return(NGit.Constants.OBJ_BLOB);
}
case (byte)('c'):
{
if (typeString[position + 1] != 'o' || typeString[position + 2] != 'm' || typeString
[position + 3] != 'm' || typeString[position + 4] != 'i' || typeString[position
+ 5] != 't' || typeString[position + 6] != endMark)
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
offset.value = position + 7;
return(NGit.Constants.OBJ_COMMIT);
}
case (byte)('t'):
{
switch (typeString[position + 1])
{
case (byte)('a'):
{
if (typeString[position + 2] != 'g' || typeString[position + 3] != endMark)
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
offset.value = position + 4;
return(NGit.Constants.OBJ_TAG);
}
case (byte)('r'):
{
if (typeString[position + 2] != 'e' || typeString[position + 3] != 'e' || typeString
[position + 4] != endMark)
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
offset.value = position + 5;
return(NGit.Constants.OBJ_TREE);
}
default:
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
}
goto default;
}
default:
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
}
}
catch (IndexOutOfRangeException)
{
throw new CorruptObjectException(id, JGitText.Get().corruptObjectInvalidType);
}
}
public override string GetDescription()
{
return(JGitText.Get().repositoryState_bisecting);
}
public override string GetDescription()
{
return(JGitText.Get().repositoryState_rebaseInteractive);
}
public override string GetDescription()
{
return(JGitText.Get().repositoryState_rebaseWithMerge);
}
public override string GetDescription()
{
return(JGitText.Get().repositoryState_applyMailbox);
}
public override string GetDescription()
{
return(JGitText.Get().repositoryState_conflicts);
}
