private static void FetchUpdates(QueryFilter queryToRun, CompressedMetadataStore destinationResult)
{
var server = new UpstreamServerClient(destinationResult.UpstreamSource);
server.MetadataQueryProgress += Server_MetadataQueryProgress;
Console.WriteLine("Fetching categories ...");
server.GetCategories(destinationResult).GetAwaiter().GetResult();
if (queryToRun != null)
{
Console.WriteLine("Running query with filters:");
MetadataQuery.PrintFilter(queryToRun, destinationResult);
server.GetUpdates(queryToRun, destinationResult).GetAwaiter().GetResult();
}
Console.WriteLine();
destinationResult.CommitProgress += Program.MetadataSourceOperationProgressHandler;
destinationResult.Commit();
Console.WriteLine();
ConsoleOutput.WriteGreen($"Query result saved to file {destinationResult.FilePath}");
}
/// <summary>
/// Initialize a new instance of UpstreamServerStartup.
/// </summary>
/// <param name="config">
/// <para>ASP.NET configuration.</para>
///
/// <para>Must contain a string entry "metadata-path" with the path to the metadata source to use</para>
///
/// <para>Must contain a string entry "updates-filter" with a JSON serialized updates metadata filter</para>
///
/// <para>Must contain a string entry "service-config-path" with the path to the service configuration JSON</para>
///
/// <para>Can contain a string entry "content-path" with the path to the content store to use if serving update content</para>
/// </param>
public UpstreamServerStartup(IConfiguration config)
{
// Get the metadata source path from the configuration
var sourcePath = config.GetValue <string>("metadata-path");
var contentPath = config.GetValue <string>("content-path");
// Get the filteres to apply to updates; restricts which updates are shared with downstream servers
Filter = MetadataFilter.FromJson(config.GetValue <string>("updates-filter"));
// Open the updates metadata source. It must exist
LocalMetadataSource = CompressedMetadataStore.Open(sourcePath);
if (LocalMetadataSource == null)
{
throw new System.Exception($"Cannot open the specified metadata source at {sourcePath}");
}
var serviceConfigPath = config.GetValue <string>("service-config-path");
ServiceConfiguration = JsonConvert.DeserializeObject <ServerSyncConfigData>(
File.OpenText(serviceConfigPath).ReadToEnd());
if (!string.IsNullOrEmpty(contentPath))
{
LocalContentSource = new FileSystemContentStore(contentPath);
ServiceConfiguration.CatalogOnlySync = false;
}
else
{
ServiceConfiguration.CatalogOnlySync = true;
}
}
/// <summary>
/// Initialize a new instance of UpdateServerStartup.
/// </summary>
/// <param name="config">
/// <para>ASP.NET configuration.</para>
/// <list type="bullet">
/// <item><description>Required: string entry "metadata-source" with the path to file containing updates metadata.</description></item>
/// <item><description>Required: string entry "server-config" containing the server configuration in JSON format. A reference server configuration file is provided.</description></item>
/// <item><description>Optional: string entry "content-source" containing the path where update content is stored.</description></item>
/// <item><description>Optional: string entry "content-http-root" with the root URL where update content is serverd from (e.g. http://my-update-server.com). Usually this set to the address/name of the server. Required if "content-source" is specified.</description></item>
/// </list>
/// </param>
public UpdateServerStartup(IConfiguration config)
{
// Get the repository path from the configuration
var metadataSourceFile = config.GetValue <string>("metadata-source");
MetadataSource = CompressedMetadataStore.Open(metadataSourceFile);
if (MetadataSource == null)
{
throw new System.Exception($"Cannot open updates metadata source from path {metadataSourceFile}");
}
UpdateServiceConfiguration = Newtonsoft.Json.JsonConvert.DeserializeObject <Config>(config.GetValue <string>("server-config"));
// A file that contains mapping of update identity to a 32 bit, locally assigned revision ID.
var contentPath = config.GetValue <string>("content-source");
if (!string.IsNullOrEmpty(contentPath))
{
ContentSource = new FileSystemContentStore(contentPath);
if (ContentSource == null)
{
throw new System.Exception($"Cannot open updates content source from path {contentPath}");
}
}
ContentRoot = config.GetValue <string>("content-http-root");
}
/// <summary>
/// Gets updates matching the query filter from an upstream update server.
/// </summary>
/// <param name="updatesFilter">Updates filter. See <see cref="QueryFilter"/> for details.</param>
/// <returns>An updates metadata source containing updates that match the filter.</returns>
public async Task <CompressedMetadataStore> GetUpdates(QueryFilter updatesFilter)
{
var queryResult = new CompressedMetadataStore(GetQueryResultFileName(), UpstreamEndpoint);
await GetUpdates(updatesFilter, queryResult);
queryResult.Commit();
return(queryResult);
}
/// <summary>
/// Gets the list of categories from the upstream update server.
/// </summary>
/// <returns>An updates metadata source containing all.</returns>
public async Task <CompressedMetadataStore> GetCategories()
{
var queryResult = new CompressedMetadataStore(GetQueryResultFileName(), UpstreamEndpoint);
await GetCategories(queryResult);
queryResult.Commit();
return(queryResult);
}
/// <summary>
/// Runs the sync command
/// </summary>
/// <param name="options">Fetch command options</param>
public static void FetchUpdates(FetchUpdatesOptions options)
{
Endpoint upstreamEndpoint;
CompressedMetadataStore baselineSource;
Console.WriteLine("Opening query results file");
baselineSource = CompressedMetadataStore.Open(options.MetadataSourcePath);
if (baselineSource == null)
{
ConsoleOutput.WriteRed("Cannot open the query result file!");
return;
}
ConsoleOutput.WriteGreen("Done!");
upstreamEndpoint = baselineSource.UpstreamSource;
// The filter to apply when fetching updates
QueryFilter queryToRun = null;
queryToRun = baselineSource.Filters.FirstOrDefault();
if (queryToRun != null)
{
ConsoleOutput.WriteCyan("Using the filter from the baseline source. Command line filters are ignored!");
}
if (queryToRun == null)
{
// A new query will be created based on command line options
try
{
queryToRun = MetadataSync.CreateValidFilterFromOptions(options, baselineSource);
}
catch (Exception ex)
{
ConsoleOutput.WriteRed(ex.Message);
return;
}
}
using (var syncResult = new CompressedMetadataStore(baselineSource))
{
if (!string.IsNullOrEmpty(options.AccountName) && !string.IsNullOrEmpty(options.AccountGuid))
{
if (!Guid.TryParse(options.AccountGuid, out Guid accountGuid))
{
ConsoleOutput.WriteRed("The account GUID must be a valid GUID string");
return;
}
syncResult.SetUpstreamCredentials(options.AccountName, accountGuid);
}
FetchUpdates(queryToRun, syncResult);
}
}
/// <summary>
/// Fetches categories from an upstream server
/// </summary>
/// <param name="options">Pre-Fetch command options</param>
public static void FetchCategories(FetchCategoriesOptions options)
{
Endpoint upstreamEndpoint;
if (!string.IsNullOrEmpty(options.UpstreamEndpoint))
{
upstreamEndpoint = new Endpoint(options.UpstreamEndpoint);
}
else
{
upstreamEndpoint = Endpoint.Default;
}
CompressedMetadataStore syncResult;
string destinationFile;
if (!string.IsNullOrEmpty(options.OutFile))
{
if (Path.GetExtension(options.OutFile).ToLower() != ".zip")
{
ConsoleOutput.WriteRed("The out file must have .zip extension");
return;
}
destinationFile = options.OutFile;
}
else
{
destinationFile = $"QueryResult-{DateTime.Now.ToFileTime()}.zip";
}
Console.WriteLine($"Creating compressed metadata store {destinationFile}");
syncResult = new CompressedMetadataStore(destinationFile, upstreamEndpoint);
if (!string.IsNullOrEmpty(options.AccountName) &&
!string.IsNullOrEmpty(options.AccountGuid))
{
if (!Guid.TryParse(options.AccountGuid, out Guid accountGuid))
{
ConsoleOutput.WriteRed("The account GUID must be a valid GUID string");
return;
}
syncResult.SetUpstreamCredentials(options.AccountName, accountGuid);
}
FetchUpdates(null, syncResult);
}
/// <summary>
/// Opens an updates metadata source the path specified on the command line
/// </summary>
/// <param name="sourceOptions">The command line switch that contains the path</param>
/// <returns>A open updates metadata source</returns>
public static IMetadataSource LoadMetadataSourceFromOptions(IMetadataSourceOptions sourceOptions)
{
IMetadataSource source = null;
Console.Write("Opening update metadata source file... ");
try
{
source = CompressedMetadataStore.Open(sourceOptions.MetadataSourcePath);
ConsoleOutput.WriteGreen("Done!");
}
catch (Exception ex)
{
Console.WriteLine();
ConsoleOutput.WriteRed("Cannot open the query result file:");
ConsoleOutput.WriteRed(ex.Message);
}
return(source);
}