private bool ValidatePackageDescriptor(PackageDescriptor packageDescriptor)
{
string newVersion;
if (!VersionStringHelper.ValidateVersion(packageDescriptor.PackageVersion, out newVersion))
{
Log.LogWarning("PackageServerFacade",
$"The package '{packageDescriptor.Name}' ({packageDescriptor.Id}) did not validate and is skipped");
return(false);
}
packageDescriptor.PackageVersion = newVersion;
if (!VersionStringHelper.ValidateVersion(packageDescriptor.MinCompositeVersionSupported, out newVersion))
{
Log.LogWarning("PackageServerFacade",
$"The package '{packageDescriptor.Name}' ({packageDescriptor.Id}) did not validate and is skipped");
return(false);
}
packageDescriptor.MinCompositeVersionSupported = newVersion;
if (!VersionStringHelper.ValidateVersion(packageDescriptor.MaxCompositeVersionSupported, out newVersion))
{
Log.LogWarning("PackageServerFacade",
$"The package '{packageDescriptor.Name}' ({packageDescriptor.Id}) did not validate and is skipped");
return(false);
}
packageDescriptor.MaxCompositeVersionSupported = newVersion;
return(true);
}
/// <summary>
/// Gets all available versions.
/// </summary>
/// <returns>
/// List of available versions.
/// </returns>
public IEnumerable <Version> GetAll()
{
string path = HttpContext.Current.Server.MapPath("~/App_Data/Repository");
var result = new List <Version>();
if (Directory.Exists(path))
{
var di = new DirectoryInfo(path);
DirectoryInfo[] directories = di.GetDirectories();
foreach (DirectoryInfo directoryInfo in directories)
{
if (VersionStringHelper.IsValidVersionString(directoryInfo.Name))
{
string versionId = directoryInfo.Name;
string stableName = this.settingsProvider.InstallerNamePattern.Replace("{number}", versionId).Replace("{stability}", string.Empty);
string betaName = this.settingsProvider.InstallerNamePattern.Replace("{number}", versionId).Replace("{stability}", "-beta");
string filePath = HttpContext.Current.Server.MapPath(string.Format("~/App_Data/Repository/{0}/{1}", directoryInfo.Name, stableName));
if (File.Exists(filePath))
{
result.Add(new Version
{
Id = versionId,
Stable = true,
ExpirationDate = this.ExtractExpirationDate(versionId)
});
}
else
{
filePath = HttpContext.Current.Server.MapPath(string.Format("~/App_Data/Repository/{0}/{1}", directoryInfo.Name, betaName));
if (File.Exists(filePath))
{
result.Add(new Version
{
Id = versionId,
Stable = false,
ExpirationDate = this.ExtractExpirationDate(versionId)
});
}
}
}
}
}
return(result);
}
public async Task <HttpResponseMessage> PostVersion()
{
// Check if the request contains multipart/form-data.
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
string root = HttpContext.Current.Server.MapPath("~/App_Data/Temp");
if (!Directory.Exists(root))
{
Directory.CreateDirectory(root);
}
var provider = new MultipartFormDataStreamProvider(root);
try
{
// Read the form data and return an async task.
await Request.Content.ReadAsMultipartAsync(provider);
string[] ids = provider.FormData.GetValues("versionId");
string[] stables = provider.FormData.GetValues("versionStable");
string[] expDates = provider.FormData.GetValues("expirationDate");
bool isStable = false;
bool idInvalid = ids == null || ids.Length != 1 || !VersionStringHelper.IsValidVersionString(ids[0]);
bool stabInvalid = stables == null || stables.Length != 1 || !bool.TryParse(stables[0], out isStable);
bool expirationInvalid = expDates == null || expDates.Length != 1;
if (idInvalid || stabInvalid || expirationInvalid || provider.FileData.Count != 1)
{
throw new HttpResponseException(HttpStatusCode.ExpectationFailed);
}
DateTime?expirationDate = null;
if (!string.IsNullOrEmpty(expDates[0]))
{
DateTime parseResult;
if (DateTime.TryParseExact(expDates[0], "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out parseResult))
{
expirationDate = parseResult;
}
else
{
throw new HttpResponseException(HttpStatusCode.ExpectationFailed);
}
}
Version versionItem = new Version
{
Id = ids[0],
Stable = isStable,
ExpirationDate = expirationDate
};
var postedFile = provider.FileData[0];
var item = this.repository.Add(versionItem, postedFile.LocalFileName);
item.DownloadUrl = Url.Link("Default", new { action = "Download", id = item.Id });
var response = Request.CreateResponse(HttpStatusCode.Created, item);
response.Headers.Location = new Uri(item.DownloadUrl);
return(response);
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
internal static PackageFragmentValidationResult ValidatePackageInformation(XElement installContent, out PackageInformation packageInformation)
{
packageInformation = null;
XElement packageInformationElement = installContent.Element(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageInformationElementName));
if (packageInformationElement == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingElement"), PackageSystemSettings.PackageInformationElementName), installContent));
}
XAttribute idAttribute = packageInformationElement.Attribute(PackageSystemSettings.IdAttributeName);
XAttribute nameAttribute = packageInformationElement.Attribute(PackageSystemSettings.NameAttributeName);
XAttribute groupNameAttribute = packageInformationElement.Attribute(PackageSystemSettings.GroupNameAttributeName);
XAttribute authorAttribute = packageInformationElement.Attribute(PackageSystemSettings.AuthorAttributeName);
XAttribute websiteAttribute = packageInformationElement.Attribute(PackageSystemSettings.WebsiteAttributeName);
XAttribute versionAttribute = packageInformationElement.Attribute(PackageSystemSettings.VersionAttributeName);
XAttribute canBeUninstalledAttribute = packageInformationElement.Attribute(PackageSystemSettings.CanBeUninstalledAttributeName);
XAttribute systemLockingAttribute = packageInformationElement.Attribute(PackageSystemSettings.SystemLockingAttributeName);
XAttribute flushOnCompletionAttribute = packageInformationElement.Attribute(PackageSystemSettings.FlushOnCompletionAttributeName);
XAttribute reloadConsoleOnCompletionAttribute = packageInformationElement.Attribute(PackageSystemSettings.ReloadConsoleOnCompletionAttributeName);
if (idAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.IdAttributeName), packageInformationElement));
}
if (nameAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.NameAttributeName), packageInformationElement));
}
if (groupNameAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.GroupNameAttributeName), packageInformationElement));
}
if (authorAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.AuthorAttributeName), packageInformationElement));
}
if (websiteAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.WebsiteAttributeName), packageInformationElement));
}
if (versionAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.VersionAttributeName), packageInformationElement));
}
if (canBeUninstalledAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.CanBeUninstalledAttributeName), packageInformationElement));
}
if (systemLockingAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.SystemLockingAttributeName), packageInformationElement));
}
if (string.IsNullOrEmpty(nameAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.NameAttributeName), nameAttribute));
}
if (string.IsNullOrEmpty(groupNameAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.GroupNameAttributeName), groupNameAttribute));
}
if (string.IsNullOrEmpty(authorAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.AuthorAttributeName), authorAttribute));
}
if (string.IsNullOrEmpty(websiteAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.WebsiteAttributeName), websiteAttribute));
}
if (string.IsNullOrEmpty(versionAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.VersionAttributeName), versionAttribute));
}
if (string.IsNullOrEmpty(packageInformationElement.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidElementValue"), PackageSystemSettings.PackageInformationElementName), packageInformationElement));
}
Guid id;
if (idAttribute.TryGetGuidValue(out id) == false)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.IdAttributeName), idAttribute));
}
string newVersion;
if (VersionStringHelper.ValidateVersion(versionAttribute.Value, out newVersion))
{
versionAttribute.Value = newVersion;
}
else
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.VersionAttributeName), versionAttribute));
}
bool canBeUninstalled;
if (canBeUninstalledAttribute.TryGetBoolValue(out canBeUninstalled) == false)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.CanBeUninstalledAttributeName), canBeUninstalledAttribute));
}
SystemLockingType systemLockingType;
if (systemLockingAttribute.TryDeserialize(out systemLockingType) == false)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.SystemLockingAttributeName), systemLockingAttribute));
}
bool flushOnCompletion = false;
if ((flushOnCompletionAttribute != null) && (flushOnCompletionAttribute.TryGetBoolValue(out flushOnCompletion) == false))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.FlushOnCompletionAttributeName), flushOnCompletionAttribute));
}
bool reloadConsoleOnCompletion = false;
if ((reloadConsoleOnCompletionAttribute != null) && (reloadConsoleOnCompletionAttribute.TryGetBoolValue(out reloadConsoleOnCompletion) == false))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.ReloadConsoleOnCompletionAttributeName), reloadConsoleOnCompletionAttribute));
}
XElement packageRequirementsElement = installContent.Element(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageRequirementsElementName));
if (packageRequirementsElement == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingElement"), PackageSystemSettings.PackageRequirementsElementName), installContent));
}
XAttribute minimumCompositeVersionAttribute = packageRequirementsElement.Attribute(PackageSystemSettings.MinimumCompositeVersionAttributeName);
XAttribute maximumCompositeVersionAttribute = packageRequirementsElement.Attribute(PackageSystemSettings.MaximumCompositeVersionAttributeName);
if (minimumCompositeVersionAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.MinimumCompositeVersionAttributeName), packageRequirementsElement));
}
if (maximumCompositeVersionAttribute == null)
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.MissingAttribute"), PackageSystemSettings.MaximumCompositeVersionAttributeName), packageRequirementsElement));
}
if (string.IsNullOrEmpty(minimumCompositeVersionAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.MinimumCompositeVersionAttributeName), minimumCompositeVersionAttribute));
}
if (string.IsNullOrEmpty(maximumCompositeVersionAttribute.Value))
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.MaximumCompositeVersionAttributeName), maximumCompositeVersionAttribute));
}
if (VersionStringHelper.ValidateVersion(minimumCompositeVersionAttribute.Value, out newVersion))
{
minimumCompositeVersionAttribute.Value = newVersion;
}
else
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.VersionAttributeName), minimumCompositeVersionAttribute));
}
if (VersionStringHelper.ValidateVersion(maximumCompositeVersionAttribute.Value, out newVersion))
{
maximumCompositeVersionAttribute.Value = newVersion;
}
else
{
return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, string.Format(GetText("PackageManager.InvalidAttributeValue"), PackageSystemSettings.VersionAttributeName), maximumCompositeVersionAttribute));
}
packageInformation = new PackageInformation
{
Id = id,
Name = nameAttribute.Value,
GroupName = groupNameAttribute.Value,
Author = authorAttribute.Value,
Website = websiteAttribute.Value,
Version = versionAttribute.Value,
CanBeUninstalled = canBeUninstalled,
SystemLockingType = systemLockingType,
Description = packageInformationElement.Value,
FlushOnCompletion = flushOnCompletion,
ReloadConsoleOnCompletion = reloadConsoleOnCompletion,
MinCompositeVersionSupported = new Version(minimumCompositeVersionAttribute.Value),
MaxCompositeVersionSupported = new Version(maximumCompositeVersionAttribute.Value)
};
return(null);
}
