private void checkout(string alias) { string projectUrl = Url.TrimEnd('/') + "/" + alias; string tempFolder = TempFolderPath(alias); bool workingCopy = false; if (Directory.Exists(Path.Combine(tempFolder, ".svn"))) { workingCopy = true; } using (SvnClient client = new SvnClient()) { client.LoadConfiguration("path"); client.Authentication.DefaultCredentials = new NetworkCredential(Login, Password); if (!workingCopy) { if (Directory.Exists(Path.Combine(TempFolderPath(string.Empty), ".svn"))) { SvnUriTarget target = new SvnUriTarget(projectUrl); if (!Directory.Exists(tempFolder)) { Directory.CreateDirectory(tempFolder); } Collection <SvnInfoEventArgs> info; bool res = client.GetInfo(target, new SvnInfoArgs { ThrowOnError = false }, out info); if (res) { client.CheckOut(target, tempFolder); } } else { SvnUriTarget target = new SvnUriTarget(Url); Collection <SvnInfoEventArgs> info; bool res = client.GetInfo(target, new SvnInfoArgs { ThrowOnError = false }, out info); if (res) { client.CheckOut(target, TempFolderPath(string.Empty)); } } } else { client.Update(tempFolder); } } }
internal void CheckOut(SvnClient client, SvnUriTarget url, string path, SvnCheckOutArgs args, bool cleanUpWhenLocked) { try { bool foundLockException = false; int cleanupCount = 0; do { try { foundLockException = false; if (args != null) { client.CheckOut(url, path, args); } else { client.CheckOut(url, path); } } catch (SvnException ex) { foundLockException = true; if ((ex.SvnErrorCode == SvnErrorCode.SVN_ERR_WC_CLEANUP_REQUIRED || ex.SvnErrorCode == SvnErrorCode.SVN_ERR_WC_LOCKED || ex.SvnErrorCode == SvnErrorCode.SVN_ERR_WC_DB_ERROR || ex.SvnErrorCode == SvnErrorCode.SVN_ERR_SQLITE_BUSY) && cleanUpWhenLocked) { client.CleanUp(path, new SvnCleanUpArgs() { ClearDavCache = true, BreakLocks = true, IncludeExternals = true, }); cleanupCount++; } else { throw; } if (cleanupCount >= 5) { throw new Exception("Cleanup was done 5 time. So we decided to stop it. You can try Checking out again."); } } } while (foundLockException && cleanUpWhenLocked); } catch (Exception) { throw; } }
public void CreateDirectory_CreateTrunk() { SvnSandBox sbox = new SvnSandBox(this); Uri ReposUrl = sbox.CreateRepository(SandBoxRepository.Empty); using (SvnClient client = NewSvnClient(true, false)) { Uri trunkUri = new Uri(ReposUrl, "trunk/"); client.RemoteCreateDirectory(trunkUri); string trunkPath = sbox.Wc; client.CheckOut(trunkUri, trunkPath); TouchFile(Path.Combine(trunkPath, "test.txt")); Assert.That(SvnTools.IsManagedPath(trunkPath)); Assert.That(SvnTools.IsBelowManagedPath(trunkPath)); Assert.That(SvnTools.IsBelowManagedPath(Path.Combine(trunkPath, "q/r/s/t/u/v/test.txt"))); client.Add(Path.Combine(trunkPath, "test.txt")); Directory.CreateDirectory(Path.Combine(trunkPath, "dir")); TouchFile(Path.Combine(trunkPath, "dir/test.txt")); SvnAddArgs aa = new SvnAddArgs(); aa.AddParents = true; client.Add(Path.Combine(trunkPath, "dir/test.txt"), aa); client.Commit(trunkPath); client.RemoteDelete(trunkUri, new SvnDeleteArgs()); } }
public static void SyncLocalFolderWithO2XRulesDatabase() { try { "in SyncLocalFolderWithO2XRulesDatabase".debug(); //var targetLocalDir = XRules_Config.PathTo_XRulesDatabase_fromO2; var targetLocalDir = PublicDI.config.LocalScriptsFolder; var o2XRulesSvn = PublicDI.config.SvnO2DatabaseRulesFolder; "starting Sync with XRules Database to {0}".info(targetLocalDir); using (SvnClient client = new SvnClient()) { if (targetLocalDir.dirExists().isFalse() || targetLocalDir.pathCombine(".svn").dirExists().isFalse()) { "First Sync, so doing an SVN Checkout to: {0}".info(targetLocalDir); Files.deleteFolder(targetLocalDir, true); client.CheckOut(new Uri(o2XRulesSvn), targetLocalDir); } else { "Local XRules folder exists, so doing an SVN Update".info(); client.Update(targetLocalDir); } "SVN Sync completed".debug(); } } catch (Exception ex) { ex.log("in SvnApi.SyncLocalFolderWithO2XRulesDatabase"); } }
public void Log_LogFromFile() { SvnSandBox sbox = new SvnSandBox(this); Uri repos = sbox.CreateRepository(SandBoxRepository.MergeScenario); string dir = sbox.Wc; using (SvnClient client = new SvnClient()) { client.CheckOut(new Uri(repos, "trunk/"), dir); int n = 0; client.Log(Path.Combine(dir, "index.html"), delegate(object sender, SvnLogEventArgs e) { switch (n++) { case 0: Assert.That(e.LogMessage, Is.EqualTo("Merge branch b - product roadmap and update about page")); break; case 1: Assert.That(e.LogMessage, Is.EqualTo("Merge branch a. Added medium product")); break; case 2: Assert.That(e.LogMessage, Is.EqualTo("Create initial product structure")); break; } }); Assert.That(n, Is.EqualTo(3)); } }
public void Resolve_RepeatedEventHookUp_SOC_411() { SvnSandBox sbox = new SvnSandBox(this); Uri projectRoot = new Uri("https://ctf.open.collab.net/svn/repos/sharpsvn/trunk/scripts"); using (var svnClient = new SvnClient()) { for (int i = 0; i < 3; i++) { string workingcopy = sbox.GetTempDir(); Directory.CreateDirectory(workingcopy); svnClient.Authentication.UserNamePasswordHandlers += DoNowt; try { SvnUpdateResult svnUpdateResult; SvnCheckOutArgs ca = new SvnCheckOutArgs() { Depth = SvnDepth.Files }; Assert.IsTrue(svnClient.CheckOut(projectRoot, workingcopy, ca, out svnUpdateResult)); Assert.IsNotNull(svnUpdateResult); Assert.IsTrue(svnUpdateResult.HasRevision); } finally { svnClient.Authentication.UserNamePasswordHandlers -= DoNowt; } } } }
/// <summary> /// 初始化 如果没有被管理,则签出 /// </summary> /// <returns></returns> public bool Init() { ShowInfo("正在初始化...."); bool result = true; HandEvents(); if(!SvnTools.IsManagedPath(GetAppLoc()))//查看某目录是否是受svn管理的状态, 即是否为工作副本 { notiny = "正在检出文件."; ShowInfo(); result = SC.CheckOut(new SvnUriTarget(svnurl), GetAppLoc()); ShowInfo("文件检出完成."); } ShowInfo("初始化完毕."); return result; }
public void Create(SandBoxRepository type, bool useTrunk) { _repositoryUri = CreateRepository(type); _uri = _repositoryUri; if (useTrunk) { switch (type) { case SandBoxRepository.Default: case SandBoxRepository.DefaultBranched: case SandBoxRepository.MergeScenario: case SandBoxRepository.AnkhSvnCases: case SandBoxRepository.Greek: _uri = new Uri(_repositoryUri, "trunk/"); break; } } using (SvnClient cl = new SvnClient()) { cl.UseDefaultConfiguration(); // Don't load config cl.CheckOut(_uri, Wc); } }
public bool checkedOut(UsuarioSVN usuSVN) { SvnUpdateResult result; SvnCheckOutArgs args = new SvnCheckOutArgs(); 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); if (client.CheckOut(target, usuSVN.RutaLocal, args, out result)) { return(true); } } catch (SvnException se) { return(false); } catch (UriFormatException ufe) { return(false); } } return(true); }
public override string CheckOut(IPackageTree packageTree, FileSystemInfo destination) { SvnUpdateResult result = null; using (var client = new SvnClient()) { try { var svnOptions = new SvnCheckOutArgs(); if (UseRevision.HasValue) svnOptions.Revision = new SvnRevision(UseRevision.Value); client.CheckOut(new SvnUriTarget(new Uri(Url)), destination.FullName, svnOptions, out result); } catch (SvnRepositoryIOException sre) { HandleExceptions(sre); } catch (SvnObstructedUpdateException sue) { HandleExceptions(sue); } } return result.Revision.ToString(); }
public void Checkout(string repoUrl, string destinationFolderPath) { using (SvnClient client = new SvnClient()) { client.Authentication.ForceCredentials(SvnUserName, SvnUserPassword); client.CheckOut(new Uri(repoUrl), destinationFolderPath); } }
private static void Checkout(SvnClient client, Uri svnuri) { Console.WriteLine("Checking out {0}", svnuri); string localPath = Path.Combine(Environment.CurrentDirectory, svnuri.LocalPath.TrimStart(new[] { '/' })); client.CheckOut(svnuri, localPath); }
private void FullCheckout(SvnClient svn, Uri svnUri, SvnChangeset set, string workPath) { svn.CheckOut(svnUri, workPath, new SvnCheckOutArgs { Revision = set.Revision }); }
private void dlModWorker_DoWork(object sender, DoWorkEventArgs e) { SvnClient client = new SvnClient(); string[] args = (string[])e.Argument; string remLocation = args[0]; string locLocation = args[1]; remLocation = remLocation.Replace(System.IO.Path.GetFileName(new Uri(remLocation).LocalPath), ""); locLocation = Path.GetDirectoryName(locLocation); Debug.WriteLine(remLocation + " && " + locLocation); BackgroundWorker worker = sender as BackgroundWorker; if (Directory.Exists(locLocation)) { Directory.Delete(locLocation, true); } Directory.CreateDirectory(locLocation); if (Directory.Exists(Path.Combine(locLocation, ".svn"))) { client.CleanUp(locLocation); } client.CheckOut(new Uri(remLocation), locLocation); fexeProcessDirectory(locLocation); // aka the "thanks a lot, flatgrass" function }
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); } }
/// <summary> /// 执行检出操作 /// </summary> /// <param name="repositoryPath">svn服务器路径</param> /// <param name="workDirectory">工程本地工作路径</param> /// <param name="svnPath">本地svn路径</param> /// <param name="checkResult">检出操作的结果</param> /// <returns>返回检出操作的日志</returns> public string CheckOut(string repositoryPath,string workDirectory,out string checkResult,string xmlConfigPath) { string err; string time; XmlDao xmlDao = new XmlDao(); XmlNodeList xmlNodeList=xmlDao.XmlQuery("config/preferences/SvnPath", xmlConfigPath); string svnPath=xmlNodeList[0].InnerText; using (SvnClient client = new SvnClient()) { Tools tools = new Tools(); string checkOutLog = ""; try { client.CheckOut(new Uri(repositoryPath), workDirectory); string args = "checkout " + repositoryPath + " " + workDirectory; checkOutLog = tools.BuildProject(svnPath, args, null, out err, out time); checkResult = "successful"; return checkOutLog; } catch (Exception ex) { checkResult = " failed"; checkOutLog = ex.Message; return checkOutLog; } } }
/// <summary> /// 执行检出操作 /// </summary> /// <param name="repositoryPath">svn服务器路径</param> /// <param name="workDirectory">工程本地工作路径</param> /// <param name="svnPath">本地svn路径</param> /// <param name="checkResult">检出操作的结果</param> /// <returns>返回检出操作的日志</returns> public string CheckOut(string repositoryPath, string workDirectory, out string checkResult, string xmlConfigPath) { string err; string time; XmlDao xmlDao = new XmlDao(); XmlNodeList xmlNodeList = xmlDao.XmlQuery("config/preferences/SvnPath", xmlConfigPath); string svnPath = xmlNodeList[0].InnerText; using (SvnClient client = new SvnClient()) { Tools tools = new Tools(); string checkOutLog = ""; try { client.CheckOut(new Uri(repositoryPath), workDirectory); string args = "checkout " + repositoryPath + " " + workDirectory; checkOutLog = tools.BuildProject(svnPath, args, null, out err, out time); checkResult = "successful"; return(checkOutLog); } catch (Exception ex) { checkResult = " failed"; checkOutLog = ex.Message; return(checkOutLog); } } }
protected override void FetchRepository(Arguments arg) { Guard.AssertNotNullOrEmpty(arg.Url, "SVN URL must be set."); SvnUpdateResult result; SvnUriTarget target = new SvnUriTarget(arg.Url); SvnCheckOutArgs args = new SvnCheckOutArgs(); if (arg.Revision.HasValue) { args.Revision = new SvnRevision(arg.Revision.Value); } args.AllowObstructions = true; args.IgnoreExternals = true; using (SvnClient client = new SvnClient()) { client.Progress += ClientOnProgress; client.Cancel += ClientOnCancel; try { client.CheckOut(target, RootPath, args, out result); } catch (Exception e) { } } }
public void GetLatestOfDay(DateTime dt, string checkOutDir) { GetHistory(); var version = reversedFileversion.FirstOrDefault(x => x.Time.Date == dt.Date); if (version == null) { return; } using (SvnClient client = new SvnClient()) { client.Update(_excelFilePath); Uri uri = new Uri("http://rsin-svnsr.india.rsystems.com/svn/Media-Valet/SDLC/Release/Status/"); var svnCheckOutArgs = new SvnCheckOutArgs(); svnCheckOutArgs.Revision = version.Revision; if (File.Exists(Path.Combine(checkOutDir, "Progress Tracking.xlsx"))) { File.Delete(Path.Combine(checkOutDir, "Progress Tracking.xlsx")); } client.CheckOut(uri, checkOutDir, svnCheckOutArgs); } }
/// <summary> /// Checks out the latest from the Server, and updates the local working copy. /// </summary> /// <returns></returns> public bool CheckOut(string localRepo) { var localUri = _svnClient.GetUriFromWorkingCopy(localRepo); var svnUriTarget = new SvnUriTarget(localUri); //TODO: why is this the only place URI is used? _repo = localRepo; return(_svnClient.CheckOut(svnUriTarget, _repo)); }
public override void Checkout(string url, FilePath path, Revision rev, bool recurse, IProgressMonitor monitor) { SvnCheckOutArgs args = new SvnCheckOutArgs(); BindMonitor(args, monitor); args.Depth = recurse ? SvnDepth.Infinity : SvnDepth.Empty; client.CheckOut(new SvnUriTarget(url, GetRevision(rev)), path); }
private bool FullCheckout(int revision) { CleanFolder(); var target = new SvnUriTarget(RepositoryUrl, revision); var result = _SvnClient.CheckOut(target, LocalPath); return(result); }
public void CheckOut(string repositoryURL, string localPath) { using (SvnClient client = new SvnClient()) { SvnCheckOutArgs args = new SvnCheckOutArgs(); SvnUriTarget target = new SvnUriTarget(repositoryURL); client.CheckOut(target, localPath, args); } }
/// <summary> /// Cambiar de ubicacion la copia de trabajo. /// </summary> /// <param name="rutaRepositorio"></param> /// <param name="rutaCopiaTrabajo"></param> /// <param name="rutaRepoAntigua"></param> /// <param name="rutaCopiaAntigua"></param> /// <returns></returns> public static string ActualizarCopiaTrabajo(string rutaRepositorio, string rutaCopiaTrabajo, string rutaRepoAntigua, string rutaCopiaAntigua) { var msj = ""; if (rutaRepositorio == rutaCopiaTrabajo) { return("Error al crear la copia de trabajo: La ruta del repositorio no puede ser la misma que la de la ruta de trabajo."); } if (rutaCopiaTrabajo == rutaCopiaAntigua) { return("Exito"); } // TODO Checar si ya hay un repositorio o copia en las rutas proporcionadas. using (var client = new SvnClient()) { try { // SvnUriTarget es una clase que envuelve las URIs de los repositorios SVN. var target = new SvnUriTarget(rutaRepositorio); // Hacemos el "svn checkout". if (client.CheckOut(target, rutaCopiaTrabajo)) { msj = "Exito"; } else { msj += "Error al crear la copia de trabajo."; } } catch (SvnException se) { Debug.WriteLine(se.ToString()); msj += "Error al crear la copia de trabajo: " + se.Message; if (se.InnerException != null) { msj += " " + se.InnerException.Message; } } catch (UriFormatException ufe) { Debug.WriteLine(ufe.ToString()); msj += "Error al con la ruta proporcionada: " + ufe.Message; if (ufe.InnerException != null) { msj += " " + ufe.InnerException.Message; } } } return(msj); }
static void Main(string[] args) { using (SvnClient client = new SvnClient()) { SvnUpdateResult result; // Checkout the code to the specified directory client.CheckOut(new Uri("https://svn01.bauerverlag.de/svn/dev_net/dev/Beispiele/"), @"C:\test\SharpSvnCheckoutTest", out result); } }
/// <summary> /// Method to checkout current source code from the specified /// repository with given url and a destination folder /// </summary> /// <param name="repo"> /// Repository under consideration /// </param> /// <param name="url"> /// URL from where the source code to checkout /// </param> /// <param name="destinationFolder"> /// Folder to save the source code /// </param> static public void CheckOutFromSourceSVN(string repo, string url, string destinationFolder) { if (repo.Equals(eRepository.svn.ToString())) { using (SvnClient client = new SvnClient()) { SvnUriTarget uriTarget = new SvnUriTarget(url); client.CheckOut(uriTarget, destinationFolder); } } }
protected virtual void CheckOutPackage(SvnClient svnClient, string packageUrl, string packagePath) { try { var packageContentUrl = GetPackageContentUri(packageUrl); svnClient.CheckOut(packageContentUrl, packagePath, new SvnCheckOutArgs { AllowObstructions = true }); Logger.LogInfo($"CheckOut: {packagePath}"); } catch (Exception e) { Logger.LogError(e.Message); } }
public static void Update(ConfigRepository repository, Log log, string directory) { if (!repository.Enabled) { Utility.Log(LogStatus.Skipped, string.Format("Disabled - {0}", repository.Url), log); } else if (string.IsNullOrWhiteSpace(repository.Url)) { Utility.Log(LogStatus.Skipped, string.Format("No Url specified - {0}", repository.Url), log); } else { try { string dir = Path.Combine(directory, repository.Url.GetHashCode().ToString("X")); using (var client = new SvnClient()) { bool cleanUp = false; client.Conflict += delegate(object sender, SvnConflictEventArgs eventArgs) { eventArgs.Choice = SvnAccept.TheirsFull; }; client.Status(dir, new SvnStatusArgs { ThrowOnError = false }, delegate(object sender, SvnStatusEventArgs args) { if (args.Wedged) { cleanUp = true; } }); if (cleanUp) { client.CleanUp(dir); } client.CheckOut(new Uri(repository.Url), dir); client.Update(dir); Utility.Log(LogStatus.Ok, string.Format("Updated - {0}", repository.Url), log); } } catch (SvnException ex) { Utility.Log(LogStatus.Error, string.Format("{0} - {1}", ex.RootCause, repository.Url), log); } catch (Exception ex) { Utility.Log(LogStatus.Error, string.Format("{0} - {1}", ex.Message, repository.Url), log); } } }
public bool RefreshWorkingCopy() { _Logger.Info("Starting to refresh the working copy folder"); if (!IsSvnControlled(WorkingCopyPath)) { _Logger.Info("No working copy folder or currently not under SVN control. Checking out content"); SvnCheckOutArgs checkoutArgs = new SvnCheckOutArgs(); checkoutArgs.Depth = SvnDepth.Infinity; checkoutArgs.Notify += new EventHandler <SvnNotifyEventArgs>(CheckoutNotificationHandler); try { SvnUpdateResult result; bool returncode = _SvnClient.CheckOut(SvnUriTarget.FromString(RepositoryUri), WorkingCopyPath, out result); if (returncode) { _RepositoryRevision = (int)result.Revision; _Logger.Info(String.Format("Sucessfully checked out revision {0} from {1} to {2}", _RepositoryRevision, RepositoryUri, WorkingCopyPath)); } } catch (Exception ex) { _Logger.Fatal(String.Format("Checkout from {0} to {1} failed! - {2}", RepositoryUri, WorkingCopyPath, ex)); return(false); } } else { _Logger.Info("Updating working copy folder"); SvnUpdateArgs updateArgs = new SvnUpdateArgs(); updateArgs.Depth = SvnDepth.Infinity; updateArgs.Notify += new EventHandler <SvnNotifyEventArgs>(CheckoutNotificationHandler); updateArgs.Conflict += new EventHandler <SvnConflictEventArgs>(ConflictHandler); try { SvnUpdateResult result; bool returncode = _SvnClient.Update(WorkingCopyPath, updateArgs, out result); if (!returncode || (result.Revision < 0)) { _Logger.Error(String.Format("Updating from {0} to {1} failed!", RepositoryUri, WorkingCopyPath)); return(false); } _RepositoryRevision = (int)result.Revision; _Logger.Info(String.Format("Sucessfully updated to revision {0}", _RepositoryRevision)); } catch (Exception ex) { _Logger.Fatal(String.Format("Checkout from {0} to {1} failed! - {2}", RepositoryUri, WorkingCopyPath, ex)); return(false); } } return(true); }
public void CheckOut(string svnUriTarget, string SvnPathTarget) { ShowState(String.Format("{0} start CheckOut", SvnPathTarget)); client.CheckOut(new SvnUriTarget(svnUriTarget), SvnPathTarget); SvnInfoEventArgs clientInfo; client.GetInfo(new SvnPathTarget(SvnPathTarget), out clientInfo); if (!client.Update(SvnPathTarget)) { ShowState(String.Format("{0} CheckOut errer", SvnPathTarget)); } ShowState(string.Format("Svn remote path is :{0} \r\nLocal path is :{1} \r\nLast change revision is :{2} \r\nLast change time is :{3} \r\nLast change author is :{4} \r\n", clientInfo.Uri, clientInfo.Path, clientInfo.LastChangeRevision, clientInfo.LastChangeTime, clientInfo.LastChangeAuthor, clientInfo.Revision)); }
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) { WorkerArguments arguments = (WorkerArguments)e.Argument; using (SvnClient client = new SvnClient()) { SvnUI.Bind(client, this); SvnUriTarget svnUri = new SvnUriTarget(arguments.uri); SvnUpdateResult result; client.CheckOut(svnUri, arguments.checkoutFolder, arguments.checkoutArgs, out result); e.Result = result; } }
public static void CheckOut(string source, string target, string SVNUser, string SVNPassword) { using (SvnClient client = new SvnClient()) { client.LoadConfiguration(Path.Combine(Path.GetTempPath(), "Svn"), true); client.Authentication.SslServerTrustHandlers += delegate(object sender, SvnSslServerTrustEventArgs e) { e.Cancel = false; }; client.Authentication.DefaultCredentials = new System.Net.NetworkCredential(SVNUser, SVNPassword); client.CheckOut(new SvnUriTarget(source), target); } }
static public void Checkout(Uri fromUri, string localPath, SvnDepth depth) { using (SvnClient svnClient = new SvnClient()) { try { SvnCheckOutArgs args = new SvnCheckOutArgs(); args.Depth = depth; svnClient.CheckOut(fromUri, localPath, args); } catch (Exception ex) { LogMessage(ex.Message); } } }
public override void Checkout(string url, FilePath path, Revision rev, bool recurse, IProgressMonitor monitor) { var args = new SvnCheckOutArgs(); BindMonitor(monitor); args.Depth = recurse ? SvnDepth.Infinity : SvnDepth.Empty; lock (client) { try { client.CheckOut(new SvnUriTarget(url, GetRevision(rev)), path); } catch (SvnOperationCanceledException) { if (Directory.Exists(path.ParentDirectory)) { FileService.DeleteDirectory(path.ParentDirectory); } } } }
public void GetProject() { if (mClient == null) { Init(); } try { mClient.CheckOut(new Uri(mSourceConnectionDetails.SourceURL + mSourceConnectionDetails.GingerSolutionName + @"/SharedRepository"), mSolutionFullLocalPath + @"/SharedRepository", out mOperationResult); } catch (Exception ex) { mClient = null; throw ex; } }
protected override void ExecuteSVNTask(SvnClient client) { if (Dir.Exists && !IsEmpty(Dir)) { throw new BuildException(string.Format(Resources.SVNCheckoutEmptyDirectory, Dir.FullName), Location); } Log(Level.Info, Resources.SVNCheckingOut, Url, Dir.FullName); SvnCheckOutArgs args = new SvnCheckOutArgs(); args.ThrowOnError = true; args.Depth = SvnDepth.Infinity; args.Revision = SvnRevision.Head; SvnUpdateResult result; bool conflictedFiles = false; client.Conflict += delegate(object sender, SvnConflictEventArgs conflictArgs) { conflictedFiles = true; Log(Level.Warning, string.Concat(@"Conflicted: ", conflictArgs.Path)); }; client.Notify += delegate(object sender, SvnNotifyEventArgs notifyArgs) { Log(Level.Info, string.Concat(notifyArgs.Action, ": ", notifyArgs.Path)); }; client.CheckOut(SvnUriTarget.FromUri(Url), Dir.FullName, args, out result); if (conflictedFiles) { throw new BuildException(string.Format(Resources.SVNConflict, Dir.FullName)); } if (result != null) { Log(Level.Info, Resources.SVNCheckedOut, Dir.FullName, result.Revision); } }
/// <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) { SvnUriTarget uriTarget = new SvnUriTarget(RepositoryUrl); SvnCheckOutArgs checkOutArgs = new SvnCheckOutArgs(); checkOutArgs.Depth = GetDepth(); checkOutArgs.IgnoreExternals = IgnoreExternals; checkOutArgs.Revision = RevisionParser.SafeParse(Revision); SvnUpdateResult result; bool success = client.CheckOut(uriTarget, RepositoryPath, checkOutArgs, out result); if (result.HasRevision) { CheckedRevision = result.Revision; Log.LogMessage(MessageImportance.Normal, "Checked revision: {0}", CheckedRevision); } if (result.HasResultMap) { ReadResults(result); } return success; }
private static void Main(string[] args) { //SvnUpdateResult provides info about what happened during a checkout //we will use this to tell CheckOut() which revision to fetch //SvnCheckoutArgs wraps all of the options for the 'svn checkout' function SvnCheckOutArgs arguments = new SvnCheckOutArgs(); bool tagOk = false; string tag = string.Empty; while (!tagOk) { Console.WriteLine("Tag: "); tag = Console.ReadLine(); Regex twoDotPattern = new Regex("[0-9]*[.][0-9]*[.][0-9]*"); if (string.IsNullOrEmpty(tag)) { Console.WriteLine("Tag vuoto."); } else { if (!twoDotPattern.IsMatch(tag)) { Console.WriteLine("Tag non corretto."); } else { tagOk = true; } } } string reposUri = string.Format(ConfigurationManager.AppSettings["ReposUri"], tag); string defaultPath = ConfigurationManager.AppSettings["DefaultPath"]; bool pathOk = false; string localPath = string.Empty; while (!pathOk) { try { Console.WriteLine("Local path to checkout (default {0}): ", defaultPath); string startingPath = Console.ReadLine(); if (string.IsNullOrEmpty(startingPath)) { startingPath = defaultPath; } localPath = Path.Combine(startingPath, tag); //Verifico se la dir è vuota if(Directory.Exists(localPath)) { string[] fileSystemEntries = Directory.GetFileSystemEntries(localPath); if (fileSystemEntries.Length > 0) { throw new Exception("La directory non è vuota!"); } } pathOk = true; } catch (Exception e) { Console.WriteLine("Errore: {0}", e.Message); pathOk = false; } } Console.WriteLine("TAG: " + tag); Console.WriteLine("LOCAL PATH: " + localPath); Console.WriteLine("Repos URI: " + reposUri); Console.WriteLine("Prosegui? (Y/N)"); if (Console.ReadLine().ToUpper() == "Y") { using (SvnClient client = new SvnClient()) try { //client.Processing +=new EventHandler<SvnProcessingEventArgs>(client_Processing); //client.Committing +=new EventHandler<SvnCommittingEventArgs>(client_Committing); //client.Progress += new EventHandler<SvnProgressEventArgs>(ClientProgress); //SvnUriTarget is a wrapper class for SVN repository URIs SvnUriTarget target = new SvnUriTarget(reposUri); SvnUpdateResult result; client.CheckOut(target, localPath, arguments, out result); //client.Update(localPath, out result); Console.WriteLine("OK: " + result); } catch (SvnException se) { Console.WriteLine(se.Message); throw se; } catch (UriFormatException ufe) { Console.WriteLine(ufe.Message); throw ufe; } Console.WriteLine("Vuoi copiare i file di deploy sui server di produzione? (Y/N)"); if (Console.ReadLine().ToUpper() == "Y") { //Verifica dell'esistenza dei file di configurazione string configurationFilesPath = Path.Combine(localPath, @"Build\ProductionConfigurations"); bool confOk = false; string webDPCList = string.Empty; while (!confOk) { try { Console.WriteLine("Elenco dei DPC separati da vigola: "); webDPCList = Console.ReadLine(); foreach (string webDPCName in webDPCList.Split(',')) { if (!File.Exists(Path.Combine(configurationFilesPath, webDPCName + ".xml"))) { throw new Exception(string.Format("Configurazione per il DPC {0} non trovata", webDPCName)); } } confOk = true; } catch (Exception e) { Console.WriteLine(e.Message); confOk = false; } } try { Executor executorDeploy = new Executor(); executorDeploy.WorkingDirectory = localPath + @"\Build"; executorDeploy.FileName = String.Format(string.Format(@"{0}\Build\nant\bin\NAnt.exe", localPath)); executorDeploy.Arguments = "CopyFilesOnServerDeploy -D:WebDPCList=" + webDPCList; executorDeploy.ErrorMatchString = "BUILD FAILED"; executorDeploy.Exec(); } catch (Exception e) { Console.WriteLine(e.Message); } } } Console.ReadLine(); }
/// <summary> /// While the server isn't up to date /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void doSvnUpdate(object sender, DoWorkEventArgs e) { client = new SvnClient(); client.Notify += onSvnNotify; client.Authentication.Clear(); client.Authentication.DefaultCredentials = null; System.Console.Out.WriteLine(client.GetUriFromWorkingCopy(System.IO.Directory.GetCurrentDirectory())); Uri rep = client.GetUriFromWorkingCopy(System.IO.Directory.GetCurrentDirectory()); Uri rel = new Uri("http://subversion.assembla.com/svn/skyrimonlineupdate/"); if (rep == null || rep != rel) { SvnDelete.findSvnDirectories(System.IO.Directory.GetCurrentDirectory()); exploreDirectory(rel); download.Maximum = iCount; updating = true; SvnCheckOutArgs args = new SvnCheckOutArgs(); args.AllowObstructions = true; if (client.CheckOut(rel, System.IO.Directory.GetCurrentDirectory(), args, out mResult)) { updated = true; } } else { downloadprogress.Text = "Building update list, please be patient..."; updating = true; SvnStatusArgs sa = new SvnStatusArgs(); sa.RetrieveRemoteStatus = true; Collection<SvnStatusEventArgs> r; client.GetStatus(System.IO.Directory.GetCurrentDirectory(), sa, out r); foreach (SvnStatusEventArgs i in r) { client.Revert(i.FullPath); if (i.IsRemoteUpdated) iCount++; } download.Maximum = iCount; SvnUpdateArgs args = new SvnUpdateArgs(); args.AllowObstructions = true; if (client.Update(System.IO.Directory.GetCurrentDirectory(), args)) { updated = true; } else { Application.Exit(); } } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); string localProdDirectoryRootedPath = @"C:\Code\PROD"; string repositorySourceDirectoryUri = @"https://github.com/CosimoDeMedici/Duomo/trunk/Source"; // NOTE, http:// requires final '/' whereas svn:// does not. int repositorySourceDirectoryUriLength = repositorySourceDirectoryUri.Length; // TODO, will need to ensure no duplicate repository solution URIs. Dictionary<string, int> repositorySolutionUrisAndRevisions = new Dictionary<string, int>(); repositorySolutionUrisAndRevisions.Add(@"https://github.com/CosimoDeMedici/Duomo/trunk/Source/Common/Applications/Gunther/Duomo.Common.Gunther.sln", 17); // Ensure that all repository solution URIs are in the source directory. Dictionary<string, int> repositorySolutionRelativeUrisAndRevisions = new Dictionary<string, int>(); foreach (string curUri in repositorySolutionUrisAndRevisions.Keys) { if (curUri.Substring(0, repositorySourceDirectoryUriLength) == repositorySourceDirectoryUri) { string solutionRelativeUri = curUri.Substring(repositorySourceDirectoryUriLength); repositorySolutionRelativeUrisAndRevisions.Add(solutionRelativeUri, repositorySolutionUrisAndRevisions[curUri]); } else { throw new ApplicationException(String.Format("Repository solution URI '{0}' was not within the repositoryl source directory URI '{1}'.", curUri, repositorySourceDirectoryUri)); } } // Checkout (the checkout command will update if the directory already exists) the Lib directory. This assumes there is a 'Lib' directory as a sibling to the main 'Source' directory. string libFolderName = @"Lib"; string localLibDirectoryRootedPath = Path.Combine(localProdDirectoryRootedPath, libFolderName); Uri uri = new Uri(repositorySourceDirectoryUri); string repositorySourceParentDirectoryUri = uri.GetParentUriString(); uri = new Uri(repositorySourceParentDirectoryUri); string repositoryLibDirectoryUri = uri.AppendSegment(libFolderName); using (SvnClient client = new SvnClient()) { SvnUriTarget target = new SvnUriTarget(repositoryLibDirectoryUri); client.CheckOut(new SvnUriTarget(repositoryLibDirectoryUri), localLibDirectoryRootedPath); } // For each solution, check out the solution's directory to the proper local path. WshShell wshShell = new WshShellClass(); // For creating a short-cut to the solution. foreach (string curRelativeUri in repositorySolutionRelativeUrisAndRevisions.Keys) { // Check out the solution. string curRepoRootedUri = repositorySourceDirectoryUri + curRelativeUri; Uri curRepoUri = new Uri(curRepoRootedUri); string solutionFileName = curRepoUri.GetLeaf(); string solutionName = solutionFileName.Substring(0, solutionFileName.Length - 4); string localFolderName = Path.Combine(localProdDirectoryRootedPath, solutionName); if (!Directory.Exists(localFolderName)) { Directory.CreateDirectory(localFolderName); } string repoSolutionFolder = curRepoUri.GetParentUriString(); string localSolutionFileRootedPath = localFolderName + curRelativeUri; FileInfo fInfo = new FileInfo(localSolutionFileRootedPath); string localSolutionDirectoryRootedPath = fInfo.DirectoryName; using (SvnClient client = new SvnClient()) { client.CheckOut(new SvnUriTarget(repoSolutionFolder), localSolutionDirectoryRootedPath); } // Create a short-cut to the solution file and place it in the local folder for the solution. string shortCutFileName = String.Format("{0} - Shortcut.lnk", solutionFileName); string shortCutFileRootedPath = Path.Combine(localFolderName, shortCutFileName); if (!System.IO.File.Exists(shortCutFileRootedPath)) { IWshShortcut shortCut = (IWshShortcut)wshShell.CreateShortcut(shortCutFileRootedPath); shortCut.TargetPath = localSolutionFileRootedPath; shortCut.Save(); } // Now get the list of relative project paths by parsing the solution file. List<string> solutionFileLines = TextFileSerializer.DeserializeFromRootedPath(localSolutionFileRootedPath); List<string> projectLines = new List<string>(); string projectSignifier = @"Project"; foreach (string line in solutionFileLines) { if (line.Length >= projectSignifier.Length && projectSignifier == line.Substring(0, projectSignifier.Length)) { projectLines.Add(line); } } List<string> relativeFilePaths = new List<string>(); string[] separators = new string[] { "=", "," }; foreach (string line in projectLines) { string[] tokens = line.Split(separators, StringSplitOptions.None); string relativePath = tokens[2].Trim().Trim('"'); if (@".." == relativePath.Substring(0, 2)) // Otherwise it's a subdirectory of the main solution directory, which has already been checked out. { relativeFilePaths.Add(relativePath); } } // Now check out the folders containing each of the relative projects to their appropriate relative local paths. foreach (string relativeFilePath in relativeFilePaths) { string relativeOtherProjectPath = Path.Combine(localSolutionDirectoryRootedPath, relativeFilePath); string localOtherProjectRootedFilePath = Path.GetFullPath(relativeOtherProjectPath); FileInfo localOtherProjectFileInfo = new FileInfo(localOtherProjectRootedFilePath); string localOtherProjectDirectoryRootedPath = localOtherProjectFileInfo.DirectoryName; if (!Directory.Exists(localOtherProjectDirectoryRootedPath)) { Directory.CreateDirectory(localOtherProjectDirectoryRootedPath); } Uri repoOtherProjectUri = new Uri(repoSolutionFolder + relativeFilePath); string repoOtherProjectFolderUri = repoOtherProjectUri.GetParentUriString(); using (SvnClient client = new SvnClient()) { client.CheckOut(new SvnUriTarget(repoOtherProjectFolderUri), localOtherProjectDirectoryRootedPath); } } } }
private async void Checkout(string url) { var branchName = url.Split('/').Last(); var checkoutPath = GetDansBranchPath(branchName); var svnClient = new SvnClient(); AppendLog("Checking out from SVN..."); // This is an async operator, it makes sure Checkout() runs in background without freezing the whole application await Task.Run(() => { svnClient.CheckOut(new SvnUriTarget(url), checkoutPath); }); AppendLog("Complete!"); }
public static void downloadSVNFromFile(string file) { var files = File.ReadAllText(file).Split('\n'); using (SvnClient client = new SvnClient()) { foreach (string f in files) { Console.Out.WriteLine(f + " started."); try { string[] fparts = f.Replace("\r", "").Split(','); client.CheckOut(new Uri(fparts[0]), Directory.GetCurrentDirectory() + "\\missed\\" + fparts[1]); Console.Out.WriteLine(f + " completed."); } catch { Console.Out.WriteLine(f + " failed."); } } } }
/// <summary> /// Gets the SVN Project /// </summary> /// <param name="Projects"></param> public static void checkoutCode(List<project> Projects) { using (SvnClient client = new SvnClient()) { foreach (project p in Projects) // Checkout the code to the specified directory try { Directory.GetDirectories(Directory.GetCurrentDirectory() + "\\" + p.Name); } catch{ try { client.CheckOut(new Uri(p.SVN), Directory.GetCurrentDirectory() + "\\" + p.Name); } catch {Console.Out.WriteLine("Couldn't write: " + p.Name); } } } }
public static string Update(string url, Log log, string directory) { if (string.IsNullOrWhiteSpace(url)) { Utility.Log(LogStatus.Skipped, "Updater", string.Format("No Url specified - {0}", url), log); } else { try { var dir = Path.Combine(directory, url.GetHashCode().ToString("X")); using (var client = new SvnClient()) { var cleanUp = false; client.Conflict += delegate(object sender, SvnConflictEventArgs eventArgs) { eventArgs.Choice = SvnAccept.TheirsFull; }; client.Status( dir, new SvnStatusArgs { ThrowOnError = false }, delegate(object sender, SvnStatusEventArgs args) { if (args.Wedged) { cleanUp = true; } }); if (cleanUp) { client.CleanUp(dir); } try { if (Directory.Exists(dir)) { SvnInfoEventArgs remoteVersion; var b1 = client.GetInfo(new Uri(url), out remoteVersion); SvnInfoEventArgs localVersion; var b2 = client.GetInfo(dir, out localVersion); if (b1 && b2 && remoteVersion.Revision == localVersion.Revision) { Utility.Log( LogStatus.Ok, "Updater", string.Format("Update not needed - {0}", url), log); return dir; } } } catch (Exception ex) { Utility.Log(LogStatus.Error, "Updater", string.Format("{0} - {1}", ex, url), log); } client.CheckOut(new Uri(url), dir); client.Update(dir); Utility.Log(LogStatus.Ok, "Updater", string.Format("Updated - {0}", url), log); } return dir; } catch (SvnException ex) { Utility.Log(LogStatus.Error, "Updater", string.Format("{0} - {1}", ex.RootCause, url), log); } catch (Exception ex) { Utility.Log(LogStatus.Error, "Updater", string.Format("{0} - {1}", ex.Message, url), log); } } return string.Empty; }
private void AddButtonClick(object sender, EventArgs e) { // Get the url to the repository string answer; if (Environment.ExpandEnvironmentVariables("path").IndexOf("git") != 0) { answer = Microsoft.VisualBasic.Interaction.InputBox(Resources.addRepoMessageGitEnabled, Resources.addRepoHeader, Resources.addRepoDefaultValue); } else { answer = Microsoft.VisualBasic.Interaction.InputBox(Resources.addRepoMessageGitDisabled, Resources.addRepoHeader, Resources.addRepoDefaultValue); } if (answer == string.Empty) { return; } if (answer == "url") { MessageBox.Show(@"You must give the url", @"No url given"); return; } // Check if it is a git repository if (answer.LastIndexOf("git") != 0) { var dir = Microsoft.VisualBasic.Interaction.InputBox(Resources.repoFolderMessage, Resources.repoFolderHeader); Process.Start("git", string.Format("clone {0} {1}", answer, _installDir + "\\" + dir)).WaitForExit(); } // ...else checkout a SVN repository else { var url = new Uri(answer); using (var svnClient = new SvnClient()) { var dir = Microsoft.VisualBasic.Interaction.InputBox(Resources.repoFolderMessage, Resources.repoFolderHeader); svnClient.CheckOut(url, _installDir + "\\" + dir); } } UpdateStuff(); }
public static void Checkout(string repoDir, string wcDir) { if (Directory.Exists(wcDir)) { Directory.Delete(wcDir, true); } using (var svn = new SvnClient()) { var repoUri = new Uri("file:///" + repoDir.Replace('\\', '/')); svn.CheckOut(new SvnUriTarget(repoUri), wcDir); foreach (var fse in Directory.EnumerateFileSystemEntries(wcDir)) { if (Path.GetFileName(fse).ToLowerInvariant() == ".svn") continue; svn.Add(fse, SvnDepth.Infinity); } svn.Commit(wcDir, new SvnCommitArgs { LogMessage = "PreCreate revision" }); } }