public SideBandInputStream(PacketLineIn aPckIn, Stream aIns, ProgressMonitor aProgress)
{
pckIn = aPckIn;
ins = aIns;
monitor = aProgress;
currentTask = "";
}
public SideBandInputStream(Stream @in, ProgressMonitor progress)
{
rawIn = @in;
pckIn = new PacketLineIn(rawIn);
monitor = progress;
currentTask = string.Empty;
progressBuffer = string.Empty;
}
internal AggregatedProgressMonitor (ProgressMonitor leaderMonitor, CancellationTokenSource cancelSource, params ProgressMonitor[] followerMonitors)
{
CancellationTokenSource = cancelSource ?? new CancellationTokenSource ();
this.leaderMonitor = leaderMonitor;
AddFollowerMonitor (leaderMonitor, MonitorAction.All);
foreach (ProgressMonitor mon in followerMonitors)
AddFollowerMonitor (mon);
}
public ComputeRelativeTimesProgressMonitor(ProgressMonitor next, Action<string> writer = null)
{
if (writer == null)
writer = s => Debug.WriteLine(s);
this.next = next;
this.writer = writer;
}
public SideBandInputStream(PacketLineIn aPckIn, Stream aIns, ProgressMonitor aProgress)
{
pckIn = aPckIn;
ins = aIns;
monitor = aProgress;
currentTask = string.Empty;
progressBuffer = string.Empty;
}
internal AggregatedProgressMonitor (ProgressMonitor masterMonitor, CancellationTokenSource cancelSource, params ProgressMonitor[] slaveMonitors)
{
CancellationTokenSource = cancelSource ?? new CancellationTokenSource ();
this.masterMonitor = masterMonitor;
AddSlaveMonitor (masterMonitor, MonitorAction.All);
foreach (ProgressMonitor mon in slaveMonitors)
AddSlaveMonitor (mon);
}
internal virtual void execute(ProgressMonitor monitor, FetchResult result)
{
_askFor.Clear();
_localUpdates.Clear();
_fetchHeadUpdates.Clear();
_packLocks.Clear();
try
{
executeImp(monitor, result);
}
finally
{
foreach (PackLock @lock in _packLocks)
{
@lock.Unlock();
}
}
}
public PushResult execute(ProgressMonitor monitor)
{
monitor.BeginTask(PROGRESS_OPENING_CONNECTION, -1);
connection = transport.openPush();
try
{
monitor.EndTask();
Dictionary<string, RemoteRefUpdate> preprocessed = prepareRemoteUpdates();
if (transport.DryRun)
modifyUpdatesForDryRun();
else if (preprocessed.Count != 0)
connection.Push(monitor, preprocessed);
}
finally
{
connection.Close();
}
if (!transport.DryRun)
updateTrackingRefs();
return prepareOperationResult();
}
public void DownloadPack(ProgressMonitor monitor)
{
Stream s = _connection.open("pack/" + PackName);
IndexPack ip = IndexPack.Create(_local, s);
ip.setFixThin(false);
ip.setObjectChecker(_objCheck);
ip.index(monitor);
PackLock keep = ip.renameAndOpenPack(_lockMessage);
if (keep != null)
{
_packLocks.Add(keep);
}
}
protected override void doFetch(ProgressMonitor monitor, List<Ref> want, List<ObjectId> have)
{
MarkLocalRefsComplete(have);
QueueWants(want);
while (!monitor.IsCancelled && _workQueue.Count > 0)
{
ObjectId id = _workQueue.First.Value;
_workQueue.RemoveFirst();
if (!(id is RevObject) || !((RevObject)id).has(COMPLETE))
{
DownloadObject(monitor, id);
}
Process(id);
}
}
private bool DownloadPackedObject(ProgressMonitor monitor, AnyObjectId id)
{
IEnumerator<RemotePack> packItr = _unfetchedPacks.GetEnumerator();
while (packItr.MoveNext() && !monitor.IsCancelled)
{
RemotePack pack = packItr.Current;
try
{
pack.OpenIndex(monitor);
}
catch (IOException err)
{
RecordError(id, err);
_unfetchedPacks.Remove(pack);
continue;
}
if (monitor.IsCancelled)
return false;
if (!pack.Index.HasObject(id))
continue;
try
{
pack.DownloadPack(monitor);
}
catch (IOException err)
{
RecordError(id, err);
continue;
}
finally
{
pack.TmpIdx.Delete();
_unfetchedPacks.Remove(pack);
}
if (!_local.HasObject(id))
{
RecordError(id,
new FileNotFoundException("Object " + id.Name + " not found in " + pack.PackName + "."));
continue;
}
IEnumerator<ObjectId> pending = SwapFetchQueue();
while (pending.MoveNext())
{
ObjectId p = pending.Current;
if (pack.Index.HasObject(p))
{
_workQueue.Remove(p);
Process(p);
}
else
_workQueue.AddLast(p);
}
return true;
}
return false;
}
protected override bool OnBuild(ProgressMonitor monitor, DeployContext ctx)
{
string tmpFolder = FileService.CreateTempDirectory();
Solution solution = null;
SolutionFolderItem entry = RootSolutionItem;
try {
if (generateFiles)
{
List <string> childEntries = new List <string> ();
if (entry is SolutionFolder)
{
SolutionFolderItem[] ents = GetChildEntries();
foreach (SolutionFolderItem it in ents)
{
childEntries.Add(it.ItemId);
}
}
else
{
// If the entry is not a combine, use the parent combine as base combine
childEntries.Add(entry.ItemId);
entry = entry.ParentFolder;
}
string sourceFile;
if (entry is SolutionFolder)
{
sourceFile = entry.ParentSolution.FileName;
}
else
{
sourceFile = ((SolutionItem)entry).FileName;
}
string efile = Services.ProjectService.Export(new FilteredProgressMonitor(monitor), sourceFile, childEntries.ToArray(), tmpFolder, null).Result;
if (efile == null)
{
monitor.ReportError(GettextCatalog.GetString("The project could not be exported."), null);
return(false);
}
solution = Services.ProjectService.ReadWorkspaceItem(new ProgressMonitor(), efile).Result as Solution;
}
else
{
solution = entry.ParentSolution;
}
var res = solution.Build(monitor, (SolutionConfigurationSelector)defaultConfig).Result;
if (res.HasErrors || monitor.CancellationToken.IsCancellationRequested)
{
return(false);
}
SolutionDeployer deployer = new SolutionDeployer(generateAutotools);
deployer.AddSwitches(switchs);
if (!deployer.Deploy(ctx, solution, DefaultConfiguration, TargetDir, generateFiles, monitor))
{
return(false);
}
} finally {
if (solution != null)
{
solution.Dispose();
}
Directory.Delete(tmpFolder, true);
}
return(true);
}
protected override void OnWriteProject(ProgressMonitor monitor, MSBuildProject msproject)
{
base.OnWriteProject(monitor, msproject);
dotNetCoreMSBuildProject.WriteProject(msproject, Project.TargetFramework.Id);
}
/// <summary>
/// Perform push operation between local and remote repository - set remote
/// refs appropriately, send needed objects and update local tracking refs.
/// <para />
/// When <seealso cref="Transport.DryRun"/> is true, result of this operation is
/// just estimation of real operation result, no real action is performed.
/// </summary>
/// <param name="monitor">
/// Progress monitor used for feedback about operation.
/// </param>
/// <returns> result of push operation with complete status description. </returns>
/// <exception cref="NotSupportedException">
/// When push operation is not supported by provided transport.
/// </exception>
/// <exception cref="TransportException">
/// When some error occurred during operation, like I/O, protocol
/// error, or local database consistency error.
/// </exception>
public PushResult execute(ProgressMonitor monitor)
{
if (monitor == null)
throw new ArgumentNullException("monitor");
monitor.BeginTask(PROGRESS_OPENING_CONNECTION, ProgressMonitor.UNKNOWN);
_connection = _transport.openPush();
try
{
monitor.EndTask();
IDictionary<string, RemoteRefUpdate> preprocessed = PrepareRemoteUpdates();
if (_transport.DryRun)
{
ModifyUpdatesForDryRun();
}
else if (preprocessed.Count != 0)
{
_connection.Push(monitor, preprocessed);
}
}
finally
{
_connection.Close();
}
if (!_transport.DryRun)
{
UpdateTrackingRefs();
}
return PrepareOperationResult();
}
public void Push(ProgressMonitor monitor, IDictionary<string, RemoteRefUpdate> refUpdates)
{
markStartedOperation();
doPush(monitor, refUpdates);
}
public abstract void PerformChange(ProgressMonitor monitor, RefactoringOptions rctx);
internal ComponentIndex GetComponentIndex(ProgressMonitor monitor)
{
// Returns an index of all components that can be added to the toolbox.
ComponentIndex index = ComponentIndex.Load();
// Get the list of assemblies that need to be updated
HashSet <string> files = new HashSet <string> ();
List <ComponentIndexFile> toupdate = new List <ComponentIndexFile> ();
List <ComponentIndexFile> todelete = new List <ComponentIndexFile> ();
foreach (ComponentIndexFile ia in index.Files)
{
files.Add(ia.FileName);
if (!File.Exists(ia.FileName))
{
todelete.Add(ia);
}
if (ia.NeedsUpdate)
{
toupdate.Add(ia);
}
if (monitor.CancellationToken.IsCancellationRequested)
{
return(index);
}
}
// Look for new assemblies
foreach (TargetRuntime runtime in Runtime.SystemAssemblyService.GetTargetRuntimes())
{
foreach (SystemAssembly asm in runtime.AssemblyContext.GetAssemblies())
{
if (files.Add(asm.Location))
{
ComponentIndexFile c = new ComponentIndexFile(asm.Location);
index.Files.Add(c);
toupdate.Add(c);
}
if (monitor.CancellationToken.IsCancellationRequested)
{
return(index);
}
}
}
foreach (ComponentIndexFile ia in todelete)
{
index.Files.Remove(ia);
}
if (toupdate.Count > 0)
{
monitor.BeginTask(GettextCatalog.GetString("Looking for components..."), toupdate.Count);
LoaderContext ctx = new LoaderContext();
try {
foreach (ComponentIndexFile ia in toupdate)
{
ia.Update(ctx);
monitor.Step(1);
if (monitor.CancellationToken.IsCancellationRequested)
{
return(index);
}
}
} finally {
ctx.Dispose();
monitor.EndTask();
}
}
if (toupdate.Count > 0 || todelete.Count > 0)
{
index.Save();
}
return(index);
}
public override void PerformChange(ProgressMonitor monitor, RefactoringOptions rctx)
{
IdeApp.Workbench.OpenDocument(FileName);
}
public override void PerformChange(ProgressMonitor monitor, RefactoringOptions rctx)
{
IdeApp.ProjectOperations.SaveAsync(this.Project);
}
public override void PerformChange(ProgressMonitor monitor, RefactoringOptions rctx)
{
File.WriteAllText(FileName, Content);
rctx.DocumentContext.Project.AddFile(FileName);
IdeApp.ProjectOperations.SaveAsync(rctx.DocumentContext.Project);
}
protected override async Task OnReevaluateProject(ProgressMonitor monitor)
{
await base.OnReevaluateProject(monitor);
UpdateHiddenFiles(Project.Files);
}
protected override async Task <ProjectFile[]> OnGetSourceFiles(ProgressMonitor monitor, ConfigurationSelector configuration)
{
var sourceFiles = await base.OnGetSourceFiles(monitor, configuration);
return(AddMissingProjectFiles(sourceFiles));
}
internal protected virtual Task PrepareExecution(ProgressMonitor monitor, ExecutionContext context, ConfigurationSelector configuration)
{
return(next.PrepareExecution(monitor, context, configuration, (SolutionRunConfiguration)context.RunConfiguration));
}
static bool UpdateCompleted(ProgressMonitor monitor,
ProjectFile file, ProjectFile genFile, SingleFileCustomToolResult result,
bool runMultipleFiles)
{
monitor.EndTask();
if (monitor.CancellationToken.IsCancellationRequested)
{
monitor.ReportError(GettextCatalog.GetString("Cancelled"), null);
monitor.Dispose();
return(false);
}
string genFileName;
try {
bool broken = false;
if (result.UnhandledException != null)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator crashed", file.Generator);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "",
msg +
": " +
result.UnhandledException.Message +
Environment.NewLine +
result.UnhandledException.StackTrace));
monitor.ReportError(msg, result.UnhandledException);
LoggingService.LogError(msg, result.UnhandledException);
}
genFileName = result.GeneratedFilePath.IsNullOrEmpty?
null : result.GeneratedFilePath.ToRelative(file.FilePath.ParentDirectory);
if (!string.IsNullOrEmpty(genFileName))
{
bool validName = genFileName.IndexOfAny(new [] { '/', '\\' }) < 0 &&
FileService.IsValidFileName(genFileName);
if (!broken && !validName)
{
broken = true;
string msg = GettextCatalog.GetString("The '{0}' code generator output invalid filename '{1}'",
file.Generator, result.GeneratedFilePath);
result.Errors.Add(new CompilerError(file.Name, 0, 0, "", msg));
monitor.ReportError(msg, null);
}
}
if (result.Errors.Count > 0)
{
Runtime.RunInMainThread(delegate {
foreach (CompilerError err in result.Errors)
{
TaskService.Errors.Add(new TaskListEntry(file.FilePath, err.ErrorText, err.Column, err.Line,
err.IsWarning? TaskSeverity.Warning : TaskSeverity.Error,
TaskPriority.Normal, file.Project.ParentSolution, file));
}
});
}
if (broken)
{
return(true);
}
if (!runMultipleFiles)
{
if (result.Success)
{
monitor.ReportSuccess("Generated file successfully.");
}
else if (result.SuccessWithWarnings)
{
monitor.ReportSuccess("Warnings in file generation.");
}
else
{
monitor.ReportError("Errors in file generation.", null);
}
}
} finally {
if (!runMultipleFiles)
{
monitor.Dispose();
}
}
if (result.GeneratedFilePath.IsNullOrEmpty || !File.Exists(result.GeneratedFilePath))
{
return(true);
}
// broadcast a change event so text editors etc reload the file
FileService.NotifyFileChanged(result.GeneratedFilePath);
// add file to project, update file properties, etc
Gtk.Application.Invoke(async(o, args) => {
bool projectChanged = false;
if (genFile == null)
{
genFile = file.Project.AddFile(result.GeneratedFilePath, result.OverrideBuildAction);
projectChanged = true;
}
else if (result.GeneratedFilePath != genFile.FilePath)
{
genFile.Name = result.GeneratedFilePath;
projectChanged = true;
}
if (file.LastGenOutput != genFileName)
{
file.LastGenOutput = genFileName;
projectChanged = true;
}
if (genFile.DependsOn != file.FilePath.FileName)
{
genFile.DependsOn = file.FilePath.FileName;
projectChanged = true;
}
if (projectChanged)
{
await IdeApp.ProjectOperations.SaveAsync(file.Project);
}
});
return(true);
}
public FilteredProgressMonitor (ProgressMonitor targetMonitor)
: this (targetMonitor, MonitorAction.WriteLog | MonitorAction.ReportError | MonitorAction.ReportWarning | MonitorAction.ReportSuccess | MonitorAction.Cancel | MonitorAction.SlaveCancel)
{
}
public CleanEventArgs(ProgressMonitor monitor)
{
this.monitor = monitor;
}
public PushResult push(ProgressMonitor monitor, ICollection<RemoteRefUpdate> toPush)
{
if (toPush == null || toPush.Count == 0)
{
try
{
toPush = findRemoteRefUpdatesFor(_pushSpecs);
}
catch (IOException e)
{
throw new TransportException("Problem with resolving push ref specs locally: " + e.Message, e);
}
if (toPush.Count == 0)
{
throw new TransportException("Nothing to push");
}
}
var pushProcess = new PushProcess(this, toPush);
return pushProcess.execute(monitor);
}
internal protected virtual Task <BuildResult> Clean(ProgressMonitor monitor, ConfigurationSelector configuration, OperationContext operationContext)
{
return(next.Clean(monitor, configuration, operationContext));
}
private void WriteCommands(IEnumerable<RemoteRefUpdate> refUpdates, ProgressMonitor monitor)
{
string capabilities = EnableCapabilities();
foreach (RemoteRefUpdate rru in refUpdates)
{
if (!_capableDeleteRefs && rru.IsDelete)
{
rru.Status = RemoteRefUpdate.UpdateStatus.REJECTED_NODELETE;
continue;
}
var sb = new StringBuilder();
Ref advertisedRef = GetRef(rru.RemoteName);
ObjectId oldId = (advertisedRef == null ? ObjectId.ZeroId : advertisedRef.ObjectId);
sb.Append(oldId.Name);
sb.Append(' ');
sb.Append(rru.NewObjectId.Name);
sb.Append(' ');
sb.Append(rru.RemoteName);
if (!_sentCommand)
{
_sentCommand = true;
sb.Append(capabilities);
}
pckOut.WriteString(sb.ToString());
rru.Status = RemoteRefUpdate.UpdateStatus.AWAITING_REPORT;
if (!rru.IsDelete)
_shouldWritePack = true;
}
if (monitor.IsCancelled)
throw new TransportException(uri, "push cancelled");
pckOut.End();
outNeedsEnd = false;
}
public Stream sideband(ProgressMonitor pm)
{
return new SideBandInputStream(this, ins, pm);
}
internal protected virtual void OnWriteSolutionFolderItemData(ProgressMonitor monitor, SlnPropertySet properties, SolutionFolderItem item)
{
next.OnWriteSolutionFolderItemData(monitor, properties, item);
}
PackageManagementEventsMonitor CreateEventMonitor(ProgressMonitor monitor, TaskCompletionSource <bool> taskCompletionSource)
{
return(CreateEventMonitor(monitor, packageManagementEvents, taskCompletionSource));
}
public void Fetch(ProgressMonitor monitor, ICollection<Ref> want, IList<ObjectId> have)
{
markStartedOperation();
doFetch(monitor, want, have);
}
internal protected virtual void OnWriteConfigurationData(ProgressMonitor monitor, SlnPropertySet properties, SolutionConfiguration configuration)
{
next.OnWriteConfigurationData(monitor, properties, configuration);
}
internal protected virtual Task <TargetEvaluationResult> OnRunTarget(ProgressMonitor monitor, string target, ConfigurationSelector configuration, TargetEvaluationContext context)
{
return(next.OnRunTarget(monitor, target, configuration, context));
}
/// <exception cref="System.NotSupportedException"></exception>
/// <exception cref="NGit.Errors.TransportException"></exception>
private void ExecuteImp(ProgressMonitor monitor, FetchResult result)
{
conn = transport.OpenFetch();
try
{
result.SetAdvertisedRefs(transport.GetURI(), conn.GetRefsMap());
ICollection <Ref> matched = new HashSet <Ref>();
foreach (RefSpec spec in toFetch)
{
if (spec.GetSource() == null)
{
throw new TransportException(MessageFormat.Format(JGitText.Get().sourceRefNotSpecifiedForRefspec
, spec));
}
if (spec.IsWildcard())
{
ExpandWildcard(spec, matched);
}
else
{
ExpandSingle(spec, matched);
}
}
ICollection <Ref> additionalTags = Sharpen.Collections.EmptyList <Ref>();
TagOpt tagopt = transport.GetTagOpt();
if (tagopt == TagOpt.AUTO_FOLLOW)
{
additionalTags = ExpandAutoFollowTags();
}
else
{
if (tagopt == TagOpt.FETCH_TAGS)
{
ExpandFetchTags();
}
}
bool includedTags;
if (!askFor.IsEmpty() && !AskForIsComplete())
{
FetchObjects(monitor);
includedTags = conn.DidFetchIncludeTags();
// Connection was used for object transfer. If we
// do another fetch we must open a new connection.
//
CloseConnection(result);
}
else
{
includedTags = false;
}
if (tagopt == TagOpt.AUTO_FOLLOW && !additionalTags.IsEmpty())
{
// There are more tags that we want to follow, but
// not all were asked for on the initial request.
//
Sharpen.Collections.AddAll(have, askFor.Keys);
askFor.Clear();
foreach (Ref r in additionalTags)
{
ObjectId id = r.GetPeeledObjectId();
if (id == null)
{
id = r.GetObjectId();
}
if (transport.local.HasObject(id))
{
WantTag(r);
}
}
if (!askFor.IsEmpty() && (!includedTags || !AskForIsComplete()))
{
ReopenConnection();
if (!askFor.IsEmpty())
{
FetchObjects(monitor);
}
}
}
}
finally
{
CloseConnection(result);
}
BatchRefUpdate batch = transport.local.RefDatabase.NewBatchUpdate().SetAllowNonFastForwards
(true).SetRefLogMessage("fetch", true);
RevWalk walk = new RevWalk(transport.local);
try
{
if (monitor is BatchingProgressMonitor)
{
((BatchingProgressMonitor)monitor).SetDelayStart(250, TimeUnit.MILLISECONDS);
}
if (transport.IsRemoveDeletedRefs())
{
DeleteStaleTrackingRefs(result, batch);
}
foreach (TrackingRefUpdate u in localUpdates)
{
result.Add(u);
batch.AddCommand(u.AsReceiveCommand());
}
foreach (ReceiveCommand cmd in batch.GetCommands())
{
cmd.UpdateType(walk);
if (cmd.GetType() == ReceiveCommand.Type.UPDATE_NONFASTFORWARD && cmd is TrackingRefUpdate.Command &&
!((TrackingRefUpdate.Command)cmd).CanForceUpdate())
{
cmd.SetResult(ReceiveCommand.Result.REJECTED_NONFASTFORWARD);
}
}
if (transport.IsDryRun())
{
foreach (ReceiveCommand cmd_1 in batch.GetCommands())
{
if (cmd_1.GetResult() == ReceiveCommand.Result.NOT_ATTEMPTED)
{
cmd_1.SetResult(ReceiveCommand.Result.OK);
}
}
}
else
{
batch.Execute(walk, monitor);
}
}
catch (IOException err)
{
throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingTrackingRef
, GetFirstFailedRefName(batch), err.Message), err);
}
finally
{
walk.Release();
}
if (!fetchHeadUpdates.IsEmpty())
{
try
{
UpdateFETCH_HEAD(result);
}
catch (IOException err)
{
throw new TransportException(MessageFormat.Format(JGitText.Get().failureUpdatingFETCH_HEAD
, err.Message), err);
}
}
}
private void ResolveDeltas(ProgressMonitor progress)
{
progress.BeginTask(PROGRESS_RESOLVE_DELTA, _deltaCount);
int last = _entryCount;
for (int i = 0; i < last; i++)
{
int before = _entryCount;
ResolveDeltas(_entries[i]);
progress.Update(_entryCount - before);
if (progress.IsCancelled)
{
throw new IOException("Download cancelled during indexing");
}
}
progress.EndTask();
}
internal protected virtual void OnReadProjectHeader(ProgressMonitor monitor, MSBuildProject msproject)
{
next.OnReadProjectHeader(monitor, msproject);
}
/// <summary> /// Implementation of <see cref="Fetch"/> /// without checking for multiple fetch. /// </summary> /// <param name="monitor">as in <see cref="Fetch"/></param> /// <param name="want">as in <see cref="Fetch"/></param> /// <param name="have">as in <see cref="Fetch"/></param> protected abstract void doFetch(ProgressMonitor monitor, ICollection<Ref> want, IList<ObjectId> have);
internal protected virtual void OnReadProject(ProgressMonitor monitor, MSBuildProject msproject)
{
next.OnReadProject(monitor, msproject);
msproject.EvaluatedProperties.ReadObjectProperties(this, GetType(), true);
msproject.ReadExternalProjectProperties(this, GetType(), true);
}
public BundleWriter(Repository repo, ProgressMonitor monitor)
{
packWriter = new PackWriter(repo, monitor);
includeObjects = new Dictionary<string, ObjectId>();
assumeCommits = new List<RevCommit>();
}
internal protected virtual void OnWriteProject(ProgressMonitor monitor, MSBuildProject msproject)
{
next.OnWriteProject(monitor, msproject);
msproject.GetGlobalPropertyGroup().WriteObjectProperties(this, GetType(), true);
msproject.WriteExternalProjectProperties(this, GetType(), true);
}
private void DownloadObject(ProgressMonitor pm, AnyObjectId id)
{
if (_local.HasObject(id)) return;
while (true)
{
if (DownloadPackedObject(pm, id))
return;
string idStr = id.Name;
string subdir = idStr.Slice(0, 2);
string file = idStr.Substring(2);
string looseName = subdir + "/" + file;
for (int i = _lastRemoteIdx; i < _remotes.Count; i++)
{
if (DownloadLooseObject(id, looseName, _remotes[i]))
{
_lastRemoteIdx = i;
return;
}
}
for (int i = 0; i < _lastRemoteIdx; i++)
{
if (DownloadLooseObject(id, looseName, _remotes[i]))
{
_lastRemoteIdx = i;
return;
}
}
while (_noPacksYet.Count > 0)
{
WalkRemoteObjectDatabase wrr = _noPacksYet.First.Value;
_noPacksYet.RemoveFirst();
List<string> packNameList;
try
{
pm.BeginTask("Listing packs", ProgressMonitor.UNKNOWN);
packNameList = wrr.getPackNames();
}
catch (IOException e)
{
RecordError(id, e);
continue;
}
finally
{
pm.EndTask();
}
if (packNameList == null || packNameList.Count == 0)
continue;
foreach (string packName in packNameList)
{
if (!_packsConsidered.Contains(packName))
{
_packsConsidered.Add(packName);
_unfetchedPacks.AddLast(new RemotePack(_lockMessage, _packLocks, _objCheck, _local, wrr, packName));
}
}
if (DownloadPackedObject(pm, id))
return;
}
List<WalkRemoteObjectDatabase> al = ExpandOneAlternate(id, pm);
if (al != null && al.Count > 0)
{
foreach (WalkRemoteObjectDatabase alt in al)
{
_remotes.Add(alt);
_noPacksYet.AddLast(alt);
_noAlternatesYet.AddLast(alt);
}
continue;
}
List<Exception> failures = null;
if (_fetchErrors.ContainsKey(id.Copy()))
{
failures = _fetchErrors[id.Copy()];
}
TransportException te = null;
if (failures != null && failures.Count > 0)
{
te = failures.Count == 1 ?
new TransportException("Cannot get " + id.Name + ".", failures[0]) :
new TransportException("Cannot get " + id.Name + ".", new CompoundException(failures));
}
if (te == null)
{
te = new TransportException("Cannot get " + id.Name + ".");
}
throw te;
}
}
internal protected virtual void OnWriteConfiguration(ProgressMonitor monitor, ProjectConfiguration config, IPropertySet pset)
{
next.OnWriteConfiguration(monitor, config, pset);
}
private List<WalkRemoteObjectDatabase> ExpandOneAlternate(AnyObjectId id, ProgressMonitor pm)
{
while (_noAlternatesYet.Count > 0)
{
WalkRemoteObjectDatabase wrr = _noAlternatesYet.First.Value;
_noAlternatesYet.RemoveFirst();
try
{
pm.BeginTask("Listing alternates", ProgressMonitor.UNKNOWN);
List<WalkRemoteObjectDatabase> altList = wrr.getAlternates();
if (altList != null && altList.Count > 0)
return altList;
}
catch (IOException e)
{
RecordError(id, e);
}
finally
{
pm.EndTask();
}
}
return null;
}
internal protected virtual Task OnReevaluateProject(ProgressMonitor monitor)
{
return(next.OnReevaluateProject(monitor));
}
public void OpenIndex(ProgressMonitor pm)
{
if (Index != null) return;
try
{
Index = PackIndex.Open(TmpIdx);
return;
}
catch (FileNotFoundException)
{
}
Stream s = _connection.open("pack/" + _idxName);
pm.BeginTask("Get " + _idxName.Slice(0, 12) + "..idx", s.Length < 0 ? -1 : (int)(s.Length / 1024));
try
{
var fos = new FileStream(TmpIdx.ToString(), System.IO.FileMode.Open, FileAccess.ReadWrite);
try
{
var buf = new byte[2048];
int cnt;
while (!pm.IsCancelled && (cnt = s.Read(buf, 0, buf.Length)) >= 0)
{
fos.Write(buf, 0, cnt);
pm.Update(cnt / 1024);
}
}
finally
{
fos.Close();
}
}
catch (IOException)
{
TmpIdx.Delete();
throw;
}
finally
{
s.Close();
}
pm.EndTask();
if (pm.IsCancelled)
{
TmpIdx.Delete();
return;
}
try
{
Index = PackIndex.Open(TmpIdx);
}
catch (IOException)
{
TmpIdx.Delete();
throw;
}
}
internal protected virtual Task <ProjectFile []> OnGetSourceFiles(ProgressMonitor monitor, ConfigurationSelector configuration)
{
return(next.OnGetSourceFiles(monitor, configuration));
}
private void writePack(IDictionary<string, RemoteRefUpdate> refUpdates, ProgressMonitor monitor)
{
PackWriter writer = new PackWriter(local, monitor);
List<ObjectId> remoteObjects = new List<ObjectId>(Refs.Count);
List<ObjectId> newObjects = new List<ObjectId>(refUpdates.Count);
foreach (Ref r in Refs)
remoteObjects.Add(r.ObjectId);
remoteObjects.AddRange(additionalHaves);
foreach (RemoteRefUpdate r in refUpdates.Values)
{
if (!ObjectId.ZeroId.Equals(r.NewObjectId))
newObjects.Add(r.NewObjectId);
}
writer.Thin = _thinPack;
writer.DeltaBaseAsOffset = _capableOfsDelta;
writer.preparePack(newObjects, remoteObjects);
writer.writePack(stream);
}
internal protected virtual void OnWriteRunConfiguration(ProgressMonitor monitor, ProjectRunConfiguration config, IPropertySet properties)
{
next.OnWriteRunConfiguration(monitor, config, properties);
}
public FilteredProgressMonitor (ProgressMonitor targetMonitor, MonitorAction actionMask)
{
AddSlaveMonitor (targetMonitor, actionMask);
}
public FigmaAggregatedProgressMonitor(ProgressMonitor monitor, string successMessage)
: base(monitor)
{
this.successMessage = successMessage;
ExtensionLoggingService.AddProgressMonitor(this);
}
public FetchResult fetch(ProgressMonitor monitor, List<RefSpec> toFetch)
{
if (toFetch == null || toFetch.Count == 0)
{
if (_fetchSpecs.Count == 0)
{
throw new TransportException("Nothing to fetch.");
}
toFetch = _fetchSpecs;
}
else if (_fetchSpecs.Count != 0)
{
var tmp = new List<RefSpec>(toFetch);
foreach (RefSpec requested in toFetch)
{
string reqSrc = requested.Source;
foreach (RefSpec configured in _fetchSpecs)
{
string cfgSrc = configured.Source;
string cfgDst = configured.Destination;
if (cfgSrc.Equals(reqSrc) && cfgDst != null)
{
tmp.Add(configured);
break;
}
}
}
toFetch = tmp;
}
var result = new FetchResult();
new FetchProcess(this, toFetch).execute(monitor, result);
return result;
}
public Task SaveAsync(FilePath fileName, ProgressMonitor monitor)
{
AssertMainThread();
FileName = fileName;
return(SaveAsync(monitor));
}
protected override void doFetch(ProgressMonitor monitor, List<Ref> want, List<ObjectId> have)
{
verifyPrerequisites();
try
{
IndexPack ip = newIndexPack();
ip.index(monitor);
packLock = ip.renameAndOpenPack(lockMessage);
}
catch (IOException err)
{
Close();
throw new TransportException(transport.Uri, err.Message, err);
}
}
protected internal virtual Task OnSave(ProgressMonitor monitor)
{
return(Task.FromResult(0));
}
protected void doPush(ProgressMonitor monitor, IDictionary<string, RemoteRefUpdate> refUpdates)
{
try
{
WriteCommands(refUpdates.Values, monitor);
if (_shouldWritePack)
writePack(refUpdates, monitor);
if (_sentCommand && _capableReport)
readStatusReport(refUpdates);
}
catch (TransportException)
{
throw;
}
catch (Exception e)
{
throw new TransportException(uri, e.Message, e);
}
finally
{
Dispose();
}
}
internal protected override Task Save(ProgressMonitor monitor)
{
return(Item.OnSave(monitor));
}
private void writePack(IDictionary<string, RemoteRefUpdate> refUpdates, ProgressMonitor monitor)
{
PackWriter writer = new PackWriter(local, monitor);
List<ObjectId> remoteObjects = new List<ObjectId>(Refs.Count);
List<ObjectId> newObjects = new List<ObjectId>(refUpdates.Count);
foreach (Ref r in Refs)
remoteObjects.Add(r.ObjectId);
remoteObjects.AddRange(additionalHaves);
foreach (RemoteRefUpdate r in refUpdates.Values)
{
if (!ObjectId.ZeroId.Equals(r.NewObjectId))
newObjects.Add(r.NewObjectId);
}
writer.Thin = _thinPack;
writer.DeltaBaseAsOffset = _capableOfsDelta;
writer.preparePack(newObjects, remoteObjects);
long start = SystemReader.getInstance().getCurrentTime();
writer.writePack(outStream);
packTransferTime = SystemReader.getInstance().getCurrentTime() - start;
}
protected override bool OnBuild(ProgressMonitor monitor, DeployContext ctx)
{
string tmpFolder = null;
try {
SolutionConfigurationSelector conf = (SolutionConfigurationSelector)configuration;
var bt = RootSolutionItem as IBuildTarget;
if (bt != null)
{
BuildResult res = bt.Build(monitor, conf).Result;
if (res.ErrorCount > 0)
{
foreach (BuildError e in res.Errors)
{
monitor.ReportError(e.ToString(), null);
}
monitor.ReportError(GettextCatalog.GetString("The source project failed to build."), null);
return(false);
}
}
tmpFolder = FileService.CreateTempDirectory();
string tf = Path.GetFileNameWithoutExtension(targetFile);
if (tf.EndsWith(".tar"))
{
tf = Path.GetFileNameWithoutExtension(tf);
}
string folder = FileService.GetFullPath(Path.Combine(tmpFolder, tf));
// Export the binary files
DeployFileCollection deployFiles = GetDeployFiles(ctx, conf);
foreach (DeployFile file in deployFiles)
{
string tfile = Path.Combine(folder, file.ResolvedTargetFile);
string tdir = FileService.GetFullPath(Path.GetDirectoryName(tfile));
if (!Directory.Exists(tdir))
{
Directory.CreateDirectory(tdir);
}
File.Copy(file.SourcePath, tfile, true);
}
// Create the archive
string td = Path.GetDirectoryName(targetFile);
if (!Directory.Exists(td))
{
Directory.CreateDirectory(td);
}
DeployService.CreateArchive(monitor, tmpFolder, targetFile);
}
catch (Exception ex) {
monitor.ReportError("Package creation failed", ex);
LoggingService.LogError("Package creation failed", ex);
return(false);
}
finally {
if (tmpFolder != null)
{
Directory.Delete(tmpFolder, true);
}
}
monitor.Log.WriteLine(GettextCatalog.GetString("Created file: {0}", targetFile));
return(true);
}