private void Catalog_PackageInstalling(PackageCatalog sender, PackageInstallingEventArgs args)
{
var ignored = CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
String eventDetails =
args.Package.Id.FullName + ","
+ args.IsComplete + ","
+ args.Progress + ","
+ args.ErrorCode + ";"
+ Environment.NewLine;
Debug.WriteLine(eventDetails);
var frame = (Frame)Window.Current.Content;
Type currentPageType = frame.SourcePageType;
if (currentPageType.Equals(typeof(MainPage)))
{
var page = (MainPage)frame.Content;
if (Package.Current.Id.FullName.Equals(args.Package.Id.FullName))
{
localSettings.Values["OverallProgress"] = args.Progress;
page.Set_Overall_ProgressBar_Value(args.Progress);
}
}
else
{
if (Package.Current.Id.FullName.Equals(args.Package.Id.FullName))
{
localSettings.Values["OverallProgress"] = args.Progress;
}
}
});
}
private async void DownloadItemPackClick(object sender, RoutedEventArgs e)
{
String lang = ((Button)sender).DataContext as String;
string resourceId = "split.language-" + lang.Substring(0, 2).ToLower();
AvailableLanguages languageSel = (AvailableLanguages)Enum.Parse(typeof(AvailableLanguages), lang.Replace('-', '_'));
var packageCatalog = PackageCatalog.OpenForCurrentPackage();
var result = await packageCatalog.AddResourcePackageAsync("29270depappf.CaffeMacchiato_gah1vdar1nn7a", resourceId, AddResourcePackageOptions.ApplyUpdateIfAvailable | AddResourcePackageOptions.ForceTargetApplicationShutdown).AsTask <PackageCatalogAddResourcePackageResult, PackageInstallProgress>(new Progress <PackageInstallProgress>
(progress =>
{
DownloadButtonList[(int)languageSel].Visibility = Visibility.Collapsed;
ProgressBarList[(int)languageSel].Visibility = Visibility.Visible;
CancelButtonList[(int)languageSel].Visibility = Visibility.Visible;
ProgressBarList[(int)languageSel].Value = progress.PercentComplete;
}));
if (result.ExtendedError != null)
{
await new MessageDialog(result.ExtendedError.ToString()).ShowAsync();
DownloadButtonList[(int)languageSel].Visibility = Visibility.Visible;
ProgressBarList[(int)languageSel].Visibility = Visibility.Collapsed;
CancelButtonList[(int)languageSel].Visibility = Visibility.Collapsed;
}
else if (result.IsComplete)
{
ProgressBarList[(int)languageSel].Visibility = Visibility.Collapsed;
RemoveButtonList[(int)languageSel].Visibility = Visibility.Visible;
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
navigationHelper.OnNavigatedTo(e);
try
{
packageCatalog = PackageCatalog.OpenForCurrentPackage();
packageCatalog.PackageInstalling += Catalog_PackageInstalling;
packageCatalog.PackageStaging += Catalog_PackageStaging;
packageCatalog.PackageStatusChanged += Catalog_PackageStatusChanged;
}
catch (Exception ex)
{
await new MessageDialog("Unable to setup deployment event handlers. {" + ex.InnerException + "}").ShowAsync();
}
dispatcher = CoreWindow.GetForCurrentThread().Dispatcher;
optionalPackagesList = new ObservableCollection <Controls.OptionalPackageControl>();
OptionalPackagesListView.ItemsSource = optionalPackagesList;
storeOptionalPackagesList = new ObservableCollection <StoreProductControl>();
StoreOptionalPackagesListView.ItemsSource = storeOptionalPackagesList;
deployingOptionalPackagesList = new Dictionary <string, PackageDeploymentControl>();
deployingOptionalPackagesListUI = new ObservableCollection <PackageDeploymentControl>();
DeployingOptionalPackagesListView.ItemsSource = deployingOptionalPackagesListUI;
context = StoreContext.GetDefault();
LoadInstalledOptionalPackages();
}
public void OnPackageInstalling(PackageCatalog p, PackageInstallingEventArgs args)
{
if (args.IsComplete)
{
try
{
var packageWrapper = PackageWrapper.GetWrapperFromPackage(args.Package);
if (!string.IsNullOrEmpty(packageWrapper.InstalledLocation))
{
var uwp = new UWP(packageWrapper);
uwp.InitializeAppInfo(packageWrapper.InstalledLocation);
foreach (var app in uwp.Apps)
{
Add(app);
}
}
}
// InitializeAppInfo will throw if there is no AppxManifest.xml for the package.
// Note there are sometimes multiple packages per product and this doesn't necessarily mean that we haven't found the app.
// eg. "Could not find file 'C:\\Program Files\\WindowsApps\\Microsoft.WindowsTerminalPreview_2020.616.45.0_neutral_~_8wekyb3d8bbwe\\AppxManifest.xml'."
catch (System.IO.FileNotFoundException e)
{
ProgramLogger.Exception(e.Message, e, GetType(), args.Package.InstalledLocation.ToString());
}
}
}
void HookupCatalog()
{
catalog = PackageCatalog.OpenForCurrentPackage();
catalog.PackageContentGroupStaging += Catalog_PackageContentGroupStaging;
catalog.PackageStaging += Catalog_PackageStaging;
catalog.PackageInstalling += Catalog_PackageInstalling;
}
/// <summary>
/// Searches for packages based on the configured parameters.
/// </summary>
/// <param name="behavior">The <see cref="CompositeSearchBehavior" /> value.</param>
/// <param name="limit">The limit on the number of matches returned.</param>
/// <returns>A list of <see cref="MatchResult" /> objects.</returns>
protected IReadOnlyList <MatchResult> FindPackages(
CompositeSearchBehavior behavior,
uint limit)
{
PackageCatalog catalog = this.GetPackageCatalog(behavior);
FindPackagesOptions options = this.GetFindPackagesOptions(limit);
return(GetMatchResults(catalog, options));
}
void HookupCatalog()
{
catalog = PackageCatalog.OpenForCurrentPackage();
//catalog = PackageCatalog.OpenForCurrentUser();
catalog.PackageContentGroupStaging += Catalog_PackageContentGroupStaging;
this.PackageEvents_checkBox.IsChecked = true;
GetContentIntegrityStatus();
}
private async Task Commit(AppendOnlyCatalogWriter writer, CantonCatalogItem[] batchItems)
{
var orderedBatch = batchItems.ToList();
orderedBatch.Sort(CantonCatalogItem.Compare);
int lastHighestCommit = 0;
DateTime?latestPublished = null;
// add the items to the writer
foreach (var orderedItem in orderedBatch)
{
lastHighestCommit = orderedItem.CantonCommitId + 1;
writer.Add(orderedItem);
}
Task cursorTask = null;
// only save the cursor if we did something
if (lastHighestCommit > 0)
{
// find the most recent package
latestPublished = batchItems.Select(c => c.Published).OrderByDescending(d => d).FirstOrDefault();
// update the cursor
JObject obj = new JObject();
// add one here since we are already added the current number
obj.Add("cantonCommitId", lastHighestCommit);
Log("Cursor cantonCommitId: " + lastHighestCommit);
Cursor.Position = DateTime.UtcNow;
Cursor.Metadata = obj;
cursorTask = Cursor.Save();
}
if (writer.Count > 0)
{
// perform the commit
Stopwatch timer = new Stopwatch();
timer.Start();
IGraph commitData = PackageCatalog.CreateCommitMetadata(writer.RootUri, latestPublished, latestPublished);
// commit
await writer.Commit(DateTime.UtcNow, commitData);
timer.Stop();
Console.WriteLine("Commit duration: " + timer.Elapsed);
}
if (cursorTask != null)
{
await cursorTask;
}
}
private void HookupCatalog()
{
try
{
packageCatalog = PackageCatalog.OpenForCurrentPackage();
packageCatalog.PackageInstalling += Catalog_PackageInstalling;
}
catch (Exception ex)
{
PopupUI("Unable to setup deployment event handlers. {" + ex.InnerException + "}");
}
}
public void OnPackageUninstalling(PackageCatalog p, PackageUninstallingEventArgs args)
{
if (args.Progress == 0)
{
//find apps associated with this package.
var uwp = new UWP(args.Package);
var apps = Items.Where(a => a.Package.Equals(uwp)).ToArray();
foreach (var app in apps)
{
Remove(app);
}
}
}
async Task AddStreamedPictureSourcesAsync()
{
// Handle any streamed packages that are already installed.
var groups = await Package.Current.GetContentGroupsAsync();
foreach (var group in groups.Where(
g => !g.IsRequired && g.State == PackageContentGroupState.Staged))
{
await this.AddPictureSourceAsync(group.Name, group.Name);
}
// Now set up handlers to wait for any others to arrive
this.catalog = PackageCatalog.OpenForCurrentPackage();
this.catalog.PackageInstalling += OnPackageInstalling;
}
async void OnContentGroupStaging(
PackageCatalog sender, PackageContentGroupStagingEventArgs args)
{
if (args.IsComplete)
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() =>
{
await this.AddPictureSourceAsync(
args.ContentGroupName,
args.ContentGroupName);
}
);
}
}
private static IReadOnlyList <MatchResult> GetMatchResults(
PackageCatalog catalog,
FindPackagesOptions options)
{
FindPackagesResult result = catalog.FindPackages(options);
if (result.Status == FindPackagesResultStatus.Ok)
{
return(result.Matches);
}
else
{
throw new FindPackagesException(result.Status);
}
}
async void OnPackageInstalling(
PackageCatalog sender,
PackageInstallingEventArgs args)
{
if (args.IsComplete)
{
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() =>
{
await this.AddPictureSourceAsync(args.Package.Id.FullName,
args.Package.Id.FullName);
}
);
}
}
public InteractiveTextBox()
: base()
{
try
{
var catalog = new PackageCatalog();
catalog.AddPackage(Package.Current);
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
}
catch (Exception exc)
{
throw new Exception("The application is missing an IDefineCommand and/or IPerformCommand component. Make sure the application refers to projects that implement these. ", exc);
}
}
async Task AddStreamedPictureSourcesAsync()
{
// Handle any streamed packages that are already installed.
var groups = await Package.Current.GetContentGroupsAsync();
// TBD - unsure exactly of the state to check for here in order
// to be sure that the content group is present.
foreach (var group in groups.Where(
g => !g.IsRequired && g.State == PackageContentGroupState.Staged))
{
await this.AddPictureSourceAsync(group.Name, group.Name);
}
// Now set up handlers to wait for any others to arrive
this.catalog = PackageCatalog.OpenForCurrentPackage();
this.catalog.PackageContentGroupStaging += OnContentGroupStaging;
}
private void Catalog_PackageStaging(PackageCatalog sender, PackageStagingEventArgs args)
{
var ignored = CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
if (Package.Current.Id.FullName.Equals(args.Package.Id.FullName))
{
this.Overall_ProgressBar.Value = args.Progress;
}
String eventDetails =
args.Package.Id.FullName + ","
+ args.IsComplete + ","
+ args.Progress + ","
+ args.ErrorCode + ";"
+ Environment.NewLine;
this.PackageStagingInstallingEvents_textBox.Text = eventDetails;
});
}
private async void Catalog_PackageInstalling(PackageCatalog sender, PackageInstallingEventArgs args)
{
if (args.Progress == 100 && args.IsComplete && args.Package.IsOptional && args.Package.Id.FamilyName.Contains("Approvals"))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
OpTitle.Visibility = Visibility.Visible;
ToApprovals.Visibility = Visibility.Visible;
});
}
else if ((args.Progress == 100 && args.IsComplete && args.Package.IsOptional && args.Package.Id.FamilyName.Contains("Employees")))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
OpTitle.Visibility = Visibility.Visible;
ToEmployees.Visibility = Visibility.Visible;
});
}
}
private async void Catalog_PackageInstalling(PackageCatalog sender, PackageInstallingEventArgs args)
{
if (args.Progress == 100 && args.IsComplete &&
args.Package.IsOptional && args.Package.Id.FamilyName.Contains("FabrikamFaceFilters"))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
FilterStackPanel.Visibility = Visibility.Visible;
});
}
else if ((args.Progress == 100 && args.IsComplete &&
args.Package.IsOptional && args.Package.Id.FamilyName.Contains("FabrikamAgeAnalysis")))
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
UtilityStackPanel.Visibility = Visibility.Visible;
});
}
}
private async Task <DateTime> Deletes2Catalog(
SortedList <DateTime, IList <FeedPackageIdentity> > packages,
IStorage storage,
DateTime lastCreated,
DateTime lastEdited,
DateTime lastDeleted,
CancellationToken cancellationToken)
{
var writer = new AppendOnlyCatalogWriter(
storage,
TelemetryService,
Constants.MaxPageSize);
if (packages == null || packages.Count == 0)
{
return(lastDeleted);
}
foreach (var entry in packages)
{
foreach (var packageIdentity in entry.Value)
{
var catalogItem = new DeleteCatalogItem(packageIdentity.Id, packageIdentity.Version, entry.Key);
writer.Add(catalogItem);
Logger.LogInformation("Delete: {PackageId} {PackageVersion}", packageIdentity.Id, packageIdentity.Version);
}
lastDeleted = entry.Key;
}
var commitMetadata = PackageCatalog.CreateCommitMetadata(writer.RootUri, new CommitMetadata(lastCreated, lastEdited, lastDeleted));
await writer.Commit(commitMetadata, cancellationToken);
Logger.LogInformation("COMMIT package deletes to catalog.");
return(lastDeleted);
}
private async void RemoveItemPackClick(object sender, RoutedEventArgs e)
{
String lang = ((Button)sender).DataContext as String;
var packageCatalog = PackageCatalog.OpenForCurrentPackage();
Package package = Package.Current;
List <Windows.ApplicationModel.Package> resourcePackagesToRemove = new List <Windows.ApplicationModel.Package>();
foreach (Package p in package.Dependencies)
{
if (p.IsResourcePackage)
{
//the resource package name only contains the language code for example ar-sa is 29270depappf.UWPCoffeeApplication_1.2.0.0_neutral_split.language-ar_gah1vdar1nn7a
if (p.Id.ResourceId.ToLower().Contains(lang.ToLower().Substring(0, 2)))
{
resourcePackagesToRemove.Add(p);
break;
}
}
}
if (resourcePackagesToRemove.Count < 1)
{
await new MessageDialog("Did not find a resource package that matches " + lang).ShowAsync();
}
else
{
await new MessageDialog("Going to remove " + resourcePackagesToRemove[0].Id.FullName + " resource package. App will need to restart").ShowAsync();
var removePackageResult = await packageCatalog.RemoveResourcePackagesAsync(resourcePackagesToRemove);
if (removePackageResult != null)
{
await new MessageDialog("RemoveResourcePackagesAsync failed with error " + removePackageResult.ExtendedError).ShowAsync();
}
}
}
public void OnPackageInstalling(PackageCatalog p, PackageInstallingEventArgs args)
{
if (args.IsComplete)
{
try
{
var uwp = new UWP(args.Package);
uwp.InitializeAppInfo(args.Package.InstalledLocation.Path);
foreach (var app in uwp.Apps)
{
Add(app);
}
}
//InitializeAppInfo will throw if there is no AppxManifest.xml for the package.
//Note there are sometimes multiple packages per product and this doesn't necessarily mean that we haven't found the app.
//eg. "Could not find file 'C:\\Program Files\\WindowsApps\\Microsoft.WindowsTerminalPreview_2020.616.45.0_neutral_~_8wekyb3d8bbwe\\AppxManifest.xml'."
catch (System.IO.FileNotFoundException e)
{
ProgramLogger.LogException($"|UWP|OnPackageInstalling|{args.Package.InstalledLocation}|{e.Message}", e);
}
}
}
public void Load()
{
// Arrange
Uri catalog = new Uri("http://foo");
Uri baseAddress = new Uri("http://storage");
MemoryStorage storage = new MemoryStorage(baseAddress);
Uri fileAddress = new Uri("http://storage/packagecatalog.json");
storage.Content.Add(fileAddress, new StringStorageContent(inputJson));
// Act
PackageCatalog packageCatalog = new PackageCatalog(catalog, storage, fileAddress, null);
packageCatalog.LoadAsync(fileAddress, storage, new CancellationToken()).Wait();
// Assert
PackageInfo package = packageCatalog.Packages["51Degrees.mobi"];
Assert.Equal(3, packageCatalog.Packages.Count);
Assert.Equal("51Degrees.mobi", package.PackageId);
Assert.Equal("3.2.5.6", package.LatestStableVersion);
Assert.Equal(false, package.HaveIdx);
Assert.Equal(new Guid("788b39a0-9a58-4000-88be-599a0ad2a8a9"), package.CommitId);
Assert.Equal(DateTime.Parse("2015-12-07T14:36:57.142124Z").ToUniversalTime(), package.CommitTimeStamp);
Assert.Equal(new Uri("https://api.nuget.org/packages/51degrees.mobi.3.2.5.6.nupkg"), package.DownloadUrl);
}
private void Catalog_PackageInstalling(PackageCatalog sender, PackageInstallingEventArgs args)
{
if (args.Progress < 100)
{
LoadDeployingPackageToUI(args.Package, args.Progress);
}
else if (args.Progress == 100 && args.IsComplete)
{
RemoveDeployingPackageFromUI(args.Package);
bool isPresent = false;
foreach (var control in optionalPackagesList)
{
if (control.Package.Id.FullName.CompareTo(args.Package.Id.FullName) == 0)
{
isPresent = true;
}
}
if (!isPresent)
{
LoadPackageToUI(args.Package);
}
}
}
public void Delist()
{
// Arrange
Uri catalog = new Uri("http://foo");
Uri baseAddress = new Uri("http://storage");
MemoryStorage storage = new MemoryStorage(baseAddress);
Uri fileAddress = new Uri("http://storage/packagecatalog.json");
storage.Content.Add(fileAddress, new StringStorageContent(inputJson));
// Act
PackageCatalog packageCatalog = new PackageCatalog(catalog, storage, fileAddress, null);
packageCatalog.LoadAsync(fileAddress, storage, new CancellationToken()).Wait();
packageCatalog.DelistPackage("51Degrees.mobi");
// Assert
Assert.Equal(2, packageCatalog.Packages.Count);
Action action = delegate
{
Assert.Null(packageCatalog.Packages["51Degrees.mobi"]);
};
Assert.Throws(typeof(KeyNotFoundException), action);
}
private void Catalog_PackageContentGroupStaging(PackageCatalog sender, PackageContentGroupStagingEventArgs args)
{
var ignored = CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
String CGStagingEvent =
args.Package.Id.FullName + ","
+ args.ContentGroupName + ","
+ args.IsComplete + ","
+ args.Progress + ","
+ args.ErrorCode + ";"
+ Environment.NewLine;
Debug.WriteLine(CGStagingEvent);
if (Package.Current.Id.FullName.Equals(args.Package.Id.FullName))
{
localSettings.Values[args.ContentGroupName] = args.Progress;
}
else
{
String resourcePackageFullName = "";
foreach (var package in Package.Current.Dependencies)
{
if (package.Id.FullName.Contains("language-fr") && package.IsResourcePackage)
{
resourcePackageFullName = package.Id.FullName;
break;
}
}
if (args.Package.Id.FullName.Equals(resourcePackageFullName))
{
localSettings.Values[args.ContentGroupName] = args.Progress;
}
}
var frame = (Frame)Window.Current.Content;
Type currentPageType = frame.SourcePageType;
if (currentPageType.Equals(typeof(ContentGroupPage)))
{
var page = (ContentGroupPage)frame.Content;
if (Package.Current.Id.FullName.Equals(args.Package.Id.FullName))
{
page.Set_CG_Status(args);
}
}
else if (currentPageType.Equals(typeof(LanguagesPage)))
{
var page = (LanguagesPage)frame.Content;
if (!Package.Current.Id.FullName.Equals(args.Package.Id.FullName))
{
String resourcePackageFullName = "";
foreach (var package in Package.Current.Dependencies)
{
if (package.Id.FullName.Contains("language-fr") && package.IsResourcePackage)
{
resourcePackageFullName = package.Id.FullName;
break;
}
}
if (args.Package.Id.FullName.Equals(resourcePackageFullName))
{
page.Set_CG_Status(args);
}
}
}
});
}
static async Task <DateTime> DownloadMetadata2Catalog(HttpClient client, SortedList <DateTime, IList <Tuple <Uri, PackageDates> > > packages, Storage storage, DateTime lastCreated, DateTime lastEdited, bool?createdPackages = null)
{
AppendOnlyCatalogWriter writer = new AppendOnlyCatalogWriter(storage, 550);
DateTime lastDate = createdPackages.HasValue ? (createdPackages.Value ? lastCreated : lastEdited) : DateTime.MinValue;
if (packages == null || packages.Count == 0)
{
return(lastDate);
}
foreach (KeyValuePair <DateTime, IList <Tuple <Uri, PackageDates> > > entry in packages)
{
foreach (Tuple <Uri, PackageDates> packageItem in entry.Value)
{
Uri uri = packageItem.Item1;
PackageDates pDates = packageItem.Item2;
HttpResponseMessage response = await client.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
using (Stream stream = await response.Content.ReadAsStreamAsync())
{
CatalogItem item = Utils.CreateCatalogItem(stream, entry.Key, null, uri.ToString(), pDates.packageCreatedDate, pDates.packageLastEditedDate, pDates.packagePublishedDate);
if (item != null)
{
writer.Add(item);
Trace.TraceInformation("Add: {0}", uri);
}
else
{
Trace.TraceWarning("Unable to extract metadata from: {0}", uri);
}
}
}
else
{
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
// the feed is out of sync with the actual package storage - if we don't have the package there is nothing to be done we might as well move onto the next package
Trace.TraceWarning(string.Format("Unable to download: {0} http status: {1}", uri, response.StatusCode));
}
else
{
// this should trigger a restart - of this program - and not more the cursor forward
Trace.TraceError(string.Format("Unable to download: {0} http status: {1}", uri, response.StatusCode));
throw new Exception(string.Format("Unable to download: {0} http status: {1}", uri, response.StatusCode));
}
}
}
lastDate = entry.Key;
}
if (createdPackages.HasValue)
{
lastCreated = createdPackages.Value ? lastDate : lastCreated;
lastEdited = !createdPackages.Value ? lastDate : lastEdited;
}
IGraph commitMetadata = PackageCatalog.CreateCommitMetadata(writer.RootUri, lastCreated, lastEdited);
await writer.Commit(commitMetadata);
Trace.TraceInformation("COMMIT");
return(lastDate);
}
public static async Task Test3Async()
{
System.Net.ServicePointManager.DefaultConnectionLimit = 1024;
IDictionary <string, string> packageHashLookup = LoadPackageHashLookup();
HashSet <string> packageExceptionLookup = LoadPackageExceptionLookup();
string nupkgs = @"c:\data\nuget\gallery\";
Storage storage = new FileStorage("http://*****:*****@"c:\data\site\ordered");
//StorageCredentials credentials = new StorageCredentials("", "");
//CloudStorageAccount account = new CloudStorageAccount(credentials, true);
//string storageContainer = "test1";
//string storagePath = "";
//string storageBaseAddress = "http://nugetjohtaylo.blob.core.windows.net/test1";
//StorageFactory storageFactory = new AzureStorageFactory(account, storageContainer, storagePath, new Uri(storageBaseAddress)) { Verbose = true };
//Storage storage = storageFactory.Create();
AppendOnlyCatalogWriter writer = new AppendOnlyCatalogWriter(storage, 550);
const int BatchSize = 64;
int commitCount = 0;
IDictionary <string, DateTime> packageCreated = LoadPackageCreatedLookup();
DateTime lastCreated = (await PackageCatalog.ReadCommitMetadata(writer)).Item1 ?? DateTime.MinValue;
ParallelOptions options = new ParallelOptions();
options.MaxDegreeOfParallelism = 8;
// filter by lastCreated here
Queue <KeyValuePair <string, DateTime> > packageCreatedQueue = new Queue <KeyValuePair <string, DateTime> >(packageCreated.Where(p => p.Value > lastCreated && !packageExceptionLookup.Contains(p.Key)).OrderBy(p => p.Value));
int completed = 0;
Stopwatch runtime = new Stopwatch();
runtime.Start();
Task commitTask = null;
var context = writer.Context;
Uri rootUri = writer.RootUri;
while (packageCreatedQueue.Count > 0)
{
List <KeyValuePair <string, DateTime> > batch = new List <KeyValuePair <string, DateTime> >();
ConcurrentBag <CatalogItem> batchItems = new ConcurrentBag <CatalogItem>();
while (batch.Count < BatchSize && packageCreatedQueue.Count > 0)
{
completed++;
var packagePair = packageCreatedQueue.Dequeue();
lastCreated = packagePair.Value;
batch.Add(packagePair);
}
var commitTime = DateTime.UtcNow;
Parallel.ForEach(batch, options, entry =>
{
FileInfo fileInfo = new FileInfo(nupkgs + entry.Key);
if (fileInfo.Exists)
{
using (Stream stream = new FileStream(fileInfo.FullName, FileMode.Open))
{
string packageHash = null;
packageHashLookup.TryGetValue(fileInfo.Name, out packageHash);
CatalogItem item = Utils.CreateCatalogItem(stream, entry.Value, packageHash, fileInfo.FullName);
batchItems.Add(item);
}
}
});
if (commitTask != null)
{
commitTask.Wait();
}
foreach (var item in batchItems)
{
writer.Add(item);
}
commitTask = Task.Run(async() => await writer.Commit(commitTime, PackageCatalog.CreateCommitMetadata(writer.RootUri, lastCreated, null)));
// stats
double perPackage = runtime.Elapsed.TotalSeconds / (double)completed;
DateTime finish = DateTime.Now.AddSeconds(perPackage * packageCreatedQueue.Count);
Console.WriteLine("commit number {0} Completed: {1} Remaining: {2} Estimated Finish: {3}",
commitCount++,
completed,
packageCreatedQueue.Count,
finish.ToString("O"));
}
// wait for the final commit
if (commitTask != null)
{
commitTask.Wait();
}
Console.WriteLine("Finished in: " + runtime.Elapsed);
}
public PackageCatalogWrapper()
{
//Opens the catalog of packages that is available for the current user.
_packageCatalog = PackageCatalog.OpenForCurrentUser();
}
/// <summary>
/// Asynchronously writes package metadata to the catalog.
/// </summary>
/// <param name="packageCatalogItemCreator">A package catalog item creator.</param>
/// <param name="packages">Packages to download metadata for.</param>
/// <param name="storage">Storage.</param>
/// <param name="lastCreated">The catalog's last created datetime.</param>
/// <param name="lastEdited">The catalog's last edited datetime.</param>
/// <param name="lastDeleted">The catalog's last deleted datetime.</param>
/// <param name="maxDegreeOfParallelism">The maximum degree of parallelism for package processing.</param>
/// <param name="createdPackages"><c>true</c> to include created packages; otherwise, <c>false</c>.</param>
/// <param name="updateCreatedFromEdited"><c>true</c> to update the created cursor from the last edited cursor;
/// otherwise, <c>false</c>.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <param name="telemetryService">A telemetry service.</param>
/// <param name="logger">A logger.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns the latest
/// <see cref="DateTime}" /> that was processed.</returns>
public static async Task <DateTime> DownloadMetadata2CatalogAsync(
IPackageCatalogItemCreator packageCatalogItemCreator,
SortedList <DateTime, IList <FeedPackageDetails> > packages,
IStorage storage,
DateTime lastCreated,
DateTime lastEdited,
DateTime lastDeleted,
int maxDegreeOfParallelism,
bool?createdPackages,
bool updateCreatedFromEdited,
CancellationToken cancellationToken,
ITelemetryService telemetryService,
ILogger logger)
{
if (packageCatalogItemCreator == null)
{
throw new ArgumentNullException(nameof(packageCatalogItemCreator));
}
if (packages == null)
{
throw new ArgumentNullException(nameof(packages));
}
if (storage == null)
{
throw new ArgumentNullException(nameof(storage));
}
if (maxDegreeOfParallelism < 1)
{
throw new ArgumentOutOfRangeException(
nameof(maxDegreeOfParallelism),
string.Format(Strings.ArgumentOutOfRange, 1, int.MaxValue));
}
if (telemetryService == null)
{
throw new ArgumentNullException(nameof(telemetryService));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
cancellationToken.ThrowIfCancellationRequested();
var writer = new AppendOnlyCatalogWriter(storage, telemetryService, Constants.MaxPageSize);
var lastDate = DetermineLastDate(lastCreated, lastEdited, createdPackages);
if (packages.Count == 0)
{
return(lastDate);
}
// Flatten the sorted list.
var workItems = packages.SelectMany(
pair => pair.Value.Select(
details => new PackageWorkItem(pair.Key, details)))
.ToArray();
await workItems.ForEachAsync(maxDegreeOfParallelism, async workItem =>
{
workItem.PackageCatalogItem = await packageCatalogItemCreator.CreateAsync(
workItem.FeedPackageDetails,
workItem.Timestamp,
cancellationToken);
});
lastDate = packages.Last().Key;
// AppendOnlyCatalogWriter.Add(...) is not thread-safe, so add them all at once on one thread.
foreach (var workItem in workItems.Where(workItem => workItem.PackageCatalogItem != null))
{
writer.Add(workItem.PackageCatalogItem);
logger?.LogInformation("Add metadata from: {PackageDetailsContentUri}", workItem.FeedPackageDetails.ContentUri);
}
if (createdPackages.HasValue)
{
lastEdited = !createdPackages.Value ? lastDate : lastEdited;
if (updateCreatedFromEdited)
{
lastCreated = lastEdited;
}
else
{
lastCreated = createdPackages.Value ? lastDate : lastCreated;
}
}
var commitMetadata = PackageCatalog.CreateCommitMetadata(writer.RootUri, new CommitMetadata(lastCreated, lastEdited, lastDeleted));
await writer.Commit(commitMetadata, cancellationToken);
logger?.LogInformation("COMMIT metadata to catalog.");
return(lastDate);
}
public void UpdateLatestStablePackage(string packageId, string packageVersion, bool haveIdx, int expectedPackageCount, bool expectedHaveIdx, bool packageIsNull)
{
// Arrange
Uri catalog = new Uri("http://foo");
Uri baseAddress = new Uri("http://storage");
MemoryStorage storage = new MemoryStorage(baseAddress);
Uri fileAddress = new Uri("http://storage/packagecatalog.json");
storage.Content.Add(fileAddress, new StringStorageContent(inputJson));
// Act
PackageCatalog packageCatalog = new PackageCatalog(catalog, storage, fileAddress, null);
packageCatalog.LoadAsync(fileAddress, storage, new CancellationToken()).Wait();
packageCatalog.UpdateLatestStablePackage(packageId, packageVersion, haveIdx);
// Assert
PackageInfo package;
packageCatalog.Packages.TryGetValue(packageId, out package);
Assert.Equal(expectedPackageCount, packageCatalog.Packages.Count);
Assert.Equal(packageIsNull, package == null);
if (!packageIsNull)
{
Assert.Equal(expectedHaveIdx, package.HaveIdx);
}
}
private void Catalog_PackageStaging(PackageCatalog sender, PackageStagingEventArgs args)
{
// Doesn't fire - 7535335
//LoadDeployingPackageToUI(args.Package, args.Progress);
}
private void Catalog_PackageStatusChanged(PackageCatalog sender, PackageStatusChangedEventArgs args)
{
// Doesn't fire - 7535335
}
public void SetLatestStablePackage_Add()
{
// Arrange
Uri catalog = new Uri("http://foo");
Uri baseAddress = new Uri("http://storage");
MemoryStorage storage = new MemoryStorage(baseAddress);
Uri fileAddress = new Uri("http://storage/packagecatalog.json");
storage.Content.Add(fileAddress, new StringStorageContent(inputJson));
// Act
PackageCatalog packageCatalog = new PackageCatalog(catalog, storage, fileAddress, null);
packageCatalog.LoadAsync(fileAddress, storage, new CancellationToken()).Wait();
packageCatalog.SetLatestStablePackage("My.Shiny.New.Package", "99.99.99-prerelease", new Guid(), DateTime.MinValue, new Uri("http://foo/download"), true);
// Assert
PackageInfo package = packageCatalog.Packages["My.Shiny.New.Package"];
Assert.Equal(4, packageCatalog.Packages.Count);
Assert.Equal("My.Shiny.New.Package", package.PackageId);
Assert.Equal("99.99.99-prerelease", package.LatestStableVersion);
Assert.Equal(true, package.HaveIdx);
Assert.Equal(new Guid(), package.CommitId);
Assert.Equal(DateTime.MinValue, package.CommitTimeStamp);
Assert.Equal(new Uri("http://foo/download"), package.DownloadUrl);
}
