protected override void ExecuteSVNTask(SvnClient client)
{
if (Dir == null)
{
Dir = new DirectoryInfo(Project.BaseDirectory);
}
if (!Dir.Exists)
{
throw new BuildException(string.Format(Resources.MissingDirectory, Dir.FullName), Location);
}
string sourcesFolder = string.Concat(Dir.FullName, @"\Sources");
if (Directory.Exists(sourcesFolder))
{
Log(Level.Info, Resources.SVNAdding, Dir.FullName);
SvnAddArgs addArgs = new SvnAddArgs();
addArgs.Depth = SvnDepth.Infinity;
addArgs.Force = true;
client.Add(sourcesFolder, addArgs);
}
else
{
Log(Level.Info, Resources.SVNSourcesFolderNotFound, sourcesFolder);
}
Log(Level.Info, Resources.SVNCommitCommitting, Dir.FullName, Message);
SvnCommitArgs args = new SvnCommitArgs();
args.LogMessage = Message;
args.ThrowOnError = true;
SvnCommitResult result;
client.Commit(Dir.FullName, args, out result);
if (result != null)
{
Log(Level.Info, Resources.SVNCommitResult, Dir.FullName, result.Revision, result.Author);
}
}
public void Commit_CommitWithNonAnsiCharsInLogMessage()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.AnkhSvnCases);
string WcPath = sbox.Wc;
string filepath = Path.Combine(WcPath, "Form.cs");
using (StreamWriter w = new StreamWriter(filepath))
w.Write("Moo");
SvnCommitArgs a = new SvnCommitArgs();
a.LogMessage = " ¥ · £ · € · $ · ¢ · ₡ · ₢ · ₣ · ₤ · ₥ · ₦ · ₧ · ₨ · ₩ · ₪ · ₫ · ₭ · ₮ · ₯";
Assert.That(Client.Commit(WcPath, a));
SvnLogArgs la = new SvnLogArgs();
la.Start = SvnRevision.Head;
la.End = SvnRevision.Head;
Collection <SvnLogEventArgs> logList;
Client.GetLog(WcPath, la, out logList);
Assert.That(logList, Is.Not.Null);
Assert.That(logList.Count, Is.EqualTo(1));
Assert.That(logList[0].LogMessage, Is.EqualTo(a.LogMessage));
}
/// <summary>
/// 提交SVN
/// </summary>
/// <param name="path"></param>
/// <param name="UserName"></param>
/// <param name="Password"></param>
public void CommitSvn(string path, string UserName, string Password)
{
//Authentication 身份验证
_client.Authentication.Clear();
_client.Authentication.UserNamePasswordHandlers
+= delegate(object obj, SharpSvn.Security.SvnUserNamePasswordEventArgs args)
{
args.UserName = UserName;
args.Password = Password;
};
//_client.Authentication.SslServerTrustHandlers +=
//delegate(object sender, SvnSslServerTrustEventArgs e)
//{
// e.AcceptedFailures = e.Failures;
// e.Save = true; //证书 Save acceptance to authentication store
//};
var ca = new SvnCommitArgs {
LogMessage = "提交信息"
};
//"svn log message created at " + DateTime.Now.ToString();
bool action = _client.Commit(path, ca);
if (action)
{
Console.WriteLine(" OK! 提交SVN成功> " + path);
}
else
{
Console.WriteLine(" ERR!!! 提交SVN失败> " + path);
}
}
public bool commit(UsuarioSVN usuSVN, string Mensaje)
{
bool EsCorrecto = true;
SvnUpdateResult result;
SvnCommitArgs ca = new SvnCommitArgs();
using (SvnClient client = new SvnClient())
{
try
{
client.Authentication.ForceCredentials(usuSVN.Nombre, usuSVN.Contraseña);
//SvnUriTarget is a wrapper class for SVN repository URIs
SvnUriTarget target = new SvnUriTarget(usuSVN.URL);
client.Authentication.SslServerTrustHandlers += new EventHandler <SharpSvn.Security.SvnSslServerTrustEventArgs>(Authentication_SslServerTrustHandlers);
// Checkout the code to the specified directory
client.CheckOut(target, usuSVN.RutaLocal);
// Update the specified working copy path to the head revision
//client.Update("c:\\sharpsvn");
client.Update(usuSVN.RutaLocal, out result);
ca.LogMessage = "Mensaje";
client.Commit(usuSVN.RutaLocal, ca);
}
catch
{
EsCorrecto = false;
}
return(EsCorrecto);
}
}
public bool CommitWorkingCopy()
{
SvnCommitArgs commitArgs = new SvnCommitArgs();
commitArgs.Notify += new EventHandler <SvnNotifyEventArgs>(CommitNotifyHandler);
commitArgs.Depth = SvnDepth.Infinity;
commitArgs.LogMessage = "user commit: " + _Username;
//commitArgs.ThrowOnError = false;
//commitArgs.SvnError += new EventHandler<SvnErrorEventArgs>(commitArgs_SvnError);
try
{
SvnCommitResult result;
bool returnCode = _SvnClient.Commit(WorkingCopyPath, commitArgs, out result);
if (returnCode)
{
_RepositoryRevision = (int)result.Revision;
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Зафиксировать изменения в хранилище
/// </summary>
/// <param name="checkError">Проверить рабочую копию на ошибки перед фиксацией</param>
/// <param name="logMessage"></param>
/// <exception cref="SvnRepositoryException">Исключение в случае не разрешённых конфликтов рабочей копии</exception>
/// <returns>Результат фиксации изменений в хранилище</returns>
public bool CommitChanges(bool checkError = false, string logMessage = "")
{
if (checkError && !CheckWorkingCopyForError(WorkingCopyPath))
{
Logger.LogError(Resources.SvnUtils_CommitChanges_Sources_not_resolved);
return(false);
}
var svnCommitArgs = new SvnCommitArgs {
LogMessage = string.IsNullOrEmpty(logMessage)
? Resources
.SvnUtils_CommitChanges_Reintegrate_base_branch_to_feature
: logMessage
};
svnCommitArgs.Committing += SvnCommitArgsOnCommitting;
svnCommitArgs.Notify += SvnCommitArgsOnNotify;
svnCommitArgs.Committed += SvnCommitArgsOnCommitted;
try {
return(Commit(WorkingCopyPath, svnCommitArgs));
} finally {
svnCommitArgs.Committing -= SvnCommitArgsOnCommitting;
svnCommitArgs.Notify += SvnCommitArgsOnNotify;
}
}
/// <summary>
/// Commit all files
/// </summary>
/// <param name="filePaths"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool CommitAllFiles(List <string> filePaths, string message)
{
var returnValue = false;
var args = new SvnCommitArgs();
args.LogMessage = message;
args.ThrowOnError = true;
args.ThrowOnCancel = true;
args.Depth = SvnDepth.Empty;
try
{
//
//if (status.IsVersioned && status.IsModified)
//{
returnValue = _svnClient.Commit(filePaths, args);
if (returnValue)
{
foreach (var filePath in filePaths)
{
UpdateCache(filePath);
}
}
//}
}
catch (Exception e)
{
}
return(returnValue);
}
public static void CommitRecommend(Source source, long revision, string logMessage)
{
source.RefreshRecommended();
List<long> list = new List<long>();
list.AddRange(source.ReadOnlyRecommendedRevisions);
if (!list.Contains(revision))
{
list.Add(revision);
list.Sort();
StringBuilder sb = new StringBuilder();
foreach (long rev in list)
{
sb.AppendLine(rev.ToString());
}
using (SvnClient client = GetSvnClient(source))
{
SvnCommitArgs args = new SvnCommitArgs();
args.LogProperties.Add("svnmonitor:recommend", sb.ToString());
args.ThrowOnError = true;
args.LogMessage = logMessage;
args.Depth = SvnDepth.Empty;
client.Commit(source.Path, args);
}
}
}
private void Commit(string message, string login, string password, Revision revision)
{
using (SvnClient client = new SvnClient())
{
SvnCommitArgs aa = new SvnCommitArgs();
aa.Depth = SvnDepth.Infinity;
aa.Progress += this.OnProgress;
aa.SvnError += this.OnSvnError;
aa.Notify += this.OnNotify;
aa.LogMessage = message;
aa.Committed += (o, args) => { revision.Id = args.Revision.ToString(); };
client.Authentication.ForceCredentials(login, password);
client.Commit(this.repoPath, aa);
// hack
for (int i = 0; i <= 100; i++)
{
if (revision.Id == null)
{
Thread.Sleep(1000);
}
}
}
}
public void Delete_AllFiles()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Default);
Uri uri = sbox.RepositoryUri;
string wc = sbox.Wc;
for (int i = 0; i < 10; i++)
{
string file = Path.Combine(wc, string.Format("file{0}.txt", i));
File.WriteAllText(file, "");
Client.Add(file);
}
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Message";
Client.Commit(wc, ca);
foreach (FileInfo f in new DirectoryInfo(wc).GetFiles())
{
Client.Delete(f.FullName);
}
Client.Commit(wc, ca);
Client.Update(wc);
foreach (FileInfo f in new DirectoryInfo(wc).GetFiles())
{
Assert.That(false, "No files should exist at this point");
}
}
public void Delete_AllFiles()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Default);
Uri uri = sbox.RepositoryUri;
string wc = sbox.Wc;
for (int i = 0; i < 10; i++)
{
string file = Path.Combine(wc, string.Format("file{0}.txt", i));
File.WriteAllText(file, "");
Client.Add(file);
}
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Message";
Client.Commit(wc, ca);
foreach (FileInfo f in new DirectoryInfo(wc).GetFiles())
{
Client.Delete(f.FullName);
}
Client.Commit(wc, ca);
Client.Update(wc);
foreach (FileInfo f in new DirectoryInfo(wc).GetFiles())
{
Assert.That(false, "No files should exist at this point");
}
}
//提交SVN
public static void CommitSvn(string path)
{
SvnClient client = new SvnClient();
SvnCommitArgs comArgs = new SvnCommitArgs();
comArgs.LogMessage = "这里输入你的提交信息";
client.Commit(path);
}
internal void Commit(string text, SvnCommitArgs args, SvnCommitResult result)
{
using (SharpSvn.SvnClient client = new SharpSvn.SvnClient())
{
SvnCommitArgs ca = new SvnCommitArgs();
client.Commit(args.LogMessage, ca);
}
}
public override void Commit(FilePath[] paths, string message, IProgressMonitor monitor)
{
SvnCommitArgs args = new SvnCommitArgs();
BindMonitor(args, monitor);
args.LogMessage = message;
client.Commit(paths.ToStringArray(), args);
}
public override bool CommitChanges(ICollection <string> Paths, string Comments, ref string error, ref List <string> conflictsPaths, bool includLockedFiles = false)
{
//Commit Changes
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = Comments;
SvnCommitResult result;
try
{
if (includLockedFiles)
{
bool unlockResult = true;
foreach (string file in Paths)
{
Collection <SvnListEventArgs> ListEventArgs;
Uri targetUri = GetRemoteUriFromPath(file, out ListEventArgs);
if (ListEventArgs != null && ListEventArgs[0].Lock != null)
{
SvnUnlockArgs args = new SvnUnlockArgs();
args.BreakLock = true;
unlockResult = client.RemoteUnlock(targetUri, args);
if (unlockResult == false && Reporter.ToUser(eUserMsgKeys.SourceControlUnlockFaild, file, targetUri.ToString()) == MessageBoxResult.No)
{
error = "Check in aborted";
return(false);
}
}
}
}
client.Commit(Paths, ca, out result);
if (result != null)
{
if (result.Revision != -1)
{
Reporter.ToUser(eUserMsgKeys.CommitedToRevision, result.Revision);
}
else
{
Reporter.ToUser(eUserMsgKeys.SourceControlCommitFailed, "The files are not connected to source control");
}
}
}
catch (Exception e)
{
if (e.InnerException != null && e.InnerException.ToString().Contains("conflict"))
{
if (mConflictsPaths.Count > 0)
{
conflictsPaths = mConflictsPaths;
}
}
error = e.Message + Environment.NewLine + e.InnerException;
return(false);
}
return(true);
}
public bool Commit()
{
Console.WriteLine("开始检查是否需要提交新参数表...");
SvnCommitArgs ca = new SvnCommitArgs();
SvnStatusArgs sa = new SvnStatusArgs();
Collection<SvnStatusEventArgs> statuses;
SC.GetStatus(GetAppLoc(), sa, out statuses);
int i = 0;
foreach (var item in statuses)
{
if (item.LocalContentStatus != item.RemoteContentStatus)
{
i++;
}
if (!item.Versioned)
{
SC.Add(item.FullPath);
Console.WriteLine("新增加文件" + item.FullPath);
i++;
}
else if (item.Conflicted)
{
SC.Resolve(item.FullPath, SvnAccept.Working);
Console.WriteLine("处理冲突文件" + item.FullPath);
}
else if (item.IsRemoteUpdated)
{
SC.Update(item.FullPath);
Console.WriteLine("处理冲突文件" + item.FullPath);
}
else if (item.LocalContentStatus == SvnStatus.Missing)
{
SC.Delete(item.FullPath);
Console.WriteLine("处理丢失文件" + item.FullPath);
i++;
}
}
if (i > 0)
{
ca.LogMessage = "";
SvnCommitResult scr;
if (SC.Commit(GetAppLoc(), ca, out scr))
{
Console.WriteLine("提交完成");
}
else
{
Console.WriteLine("提交失败");
}
}
else
{
Console.WriteLine("无变化，无需检查");
}
return true;
}
/// <summary>
/// svn commit
/// 提交工作区中的改变到版本库
/// </summary>
/// <param name="path">需要提交的目录或者文件</param>
/// <param name="message">提交说明</param>
private void Commit(string path, string message)
{
using (SvnClient client = new SvnClient())
{
SvnCommitArgs args = new SvnCommitArgs();
args.LogMessage = message;
client.Commit(path, args);
}
}
public override void Commit(FilePath[] paths, string message, IProgressMonitor monitor)
{
var args = new SvnCommitArgs {
LogMessage = message,
};
BindMonitor(monitor);
lock (client)
client.Commit(paths.ToStringArray(), args);
}
public void CheckInChanges(string solutionDirectoryPath, Project oldProject, Project newProject)
{
using(SvnClient svnClient = new SvnClient())
{
SvnCommitArgs svnCommitArgs = new SvnCommitArgs { LogMessage = string.Format("Renamed project {0} into {1}", oldProject.ProjectName, newProject.ProjectName) };
// TODO NKO: Do something with the result
SvnCommitResult result;
svnClient.Commit(solutionDirectoryPath, svnCommitArgs, out result);
}
}
public void CheckInChanges(string solutionDirectoryPath, Project oldProject, Project newProject)
{
using (SvnClient svnClient = new SvnClient())
{
SvnCommitArgs svnCommitArgs = new SvnCommitArgs {
LogMessage = string.Format("Renamed project {0} into {1}", oldProject.ProjectName, newProject.ProjectName)
};
// TODO NKO: Do something with the result
SvnCommitResult result;
svnClient.Commit(solutionDirectoryPath, svnCommitArgs, out result);
}
}
/// <summary>
/// Actual method to be executed for the implementing task
/// </summary>
/// <param name="client">The instance of the SVN client</param>
/// <returns></returns>
public override bool ExecuteCommand(SvnClient client)
{
SvnCommitArgs args = new SvnCommitArgs();
args.LogMessage = Message;
args.KeepLocks = KeepLocks;
args.KeepChangeLists = KeepChangeLists;
SvnCommitResult result;
bool success = client.Commit(RepositoryPath, args, out result);
return success;
}
public void WriteTest()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string WcPath = sbox.Wc;
string data = Guid.NewGuid().ToString();
using (SvnClient client = NewSvnClient(true, false))
{
string file = Path.Combine(WcPath, "WriteTest");
using (StreamWriter sw = File.CreateText(file))
{
sw.WriteLine(data);
}
client.Add(file);
client.AddToChangeList(file, "WriteTest-Items");
SvnCommitArgs ca = new SvnCommitArgs();
ca.ChangeLists.Add("WriteTest-Items");
client.Commit(WcPath);
using (MemoryStream ms = new MemoryStream())
{
client.Write(new SvnPathTarget(file), ms);
ms.Position = 0;
using (StreamReader sr = new StreamReader(ms))
{
Assert.That(sr.ReadLine(), Is.EqualTo(data));
Assert.That(sr.ReadToEnd(), Is.EqualTo(""));
}
}
using (MemoryStream ms = new MemoryStream())
{
client.Write(new Uri(sbox.RepositoryUri, "WriteTest"), ms);
ms.Position = 0;
using (StreamReader sr = new StreamReader(ms))
{
Assert.That(sr.ReadLine(), Is.EqualTo(data));
Assert.That(sr.ReadToEnd(), Is.EqualTo(""));
}
}
}
}
public void TestCommit()
{
using (SvnClient client = new SvnClient())
{
var localpath = "d:\\sharpsvn\\需求文档\\1.txt";
localpath = "d:\\sharpsvn\\1.txt";
//localpath = @"E:\project\ccms\CCMS_V7_HBYD_R";
var username = "******";
var pwd = "123456";
client.Authentication.DefaultCredentials = new System.Net.NetworkCredential(username, pwd);
//如果项目不存在则checkout，否则进行update
Console.WriteLine("开始检查是否需要提交新参数表...");
SvnCommitArgs ca = new SvnCommitArgs();
SvnStatusArgs sa = new SvnStatusArgs();
Collection <SvnStatusEventArgs> statuses;
client.GetStatus(localpath, sa, out statuses);
int i = 0;
foreach (var item in statuses)
{
if (item.LocalContentStatus != item.RemoteContentStatus)
{
i++;
}
if (!item.Versioned)
{
client.Add(item.FullPath);
Console.WriteLine("新增加文件" + item.FullPath);
i++;
}
}
if (i > 0)
{
ca.LogMessage = "测试提交文档";
SvnCommitResult clientr;
if (client.Commit(localpath, ca, out clientr))
{
Console.WriteLine("提交完成");
}
else
{
Console.WriteLine("提交失败");
}
}
else
{
Console.WriteLine("无变化，无需检查");
}
}
}
public override void CommitChanges(ICollection <string> Paths, string Comments)
{
//Commit Changes
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = Comments;
try
{
client.Commit(Paths, ca);
}
catch (Exception e)
{
Reporter.ToUser(eUserMsgKeys.GeneralErrorOccured, e.Message + Environment.NewLine + e.InnerException);
}
}
public override void CommitChanges(string Comments)
{
//Commit Changes
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = Comments;
try
{
client.Commit(App.UserProfile.Solution.Folder);
}
catch (Exception e)
{
Reporter.ToUser(eUserMsgKeys.GeneralErrorOccured, e.Message + Environment.NewLine + e.InnerException);
}
}
public static bool Commit(string path, SvnCommitArgs args, out SvnCommitResult result)
{
result = null;
try
{
return m_Client.Commit(path, args, out result);
}
catch (SvnException ex)
{
MessageBox.Show("提交失败 ： " + ex.Message, "系统提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);
}
return false;
}
public static bool Commit(ICollection <string> paths, SvnCommitArgs args, out SvnCommitResult result)
{
result = null;
try
{
return(m_Client.Commit(paths, args, out result));
}
catch (SvnException ex)
{
MessageBox.Show("提交失败 ： " + ex.Message, "系统提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);
}
return(false);
}
/// <summary>
/// 执行SVN的Commit操作
/// </summary>
public static bool Commit(string localFilePath, string logMessage, out SvnException svnException)
{
try
{
SvnCommitArgs commitArgs = new SvnCommitArgs();
commitArgs.LogMessage = logMessage;
bool result = _svnClient.Commit(localFilePath, commitArgs);
svnException = null;
return(result);
}
catch (SvnException exception)
{
svnException = exception;
return(false);
}
}
public void TestPostCommit()
{
SvnSandBox sbox = new SvnSandBox(this);
Uri uri = sbox.CreateRepository(SandBoxRepository.MergeScenario);
using (InstallHook(uri, SvnHookType.PostCommit, OnPostCommit))
{
string dir = sbox.GetTempDir();
Client.CheckOut(new Uri(uri, "trunk/"), dir);
TouchFile(Path.Combine(dir, "Post.txt"));
Client.Add(Path.Combine(dir, "Post.txt"));
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Blaat!\nQWQQ\n";
Client.Commit(dir, ca);
}
}
public void TestPostCommit()
{
SvnSandBox sbox = new SvnSandBox(this);
Uri uri = sbox.CreateRepository(SandBoxRepository.MergeScenario);
using (InstallHook(uri, SvnHookType.PostCommit, OnPostCommit))
{
string dir = sbox.GetTempDir();
Client.CheckOut(new Uri(uri, "trunk/"), dir);
TouchFile(Path.Combine(dir, "Post.txt"));
Client.Add(Path.Combine(dir, "Post.txt"));
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Blaat!\nQWQQ\n";
Client.Commit(dir, ca);
}
}
public override bool CommitChanges(string Comments, ref string error)
{
//Commit Changes
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = Comments;
try
{
client.Commit(SolutionFolder);
}
catch (Exception e)
{
error = e.Message + Environment.NewLine + e.InnerException;
return(false);
}
return(true);
}
public void Commit_SetCustomProps()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string WcPath = sbox.Wc;
string fp = Path.Combine(WcPath, "NewFile.cs");
Touch2(fp);
Client.Add(fp);
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Committed extra";
ca.LogProperties.Add("my:prop", "PropValue");
ca.RunTortoiseHooks = true;
SvnCommitResult cr;
Client.Commit(WcPath, ca, out cr);
string value;
Client.GetRevisionProperty(sbox.RepositoryUri, cr.Revision, "my:prop", out value);
Assert.That(value, Is.EqualTo("PropValue"));
SvnLogArgs la = new SvnLogArgs();
la.RetrieveProperties.Add("my:prop");
la.Start = la.End = cr.Revision;
Collection <SvnLogEventArgs> lc;
Client.GetLog(WcPath, la, out lc);
Assert.That(lc.Count, Is.EqualTo(1));
Assert.That(lc[0].RevisionProperties.Contains("my:prop"));
SvnLogEventArgs l = lc[0];
Assert.That(l.RevisionProperties["my:prop"].StringValue, Is.EqualTo("PropValue"));
Assert.That(l.Author, Is.EqualTo(Environment.UserName));
}
static public void Commit(string fromLocalPath)
{
using (SvnClient svnClient = new SvnClient())
{
try
{
//svnClient.Authentication.ForceCredentials(_svnUserName, _svnPwd);
SvnCommitArgs args = new SvnCommitArgs();
args.LogMessage = Properties.Settings.Default.SVN_Commit_Msg;
svnClient.Commit(fromLocalPath, args);
}
catch (Exception ex)
{
LogMessage(ex.Message);
}
}
}
public override string Commit(string filePath, string changedContent, string commitComment)
{
string changedFilePath = Path.Combine(LocalRepositoryCheckedOutPath, filePath);
using (var changedFile = File.OpenWrite(changedFilePath))
{
var changes = new UTF8Encoding(true).GetBytes(changedContent);
changedFile.Write(changes, 0, changes.Length);
}
var commit = new SvnCommitArgs {
LogMessage = commitComment
};
SvnCommitResult result;
_client.Commit(LocalRepositoryCheckedOutPath, commit, out result);
return(result.Revision.ToString());
}
public void Commit_NonRecursiveDirDelete()
{
SvnSandBox sbox = new SvnSandBox(this);
string dir = sbox.GetTempDir();
Client.CheckOut(sbox.CreateRepository(SandBoxRepository.Empty), dir);
string name = Path.Combine(dir, "sd");
Client.CreateDirectory(name);
Client.Commit(name);
Client.Delete(name);
SvnCommitArgs ca = new SvnCommitArgs();
ca.Depth = SvnDepth.Empty;
Client.Commit(name, ca);
}
private SvnCommitResult CommitChangesetFiles(SvnClient svnClient, Changeset changeset, List <string> filePaths)
{
SvnCommitResult commitResult;
SvnCommitArgs commitArgs;
int failCount;
bool complete;
commitArgs = new SvnCommitArgs {
LogMessage = changeset.Comment
};
failCount = 0;
complete = false;
commitResult = null;
while (!complete)
{
if (failCount > 0)
{
this.LogMessage("Retrying commit again, attempt {0} of {1}...", failCount + 1, this.RetryCount);
}
try
{
svnClient.Commit(filePaths, commitArgs, out commitResult);
complete = true;
}
catch (Exception ex)
{
this.LogException(ex);
failCount++;
if (failCount > this.RetryCount)
{
complete = true; // abort
}
else
{
Thread.Sleep(1000);
}
}
}
return(commitResult);
}
/// <summary>
/// Actualiza un archivo en el SVN.
/// </summary>
/// <param name="ruta"></param>
/// <returns></returns>
public static string ActualizarArchivo(string nombre, string usuario)
{
var msj = "";
try
{
string rutaCopiaTrabajo = ObtenerRutaCopiaTrabajo();
// Argumentos del agregado.
var aa = new SvnAddArgs();
aa.Depth = SvnDepth.Infinity;
aa.Force = true;
// Argyumentos del commit.
var args = new SvnCommitArgs();
args.LogMessage = "Editar: " + nombre + ".\nUsuario: " + usuario + ".\nFecha: " + DateTime.Now;
args.Depth = SvnDepth.Infinity;
using (var client = new SvnClient())
{
// Agregar archivo a la copia de trabajo SVN.
client.Add(rutaCopiaTrabajo, aa);
// Hacer commit repositorio SVN.
client.Commit(rutaCopiaTrabajo, args);
}
msj = "Exito";
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
msj += "Error al subir el archivo: " + ex.Message;
if (ex.InnerException != null)
{
msj += " " + ex.InnerException.Message;
}
}
return(msj);
}
public void CheckIn()
{
SvnCommitArgs a = new SvnCommitArgs();
a.LogMessage = "Status Update";
using (SvnClient client = new SvnClient())
{
client.Commit(_excelFilePath, a);
try
{
client.Unlock(_excelFilePath);
}
#pragma warning disable CS0168 // The variable 'ex' is declared but never used
catch (SharpSvn.SvnClientMissingLockTokenException ex)
#pragma warning restore CS0168 // The variable 'ex' is declared but never used
{
}
}
}
public void TestChangedFile()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.AnkhSvnCases);
string WcPath = sbox.Wc;
using (StreamWriter w = new StreamWriter(Path.Combine(WcPath, "Form.cs")))
w.Write("Moo");
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "";
Client.Commit(WcPath, ca);
this.Client.Update(WcPath);
string s = File.ReadAllText(Path.Combine(WcPath, "Form.cs"));
Assert.That(s, Is.EqualTo("Moo"), "File not updated");
}
public void TestPreCommit()
{
SvnSandBox sbox = new SvnSandBox(this);
Uri uri = sbox.CreateRepository(SandBoxRepository.MergeScenario);
using (InstallHook(uri, SvnHookType.PreCommit, OnPreCommit))
{
string dir = sbox.GetTempDir();
Client.CheckOut(new Uri(uri, "trunk/"), dir);
string pre = Path.Combine(dir, "Pre.txt");
File.WriteAllText(pre, "AllTheData");
Client.Add(pre);
Client.SetProperty(pre, "boe", "blaat");
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Blaat!\nQWQQ\n";
Client.Commit(dir, ca);
}
}
public void Commit_CommitWithNonAnsiCharsInLogMessage()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.AnkhSvnCases);
string WcPath = sbox.Wc;
string filepath = Path.Combine(WcPath, "Form.cs");
using (StreamWriter w = new StreamWriter(filepath))
w.Write("Moo");
SvnCommitArgs a = new SvnCommitArgs();
a.LogMessage = " ¥ · £ · € · $ · ¢ · ₡ · ₢ · ₣ · ₤ · ₥ · ₦ · ₧ · ₨ · ₩ · ₪ · ₫ · ₭ · ₮ · ₯";
Assert.That(Client.Commit(WcPath, a));
SvnLogArgs la = new SvnLogArgs();
la.Start = SvnRevision.Head;
la.End = SvnRevision.Head;
Collection<SvnLogEventArgs> logList;
Client.GetLog(WcPath, la, out logList);
Assert.That(logList, Is.Not.Null);
Assert.That(logList.Count, Is.EqualTo(1));
Assert.That(logList[0].LogMessage, Is.EqualTo(a.LogMessage));
}
private void m_tmsi_commit_Click(object sender, EventArgs e)
{
try
{
if (!this.SaveFile()) return;
SvnCommitResult result;
CommitMessage messageDialog = new CommitMessage();
if (messageDialog.ShowDialog() == DialogResult.OK)
{
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = messageDialog.m_tb_Log.Text.ToString();
if (SVNMgr.Commit(this.m_OperatorFiles, ca, out result))
{
MessageBox.Show("提交成功。", "系统提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);
this.m_tv_Items.SelectedNode.ImageIndex = 1;
this.m_tv_Items.SelectedNode.SelectedImageIndex = 1;
}
}
}
catch (Exception ex)
{
MessageBox.Show("文件提交失败 : " + ex.Message, "系统提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);
}
}
public void Commit_CommitFile()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.AnkhSvnCases);
string WcPath = sbox.Wc;
string filepath = Path.Combine(WcPath, "Form.cs");
using (StreamWriter w = new StreamWriter(filepath))
w.Write("Moo");
SvnCommitArgs a = new SvnCommitArgs();
a.Depth = SvnDepth.Empty;
Assert.That(this.Client.Commit(filepath, a));
SvnStatus status = this.GetSvnStatus(filepath);
Assert.That(status, Is.EqualTo(SvnStatus.None), "File not committed");
}
public void Copy()
{
long lastSyncRevision = 0;
if (_args.Incremental)
{
SvnLogParser logParser = new SvnLogParser(_args.Destination);
lastSyncRevision = logParser.GetLastSyncedRevisionFromDestination();
Console.WriteLine("Last revision synched: {0}", lastSyncRevision);
}
Console.Write("Collecting svn log: ");
if (_args.RevisionRange != null)
{
Console.Write("{0}:{1} ",
_args.RevisionRange.StartRevision,
_args.RevisionRange.EndRevision);
}
// fetch the source svn respository and
SvnInfo sourceInfo = new SvnInfo(_args.Source);
Console.WriteLine("Source SVN root: {0}", sourceInfo.Info.RepositoryRoot);
Console.WriteLine("Source SVN uri: {0}", sourceInfo.Info.Uri);
string sourceRelativePath = sourceInfo.Info.Uri.ToString().Remove(
0, sourceInfo.Info.RepositoryRoot.ToString().Length - 1);
Console.WriteLine("Relative path: {0}", sourceRelativePath);
if (!string.IsNullOrEmpty(_args.Root))
{
sourceRelativePath = _args.Root;
Console.WriteLine("Substituting relative path: {0}", sourceRelativePath);
}
SvnLogArgs logArgs = new SvnLogArgs();
logArgs.StrictNodeHistory = _args.StopOnCopy;
logArgs.ThrowOnError = true;
logArgs.Range = _args.RevisionRange;
logArgs.RetrieveChangedPaths = true;
_client.Log(_args.Source, logArgs, new EventHandler<SvnLogEventArgs>(OnLog));
Console.WriteLine();
Console.WriteLine("Collected {0} revisions.", _revisions.Count);
SvnTarget fromSvnTarget = SvnTarget.FromString(_args.Source);
foreach (KeyValuePair<long, SvnLogEventArgs> revisionPair in _revisions)
{
SvnLogEventArgs revision = revisionPair.Value;
if (_args.Incremental && lastSyncRevision != 0 && lastSyncRevision >= revision.Revision )
{
Console.WriteLine("Skipping revision {0} ({1})", revision.Revision, revision.Time);
continue;
}
Console.WriteLine("Revision {0} ({1})", revision.Revision, revision.Time);
if (_args.SimulationOnly)
continue;
SvnExportArgs exportArgs = new SvnExportArgs();
exportArgs.Overwrite = true;
exportArgs.ThrowOnError = true;
exportArgs.Revision = revision.Revision;
SvnUpdateResult exportResult = null;
_client.Export(fromSvnTarget, _args.Destination, exportArgs, out exportResult);
if (revision.ChangedPaths == null)
{
throw new Exception(string.Format("No changed paths in rev. {0}",
revision.Revision));
}
SortedList<string, SvnChangeItem> changeItems = new SortedList<string, SvnChangeItem>();
foreach (SvnChangeItem changeItem in revision.ChangedPaths)
{
changeItems.Add(changeItem.Path, changeItem);
}
List<string> filesAdd = new List<string>();
List<string> filesDelete = new List<string>();
List<string> filesModify = new List<string>();
// add files in forward order (add directories first)
// delete files in reverse order (delete files first)
foreach (SvnChangeItem changeItem in changeItems.Values)
{
// anything above (outside) of the source path is ignored, we didn't export that
if (! changeItem.Path.StartsWith(sourceRelativePath))
{
Console.WriteLine("Skipping {0}. Did you need to specify /root:<path>?)", changeItem.Path);
continue;
}
string targetSvnPath = changeItem.Path.Remove(0, sourceRelativePath.Length);
string targetOSPath = targetSvnPath.Replace("/", @"\");
string targetPath = Path.Combine(_args.Destination, targetOSPath);
Console.WriteLine(" {0} {1}", changeItem.Action, changeItem.Path);
switch (changeItem.Action)
{
case SvnChangeAction.Add:
case SvnChangeAction.Replace:
filesAdd.Add(targetPath);
break;
case SvnChangeAction.Delete:
filesDelete.Insert(0, targetPath);
break;
case SvnChangeAction.Modify:
filesModify.Add(targetPath);
break;
}
}
Console.WriteLine("Applying changes @ rev. {0} ...", revision.Revision);
foreach (string targetPath in filesModify)
{
Console.WriteLine(" M {0}", targetPath);
}
foreach (string targetPath in filesAdd)
{
if (! File.Exists(targetPath))
{
throw new Exception(string.Format("Added file '{0}' doesn't exist. Did you need to specify /root:<path>?",
targetPath));
}
Console.WriteLine(" A {0}", targetPath);
SvnAddArgs svnAddArgs = new SvnAddArgs();
svnAddArgs.ThrowOnError = true;
svnAddArgs.Depth = SvnDepth.Empty;
_client.Add(targetPath, svnAddArgs);
}
foreach (string targetPath in filesDelete)
{
Console.WriteLine(" D {0}", targetPath);
SvnDeleteArgs svnDeleteArgs = new SvnDeleteArgs();
svnDeleteArgs.ThrowOnError = true;
svnDeleteArgs.Force = true;
_client.Delete(targetPath, svnDeleteArgs);
}
SvnCommitArgs commitArgs = new SvnCommitArgs();
commitArgs.LogMessage = revision.LogMessage;
commitArgs.LogMessage += string.Format("\nCopied from {0}, rev. {1} by {2} @ {3} {4}",
sourceInfo.Info.Uri, revision.Revision, revision.Author, revision.Time.ToShortDateString(), revision.Time.ToShortTimeString());
commitArgs.ThrowOnError = true;
Console.WriteLine("Committing changes @ rev. {0} in {1}", revision.Revision, _args.Destination);
Console.WriteLine("----------------------------------------------------------------------------");
Console.WriteLine(commitArgs.LogMessage);
Console.WriteLine("----------------------------------------------------------------------------");
if (_args.Prompt)
{
while (true)
{
Console.Write("Commit? [Y/N] ");
char k = Char.ToLower(Console.ReadKey().KeyChar);
Console.WriteLine();
if (k == 'y') break;
if (k == 'n') throw new Exception("Aborted by user.");
}
}
SvnCommitResult commitResult = null;
_client.Commit(_args.Destination, commitArgs, out commitResult);
if (commitResult != null)
{
Console.WriteLine("Commited revision {0}.", commitResult.Revision);
}
else
{
Console.WriteLine("There were no committable changes.");
Console.WriteLine("Subversion property changes are not supported.");
}
}
}
public void FileVersions_WalkKeywords()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string wc = sbox.Wc;
string file = Path.Combine(wc, "myFile.txt");
string nl = Environment.NewLine;
File.WriteAllText(file, "Line1 $Id: FileVersions.cs 2139 2012-05-19 10:21:53Z rhuijben $" + nl + "$HeadURL$" + nl + nl);
Client.Add(file);
Client.SetProperty(file, SvnPropertyNames.SvnKeywords, "Id\nHeadURL");
Client.Commit(file);
File.AppendAllText(file, "Line" + nl);
Client.Commit(file);
Client.SetProperty(file, SvnPropertyNames.SvnEolStyle, "native");
Client.Commit(file);
File.AppendAllText(file, "Line" + nl + "Line");
Client.Commit(file);
Client.SetProperty(file, SvnPropertyNames.SvnEolStyle, "CR");
Client.Commit(file);
string f2 = file + "2";
Client.Copy(file, f2);
SvnCommitArgs xa = new SvnCommitArgs();
xa.LogProperties.Add("extra", "value");
Client.Commit(wc, xa);
Client.Update(wc);
SvnFileVersionsArgs va;
using (SvnClient c2 = new SvnClient())
{
Uri fileUri = c2.GetUriFromWorkingCopy(file);
Uri f2Uri = c2.GetUriFromWorkingCopy(f2);
for (int L = 0; L < 2; L++)
{
va = new SvnFileVersionsArgs();
va.RetrieveProperties = true;
switch (L)
{
case 0:
va.Start = SvnRevision.Zero;
va.End = SvnRevision.Head;
break;
default:
break;
}
int i = 0;
Client.FileVersions(f2, va,
delegate(object sender, SvnFileVersionEventArgs e)
{
Assert.That(e.Revision, Is.EqualTo(i + 1L));
Assert.That(e.RepositoryRoot, Is.Not.Null);
Assert.That(e.Uri, Is.EqualTo(i == 5 ? f2Uri : fileUri));
Assert.That(e.Author, Is.EqualTo(Environment.UserName));
Assert.That(e.Time, Is.GreaterThan(DateTime.UtcNow - new TimeSpan(0, 0, 10, 0, 0)));
Assert.That(e.RevisionProperties.Count, Is.GreaterThanOrEqualTo(3));
if (i == 5)
{
Assert.That(e.RevisionProperties.Contains("extra"), "Contains extra property");
//Assert.That(e.Properties.Contains(SvnPropertyNames.SvnMergeInfo), Is.True, "Contains merge info in revision 5");
}
else
Assert.That(e.Properties.Contains(SvnPropertyNames.SvnMergeInfo), Is.False, "No mergeinfo");
MemoryStream ms1 = new MemoryStream();
MemoryStream ms2 = new MemoryStream();
e.WriteTo(ms1);
c2.Write(new SvnUriTarget(e.Uri, e.Revision), ms2);
string s1 = Encoding.UTF8.GetString(ms1.ToArray());
string s2 = Encoding.UTF8.GetString(ms2.ToArray());
//Assert.That(ms1.Length, Is.EqualTo(ms2.Length), "Export lengths equal");
Assert.That(s1, Is.EqualTo(s2));
i++;
});
Assert.That(i, Is.EqualTo(6), "Found 6 versions");
}
}
}
public override void Commit (FilePath[] paths, string message, IProgressMonitor monitor)
{
SvnCommitArgs args = new SvnCommitArgs ();
BindMonitor (args, monitor);
args.LogMessage = message;
lock (client)
client.Commit (paths.ToStringArray (), args);
}
public void Copy()
{
Console.Write("Collecting svn log: ");
if (_args.RevisionRange != null)
{
Console.Write("{0}:{1} ",
_args.RevisionRange.StartRevision,
_args.RevisionRange.EndRevision);
}
// fetch the source svn respository and
SvnInfo sourceInfo = new SvnInfo(_args.Source);
Console.WriteLine("Source SVN root: {0}", sourceInfo.Info.RepositoryRoot);
Console.WriteLine("Source SVN uri: {0}", sourceInfo.Info.Uri);
string sourceRelativePath = sourceInfo.Info.Uri.ToString().Remove(
0, sourceInfo.Info.RepositoryRoot.ToString().Length - 1);
Console.WriteLine("Relative path: {0}", sourceRelativePath);
SvnLogArgs logArgs = new SvnLogArgs();
logArgs.StrictNodeHistory = true;
logArgs.ThrowOnError = true;
logArgs.Range = _args.RevisionRange;
logArgs.RetrieveChangedPaths = true;
_client.Log(_args.Source, logArgs, new EventHandler<SvnLogEventArgs>(OnLog));
Console.WriteLine();
Console.WriteLine("Collected {0} revisions.", _revisions.Count);
SvnTarget fromSvnTarget = SvnTarget.FromString(_args.Source);
foreach (KeyValuePair<long, SvnLogEventArgs> revisionPair in _revisions)
{
SvnLogEventArgs revision = revisionPair.Value;
Console.WriteLine("Revision {0} ({1})", revision.Revision, revision.Time);
if (_args.simulationOnly)
continue;
SvnExportArgs exportArgs = new SvnExportArgs();
exportArgs.Overwrite = true;
exportArgs.ThrowOnError = true;
exportArgs.Revision = revision.Revision;
SvnUpdateResult exportResult = null;
_client.Export(fromSvnTarget, _args.Destination, exportArgs, out exportResult);
if (revision.ChangedPaths == null)
{
throw new Exception(string.Format("No changed paths in rev. {0}",
revision.Revision));
}
SortedList<string, SvnChangeItem> changeItems = new SortedList<string, SvnChangeItem>();
foreach (SvnChangeItem changeItem in revision.ChangedPaths)
{
changeItems.Add(changeItem.Path, changeItem);
}
foreach (SvnChangeItem changeItem in changeItems.Values)
{
string targetSvnPath = changeItem.Path.Remove(0, sourceRelativePath.Length);
string targetOSPath = targetSvnPath.Replace("/", @"\");
string targetPath = Path.Combine(_args.Destination, targetOSPath);
Console.WriteLine("{0} {1}", changeItem.Action, changeItem.Path);
switch (changeItem.Action)
{
case SvnChangeAction.Add:
{
Console.WriteLine(" A {0}", targetPath);
SvnAddArgs svnAddArgs = new SvnAddArgs();
svnAddArgs.ThrowOnError = true;
svnAddArgs.Depth = SvnDepth.Empty;
_client.Add(targetPath, svnAddArgs);
}
break;
case SvnChangeAction.Delete:
{
Console.WriteLine(" D {0}", targetPath);
SvnDeleteArgs svnDeleteArgs = new SvnDeleteArgs();
svnDeleteArgs.ThrowOnError = true;
_client.Delete(targetPath, svnDeleteArgs);
}
break;
}
}
SvnCommitArgs commitArgs = new SvnCommitArgs();
commitArgs.LogMessage = revision.LogMessage;
commitArgs.LogMessage += string.Format("\nCopied from {0}, rev. {1} by {2} @ {3} {4}",
sourceInfo.Info.Uri, revision.Revision, revision.Author, revision.Time.ToShortDateString(), revision.Time.ToShortTimeString());
commitArgs.ThrowOnError = true;
Console.WriteLine("Commiting {0}", _args.Destination);
Console.WriteLine("----------------------------------------------------------------------------");
Console.WriteLine(commitArgs.LogMessage);
Console.WriteLine("----------------------------------------------------------------------------");
if (_args.prompt)
{
while (true)
{
Console.Write("Commit? [Y/N] ");
char k = Char.ToLower(Console.ReadKey().KeyChar);
Console.WriteLine();
if (k == 'y') break;
if (k == 'n') throw new Exception("Aborted by user.");
}
}
_client.Commit(_args.Destination, commitArgs);
}
}
public void Commit_NonRecursiveDirDelete()
{
SvnSandBox sbox = new SvnSandBox(this);
string dir = sbox.GetTempDir();
Client.CheckOut(sbox.CreateRepository(SandBoxRepository.Empty), dir);
string name = Path.Combine(dir, "sd");
Client.CreateDirectory(name);
Client.Commit(name);
Client.Delete(name);
SvnCommitArgs ca = new SvnCommitArgs();
ca.Depth = SvnDepth.Empty;
Client.Commit(name, ca);
}
public void Commit_SetCustomProps()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string WcPath = sbox.Wc;
string fp = Path.Combine(WcPath, "NewFile.cs");
Touch2(fp);
Client.Add(fp);
SvnCommitArgs ca = new SvnCommitArgs();
ca.LogMessage = "Committed extra";
ca.LogProperties.Add("my:prop", "PropValue");
ca.RunTortoiseHooks = true;
SvnCommitResult cr;
Client.Commit(WcPath, ca, out cr);
string value;
Client.GetRevisionProperty(sbox.RepositoryUri, cr.Revision, "my:prop", out value);
Assert.That(value, Is.EqualTo("PropValue"));
SvnLogArgs la = new SvnLogArgs();
la.RetrieveProperties.Add("my:prop");
la.Start = la.End = cr.Revision;
Collection<SvnLogEventArgs> lc;
Client.GetLog(WcPath, la, out lc);
Assert.That(lc.Count, Is.EqualTo(1));
Assert.That(lc[0].RevisionProperties.Contains("my:prop"));
SvnLogEventArgs l = lc[0];
Assert.That(l.RevisionProperties["my:prop"].StringValue, Is.EqualTo("PropValue"));
Assert.That(l.Author, Is.EqualTo(Environment.UserName));
}
public int Commit(ICollection<string> targets, bool recurse, bool keepLocks, string logMessage)
{
try
{
SvnCommitArgs args = new SvnCommitArgs();
args.Depth = SvnDepth.Infinity;
args.KeepLocks = true;
args.LogMessage = logMessage;
SvnCommitResult result;
client.Commit(targets, args, out result);
OnCommitted((int)result.Revision, result.Author, result.Time);
return (int)result.Revision;
}
catch (Exception ex)
{
OnError(ex);
}
return int.MinValue;
}
public override void Commit (FilePath[] paths, string message, ProgressMonitor monitor)
{
var args = new SvnCommitArgs {
LogMessage = message,
};
BindMonitor (monitor);
lock (client)
client.Commit (paths.ToStringArray (), args);
}
public bool Commit(string authorName, string authorEmail, string comment, DateTime localTime)
{
/*
TempFile commentFile;
var args = "commit";
AddComment(comment, ref args, out commentFile);
using (commentFile)
{
var startInfo = GetStartInfo(args);
startInfo.EnvironmentVariables["GIT_AUTHOR_NAME"] = authorName;
startInfo.EnvironmentVariables["GIT_AUTHOR_EMAIL"] = authorEmail;
startInfo.EnvironmentVariables["GIT_AUTHOR_DATE"] = GetUtcTimeString(localTime);
// also setting the committer is supposedly useful for converting to Mercurial
startInfo.EnvironmentVariables["GIT_COMMITTER_NAME"] = authorName;
startInfo.EnvironmentVariables["GIT_COMMITTER_EMAIL"] = authorEmail;
startInfo.EnvironmentVariables["GIT_COMMITTER_DATE"] = GetUtcTimeString(localTime);
// ignore empty commits, since they are non-trivial to detect
// (e.g. when renaming a directory)
return ExecuteUnless(startInfo, "nothing to commit");
}
*/
if (string.IsNullOrEmpty(authorName))
{
return false;
}
using (var client = new SvnClient())
{
SvnUI.Bind(client, parentWindow);
var svnCommitArgs = new SvnCommitArgs { LogMessage = comment };
var svnCommitResult = (SvnCommitResult)null;
var result = client.Commit(useSvnStandardDirStructure ? trunkPath : workingCopyPath, svnCommitArgs, out svnCommitResult);
// commit without files results in result=true and svnCommitResult=null
if (svnCommitResult != null)
{
if (result)
{
var workingCopyUri = client.GetUriFromWorkingCopy(useSvnStandardDirStructure ? trunkPath : workingCopyPath);
result &= client.SetRevisionProperty(svnCommitResult.RepositoryRoot, new SvnRevision(svnCommitResult.Revision), SvnPropertyNames.SvnAuthor, authorName);
result &= client.SetRevisionProperty(svnCommitResult.RepositoryRoot, new SvnRevision(svnCommitResult.Revision), SvnPropertyNames.SvnDate, SvnPropertyNames.FormatDate(localTime));
result &= client.Update(workingCopyPath, new SvnUpdateArgs { AddsAsModifications = false, AllowObstructions = false, Depth = SvnDepth.Infinity, IgnoreExternals = true, KeepDepth = true, Revision = SvnRevision.Head, UpdateParents = false });
}
else
{
MessageBox.Show(string.Format("{0} Error Code: {1}{2}", svnCommitResult.PostCommitError, "", Environment.NewLine), "SVN Commit Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
return result;
}
return false;
}
public void WriteTest()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string WcPath = sbox.Wc;
string data = Guid.NewGuid().ToString();
using (SvnClient client = NewSvnClient(true, false))
{
string file = Path.Combine(WcPath, "WriteTest");
using (StreamWriter sw = File.CreateText(file))
{
sw.WriteLine(data);
}
client.Add(file);
client.AddToChangeList(file, "WriteTest-Items");
SvnCommitArgs ca = new SvnCommitArgs();
ca.ChangeLists.Add("WriteTest-Items");
client.Commit(WcPath);
using (MemoryStream ms = new MemoryStream())
{
client.Write(new SvnPathTarget(file), ms);
ms.Position = 0;
using (StreamReader sr = new StreamReader(ms))
{
Assert.That(sr.ReadLine(), Is.EqualTo(data));
Assert.That(sr.ReadToEnd(), Is.EqualTo(""));
}
}
using (MemoryStream ms = new MemoryStream())
{
client.Write(new Uri(sbox.RepositoryUri, "WriteTest"), ms);
ms.Position = 0;
using (StreamReader sr = new StreamReader(ms))
{
Assert.That(sr.ReadLine(), Is.EqualTo(data));
Assert.That(sr.ReadToEnd(), Is.EqualTo(""));
}
}
}
}
public void Commit_CommitWithLocks()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.AnkhSvnCases);
string WcPath = sbox.Wc;
string filepath = Path.Combine(WcPath, "Form.cs");
using (StreamWriter w = new StreamWriter(filepath))
w.Write("Moo");
this.RunCommand("svn", "lock " + filepath);
SvnCommitResult info;
SvnCommitArgs a = new SvnCommitArgs();
a.KeepLocks = true;
Assert.That(this.Client.Commit(WcPath, a, out info));
Assert.IsNotNull(info);
char locked = this.RunCommand("svn", "status " + filepath)[5];
Assert.That(locked == 'K', "File was unlocked while lock should be kept");
using (StreamWriter w = new StreamWriter(filepath))
w.Write("Bah");
a.KeepLocks = false;
Assert.That(Client.Commit(WcPath, a, out info));
Assert.IsNotNull(info);
string output = this.RunCommand("svn", "status " + filepath);
Assert.That(output, Is.EqualTo(String.Empty));
}
public void Commit_CanceledCommit()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.AnkhSvnCases);
string WcPath = sbox.Wc;
string path = Path.Combine(WcPath, "Form.cs");
string path2 = Path.Combine(WcPath, "Form2.cs");
File.WriteAllText(path, "MOO");
File.WriteAllText(path2, "MOO2");
Client.Add(path2);
this.Client.Committing += delegate(object sender, SvnCommittingEventArgs e)
{
e.LogMessage = null;
e.Cancel = true;
};
SvnCommitResult info;
SvnCommitArgs a = new SvnCommitArgs();
a.ThrowOnCancel = false;
a.RunTortoiseHooks = true;
Assert.That(this.Client.Commit(new string[] { path, path2 }, a, out info), Is.False);
Assert.That(info, Is.Null, "info should be Invalid for a canceled commit");
Collection<SvnStatusEventArgs> statee;
Client.GetStatus(path, out statee);
Assert.That(statee.Count, Is.EqualTo(1));
Assert.That(statee[0].LocalNodeStatus, Is.EqualTo(SvnStatus.Modified), "File committed even for a canceled log message");
}
/// <summary>
/// Finalizes the action by committing to the repository
/// </summary>
/// <param name="state">The state.</param>
/// <returns></returns>
private bool Commit_CommitToRepository(PendingCommitState state)
{
bool ok = false;
SvnCommitResult rslt = null;
SvnDepth depth = state.CalculateCommitDepth();
if (depth == SvnDepth.Unknown)
return false;
StringBuilder outOfDateMessage = null;
ProgressRunnerResult r = state.GetService<IProgressRunner>().RunModal(PccStrings.CommitTitle,
delegate(object sender, ProgressWorkerArgs e)
{
SvnCommitArgs ca = new SvnCommitArgs();
ca.Depth = depth;
ca.KeepLocks = state.KeepLocks;
ca.KeepChangeLists = state.KeepChangeLists;
ca.LogMessage = state.LogMessage;
ca.AddExpectedError(SvnErrorCode.SVN_ERR_RA_OUT_OF_DATE);
ca.AddExpectedError(SvnErrorCode.SVN_ERR_WC_NOT_UP_TO_DATE);
ca.AddExpectedError(SvnErrorCode.SVN_ERR_FS_TXN_OUT_OF_DATE);
ok = e.Client.Commit(
state.CommitPaths,
ca, out rslt);
if(!ok && ca.LastException != null)
{
switch (ca.LastException.SvnErrorCode)
{
case SvnErrorCode.SVN_ERR_WC_NOT_UP_TO_DATE:
case SvnErrorCode.SVN_ERR_RA_OUT_OF_DATE:
case SvnErrorCode.SVN_ERR_FS_TXN_OUT_OF_DATE:
outOfDateMessage = new StringBuilder();
Exception ex = ca.LastException;
while(ex != null)
{
outOfDateMessage.AppendLine(ex.Message);
ex = ex.InnerException;
}
break;
}
}
});
if (outOfDateMessage != null)
{
state.MessageBox.Show(outOfDateMessage.ToString(),
PccStrings.OutOfDateCaption,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
if (rslt != null)
{
ILastChangeInfo ci = GetService<ILastChangeInfo>();
if (ci != null)
ci.SetLastChange(PccStrings.CommittedPrefix, rslt.Revision.ToString());
if (!string.IsNullOrEmpty(rslt.PostCommitError))
state.MessageBox.Show(rslt.PostCommitError, PccStrings.PostCommitError, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
else
{
PostCommit_IssueTracker(state, rslt);
}
}
return ok;
}
public bool Commit()
{
if (!m_loggedIn)
return false;
using (m_client = new SvnClient())
{
m_client.Authentication.Clear();
m_client.Authentication.DefaultCredentials = new System.Net.NetworkCredential(m_strUser, m_strPassword);
m_client.Authentication.SslServerTrustHandlers += delegate(object sender, SharpSvn.Security.SvnSslServerTrustEventArgs e)
{
e.AcceptedFailures = e.Failures;
e.Save = true; // save acceptance to authentication store
};
System.Collections.ObjectModel.Collection<SvnLogEventArgs> logEntries;
SvnLogArgs logArgs = new SvnLogArgs();
logArgs.Limit = 1;
try
{
m_client.GetLog(m_uriRepository.Uri, logArgs, out logEntries);
m_loggedIn = true;
}
catch (SvnException ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message, "SVN Connect Error", System.Windows.Forms.MessageBoxButtons.OK);
m_loggedIn = false;
return false;
}
try
{
SvnCommitArgs args = new SvnCommitArgs();
args.LogMessage = "Update release data " + DateTime.Now.ToString();
args.Depth = SvnDepth.Infinity;
return m_client.Commit(m_client.GetWorkingCopyRoot(m_strCheckoutPath), args);
}
catch (SvnException ex)
{
String msg = ex.Message + Environment.NewLine + Environment.NewLine +
ex.StackTrace.ToString();
System.Windows.Forms.MessageBox.Show(ex.Message, "SVN Commit Error", System.Windows.Forms.MessageBoxButtons.OK);
return false;
}
}
}
public static void CompleteSync(Parameters parameters)
{
using (var client = new SharpSvn.SvnClient())
{
SetUpClient(parameters, client);
if (parameters.UpdateBeforeCompleteSync)
{
DebugMessage(parameters, "Updating");
client.Update(parameters.Path);
DebugMessage(parameters, "Done");
}
Collection<SvnStatusEventArgs> changedFiles;
DebugMessage(parameters, "Getting status");
client.GetStatus(parameters.Path, out changedFiles);
DebugMessage(parameters, "Done");
if(changedFiles.Count == 0)
{
Console.WriteLine("No changes to commit.");
return;
}
//delete files from subversion that are not in filesystem
//add files to subversion that are new in filesystem
//modified files are automatically included as part of the commit
//TODO: check remoteStatus
DebugMessage(parameters, "Recording changes");
foreach (var changedFile in changedFiles)
{
if (changedFile.LocalContentStatus == SvnStatus.Missing)
{
// SVN thinks file is missing but it still exists hence
// a change in the case of the filename.
if (File.Exists(changedFile.Path))
{
var changedArgs = new SvnDeleteArgs {KeepLocal = true};
client.Delete(changedFile.Path, changedArgs);
}
else
client.Delete(changedFile.Path);
}
if (changedFile.LocalContentStatus == SvnStatus.NotVersioned)
{
client.Add(changedFile.Path);
}
}
DebugMessage(parameters, "Done");
var ca = new SvnCommitArgs {LogMessage = parameters.Message};
SvnCommitResult result;
DebugMessage(parameters, "Committing");
if (client.Commit(parameters.Path, ca, out result))
{
DebugMessage(parameters, "Done");
if(result == null)
{
Console.WriteLine("No result returned from commit.");
return;
}
if (!string.IsNullOrEmpty(result.PostCommitError))
{
Console.WriteLine("Post-commit hook error: " + result.PostCommitError);
return;
}
Console.WriteLine("Committed r" + result.Revision);
}
else
{
if (result != null && !string.IsNullOrEmpty(result.PostCommitError))
{
Console.WriteLine("Post-commit hook error after failed commit: " + result.PostCommitError);
return;
}
Console.WriteLine("Commit failed.");
}
}
}
public void Commit_NonRecursiveDepthEmpty()
{
SvnSandBox sbox = new SvnSandBox(this);
sbox.Create(SandBoxRepository.Empty);
string dir = sbox.Wc;
string name = Path.Combine(dir, "sd");
string f = Path.Combine(name, "f");
Client.CreateDirectory(name);
File.WriteAllText(f, "qq");
Client.Add(f);
Client.Commit(name);
Collection<SvnStatusEventArgs> st;
Client.CropWorkingCopy(name, SvnDepth.Empty);
Client.Delete(name);
Client.GetStatus(name, out st);
Assert.That(st.Count, Is.EqualTo(1));
using (SvnWorkingCopyClient wcc = new SvnWorkingCopyClient())
{
Collection<SvnWorkingCopyEntryEventArgs> lst;
wcc.GetEntries(name, out lst);
Assert.That(lst.Count, Is.EqualTo(1));
}
SvnCommitArgs ca = new SvnCommitArgs();
ca.Depth = SvnDepth.Empty;
Client.Commit(name, ca);
}
public void CommitRevision(string author, string comment, DateTime time)
{
using (var svn = new SvnClient())
{
// commit
var commitArgs = new SvnCommitArgs { LogMessage = "author: " + author + "\n" + comment };
SvnCommitResult cr;
svn.Commit(_wc, commitArgs, out cr);
if (cr == null)
{
Console.WriteLine(" Nothing to commit. Seems this revision was already added or contains only unimportant chnages ?");
return;
}
try
{
var revision = new SvnRevision(cr.Revision);
svn.SetRevisionProperty(_svnUri, revision, "svn:author", author);
svn.SetRevisionProperty(_svnUri, revision, "svn:log", comment);
svn.SetRevisionProperty(_svnUri, revision, "svn:date", time.ToString("o"));
}
catch (Exception ex)
{
_log.WriteLine("Change props error: {0}", ex);
}
}
}
