public static void CopyFolder(NPath fromPath, NPath toPath)
{
Logger.Trace("CopyFolder fromPath: {0} toPath:{1}", fromPath.ToString(), toPath.ToString());
toPath.DeleteIfExists();
toPath.EnsureParentDirectoryExists();
fromPath.Move(toPath);
}
public GitLock(string id, NPath path, GitUser owner, DateTimeOffset locked_at)
{
this.id = id;
this.path = path.IsInitialized ? path.ToString() : null;
this.owner = owner;
this.lockedAtString = locked_at.ToUniversalTime().ToString(Constants.Iso8601FormatZ, CultureInfo.InvariantCulture);
}
private void ReadCacheFromDisk()
{
logger.Trace("ReadCacheFromDisk Path:{0}", cachePath.ToString());
ConnectionCacheItem[] connections = null;
if (cachePath.FileExists())
{
var json = cachePath.ReadAllText();
try
{
connections = SimpleJson.DeserializeObject <ConnectionCacheItem[]>(json);
}
catch (Exception ex)
{
logger.Error(ex, "Error deserializing connection cache: {0}", cachePath);
cachePath.Delete();
}
}
if (connections != null)
{
connectionCache =
connections.Select(item => new Connection {
Host = new UriString(item.Host), Username = item.Username
})
.ToDictionary(connection => connection.Host);
}
else
{
connectionCache = new Dictionary <UriString, Connection>();
}
}
public static void CopyFolderContents(NPath fromPath, NPath toPath)
{
Logger.Trace("CopyFolderContents fromPath: {0} toPath:{1}", fromPath.ToString(), toPath.ToString());
toPath.DeleteContents();
fromPath.MoveFiles(toPath, true);
}
private NPath MoveOctorun(NPath fromPath)
{
var toPath = installDetails.InstallationPath;
Logger.Trace("MoveOctorun fromPath: {0} toPath:{1}", fromPath.ToString(), toPath.ToString());
CopyHelper.Copy(fromPath, toPath);
return(installDetails.ExecutablePath);
}
public static NPath Resolve(this NPath path)
{
// Add a reference to Mono.Posix with an .rsp file in the Assets folder with the line "-r:Mono.Posix.dll" for this to work
#if ENABLE_MONO
if (!path.IsInitialized || !NPath.IsLinux /* nothing to resolve on windows */ || path.IsRelative || !path.FileExists())
{
return(path);
}
return(new NPath(Mono.Unix.UnixPath.GetCompleteRealPath(path.ToString())));
#else
return(path);
#endif
}
private void SaveUsage(UsageStore store)
{
var pathString = storePath.ToString();
Logger.Trace("SaveUsage: \"{0}\"", pathString);
try
{
var json = SimpleJson.SerializeObject(store);
storePath.WriteAllText(json, Encoding.UTF8);
}
catch (Exception ex)
{
Logger.Error(ex, "SaveUsage Error: \"{0}\"", pathString);
}
}
public GitUnlockTask(NPath path, bool force,
CancellationToken token, IOutputProcessor <string> processor = null)
: base(token, processor ?? new SimpleOutputProcessor())
{
Guard.ArgumentNotNullOrWhiteSpace(path, "path");
Name = TaskName;
var stringBuilder = new StringBuilder("unlock ");
if (force)
{
stringBuilder.Append("--force ");
}
stringBuilder.Append("\"");
stringBuilder.Append(path.ToString(SlashMode.Forward));
stringBuilder.Append("\"");
arguments = stringBuilder.ToString();
}
public void Configure(ProcessStartInfo psi, NPath workingDirectory, bool dontSetupGit = false)
{
psi.WorkingDirectory = workingDirectory;
psi.EnvironmentVariables["HOME"] = NPath.HomeDirectory;
psi.EnvironmentVariables["TMP"] = psi.EnvironmentVariables["TEMP"] = NPath.SystemTemp;
var path = Environment.Path;
psi.EnvironmentVariables["GHU_WORKINGDIR"] = workingDirectory;
if (dontSetupGit)
{
psi.EnvironmentVariables["GHU_FULLPATH"] = path;
psi.EnvironmentVariables["PATH"] = path;
return;
}
Guard.ArgumentNotNull(psi, "psi");
var pathEntries = new List <string>();
string separator = Environment.IsWindows ? ";" : ":";
NPath libexecPath = NPath.Default;
List <string> gitPathEntries = new List <string>();
if (Environment.GitInstallPath.IsInitialized)
{
var gitPathRoot = Environment.GitExecutablePath.Resolve().Parent.Parent;
var gitExecutableDir = Environment.GitExecutablePath.Parent; // original path to git (might be different from install path if it's a symlink)
var baseExecPath = gitPathRoot;
var binPath = baseExecPath;
if (Environment.IsWindows)
{
if (baseExecPath.DirectoryExists("mingw32"))
{
baseExecPath = baseExecPath.Combine("mingw32");
}
else
{
baseExecPath = baseExecPath.Combine("mingw64");
}
binPath = baseExecPath.Combine("bin");
}
libexecPath = baseExecPath.Combine("libexec", "git-core");
if (!libexecPath.DirectoryExists())
{
libexecPath = NPath.Default;
}
if (Environment.IsWindows)
{
gitPathEntries.AddRange(new[] { gitPathRoot.Combine("cmd").ToString(), gitPathRoot.Combine("usr", "bin") });
}
else
{
gitPathEntries.Add(gitExecutableDir.ToString());
}
if (libexecPath.IsInitialized)
{
gitPathEntries.Add(libexecPath);
}
gitPathEntries.Add(binPath);
// we can only set this env var if there is a libexec/git-core. git will bypass internally bundled tools if this env var
// is set, which will break Apple's system git on certain tools (like osx-credentialmanager)
if (libexecPath.IsInitialized)
{
psi.EnvironmentVariables["GIT_EXEC_PATH"] = libexecPath.ToString();
}
}
if (Environment.GitLfsInstallPath.IsInitialized && libexecPath != Environment.GitLfsInstallPath)
{
pathEntries.Add(Environment.GitLfsInstallPath);
}
if (gitPathEntries.Count > 0)
{
pathEntries.AddRange(gitPathEntries);
}
pathEntries.Add("END");
path = String.Join(separator, pathEntries.ToArray()) + separator + path;
psi.EnvironmentVariables["GHU_FULLPATH"] = path;
psi.EnvironmentVariables["PATH"] = path;
//TODO: Remove with Git LFS Locking becomes standard
psi.EnvironmentVariables["GITLFSLOCKSENABLED"] = "1";
if (Environment.IsWindows)
{
psi.EnvironmentVariables["PLINK_PROTOCOL"] = "ssh";
psi.EnvironmentVariables["TERM"] = "msys";
}
var httpProxy = Environment.GetEnvironmentVariable("HTTP_PROXY");
if (!String.IsNullOrEmpty(httpProxy))
{
psi.EnvironmentVariables["HTTP_PROXY"] = httpProxy;
}
var httpsProxy = Environment.GetEnvironmentVariable("HTTPS_PROXY");
if (!String.IsNullOrEmpty(httpsProxy))
{
psi.EnvironmentVariables["HTTPS_PROXY"] = httpsProxy;
}
}
