public static async Task <IEnumerable <NugetPackage> > GetNugetPackages(string projectPath)
{
var projectDirectory = Path.GetDirectoryName(projectPath);
var packagesConfig = Path.Combine(projectDirectory, "packages.config");
if (File.Exists(packagesConfig))
{
var projectFile = await File.ReadAllTextAsync(packagesConfig);
var doc = XDocument.Parse(projectFile);
var packageReferences = doc.XPathSelectElements("//package")
.Select(pr => new NugetPackage
{
Name = pr.Attribute("id").Value,
Version = VersionEx.FromString(pr.Attribute("version").Value),
TargetFramework = pr.Attribute("targetFramework").Value
});
return(packageReferences);
}
else
{
var projectFile = await File.ReadAllTextAsync(projectPath);
var doc = XDocument.Parse(projectFile);
var packageReferences = doc.XPathSelectElements("//PackageReference")
.Select(pr => new NugetPackage
{
Name = pr.Attribute("Include").Value,
Version = VersionEx.FromString(pr.Attribute("Version").Value)
});
return(packageReferences);
}
}
public static string ProcessVersionString(string str)
{
// Integer - Ex) 001 -> 1
if (NumberHelper.ParseInt32(str, out int intVal))
return intVal.ToString();
// Semantic versioning - Ex) 5.1.2600
// If str does not conform to semantic versioning, return null
VersionEx semVer = VersionEx.Parse(str);
return semVer?.ToString();
}
private async Task <IEnumerable <NugetPackage> > ReadNuget(string projectPath, DotNetProject project)
{
if (project.Format == ProjectFormat.Old)
{
var nugets = await NugetConfigReader.GetNugetPackages(projectPath);
return(nugets);
}
else
{
return(project.PackageReferences.Where(x => !string.IsNullOrWhiteSpace(x.Name))
.Select(p => new NugetPackage
{
Name = p.Name,
Version = VersionEx.FromString(p.Version)
}));
}
}
private ResultReport <Script> InternalUpdateOneScript(Script sc, ScriptStateBackup stateBackup)
{
// Never should be triggered, because Script class constructor check it
Debug.Assert(sc.ParsedVersion != null, $"Local script [{sc.Title}] does not provide proper version information");
string updateUrl = sc.UpdateUrl;
string metaJsonUrl = Path.ChangeExtension(updateUrl, ".meta.json");
string metaJsonFile = FileHelper.GetTempFile(".meta.json");
string tempScriptFile = FileHelper.GetTempFile(".script");
try
{
// Download .meta.json
HttpFileDownloader.Report httpReport = DownloadFile(metaJsonUrl, metaJsonFile);
if (!httpReport.Result)
{
// Failed to send a request, such as network not available
if (httpReport.StatusCode == 0)
{
return(new ResultReport <Script>(false, null, $"Unable to connect to the server"));
}
// Try downloading .deleted to check if a script is deleted
string errorMsg;
string deletedUrl = Path.ChangeExtension(updateUrl, ".deleted");
string deletedFile = Path.ChangeExtension(metaJsonFile, ".deleted");
try
{
httpReport = DownloadFile(deletedUrl, deletedFile);
if (httpReport.Result)
{ // Successfully received response
if (httpReport.StatusCode == 200) // .deleted file exists in the server
{
errorMsg = $"[{sc.Title}] was deleted from the server";
}
else // There is no .deleted file in the server
{
errorMsg = $"Update is not available for [{sc.Title}]";
}
}
else
{
if (httpReport.StatusCode == 0) // Failed to send a request, such as network not available
{
errorMsg = $"Unable to connect to the server";
}
else
{
errorMsg = $"Update is not available for [{sc.Title}]";
}
}
}
finally
{
if (File.Exists(deletedFile))
{
File.Delete(deletedFile);
}
}
return(new ResultReport <Script>(false, null, errorMsg));
}
// Check and read .meta.json
ResultReport <UpdateJson.Root> jsonReport = UpdateJson.ReadUpdateJson(metaJsonFile);
if (!jsonReport.Success)
{
return(new ResultReport <Script>(false, null, jsonReport.Message));
}
UpdateJson.Root metaJson = jsonReport.Result;
UpdateJson.FileIndex index = metaJson.Index;
if (index.Kind != UpdateJson.IndexEntryKind.Script)
{
return(new ResultReport <Script>(false, null, "Update json is not of a script file"));
}
UpdateJson.ScriptInfo scInfo = index.ScriptInfo;
if (scInfo.Format != UpdateJson.ScriptFormat.IniBased)
{
return(new ResultReport <Script>(false, null, $"Format [{scInfo.Format}] of remote script [{sc.Title}] is not supported"));
}
UpdateJson.IniBasedScript iniScInfo = scInfo.IniBased;
if (iniScInfo.Version <= sc.ParsedVersion)
{
return(new ResultReport <Script>(false, null, $"You are using the lastest version of script [{sc.Title}]"));
}
// Download .script file
httpReport = DownloadFile(updateUrl, tempScriptFile);
if (!httpReport.Result)
{
return(new ResultReport <Script>(false, null, httpReport.ErrorMsg));
}
// Verify downloaded .script file with FileMetadata
ResultReport verifyReport = index.FileMetadata.VerifyFile(tempScriptFile);
if (!verifyReport.Success)
{
return(new ResultReport <Script>(false, null, $"Remote script [{sc.Title}] is corrupted"));
}
// Check downloaded script's version and check
// Must have been checked with the UpdateJson
string remoteVerStr = IniReadWriter.ReadKey(tempScriptFile, "Main", "Version");
VersionEx remoteVer = VersionEx.Parse(remoteVerStr);
if (remoteVer == null)
{
return(new ResultReport <Script>(false, null, $"Version of remote script [{sc.Title}] is corrupted"));
}
if (!remoteVer.Equals(iniScInfo.Version))
{
return(new ResultReport <Script>(false, null, $"Version of remote script [{sc.Title}] is corrupted"));
}
if (remoteVer <= sc.ParsedVersion)
{
return(new ResultReport <Script>(false, null, $"Version of remote script [{sc.Title}] is corrupted"));
}
// Check if remote script is valid
Script remoteScript = _p.LoadScriptRuntime(tempScriptFile, new LoadScriptRuntimeOptions
{
IgnoreMain = false,
AddToProjectTree = false,
OverwriteToProjectTree = false,
});
if (remoteScript == null)
{
return(new ResultReport <Script>(false, null, $"Remote script [{sc.Title}] is corrupted"));
}
// Overwrite backup state to new script
if (stateBackup != null)
{
RestoreScriptState(remoteScript, stateBackup);
// Let's be extra careful
remoteScript = _p.RefreshScript(remoteScript);
if (remoteScript == null)
{
return(new ResultReport <Script>(false, null, $"Internal error at {nameof(FileUpdater)}.{nameof(RestoreScriptState)}"));
}
}
// Copy downloaded remote script into new script
File.Copy(tempScriptFile, sc.DirectRealPath, true);
Script newScript = _p.RefreshScript(sc);
// Return updated script instance
return(new ResultReport <Script>(true, newScript, $"Updated script [{sc.Title}] to [v{sc.RawVersion}] from [v{newScript.RawVersion}]"));
}
finally
{
if (File.Exists(metaJsonFile))
{
File.Delete(metaJsonFile);
}
if (File.Exists(tempScriptFile))
{
File.Delete(tempScriptFile);
}
}
}
