public void MajorMethodChangeCausesMajor()
{
NapackSpec minorMethodSpec = this.LoadNapackSpec(SampleStrings.LargeSampleMajorMethodChange);
Assert.AreEqual(NapackAnalyst.UpversionType.Major, NapackAnalyst.DeterminedRequiredUpversioning(oldSpec, minorMethodSpec));
}
public static void Main(string[] args)
{
Global.RootDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
logger.Info("Serializer Setup...");
Serializer.Setup();
logger.Info("System Config loading...");
Global.SystemConfig = Global.SystemConfig ?? Serializer.Deserialize <SystemConfig>(File.ReadAllText(ConfigurationManager.AppSettings["SystemConfigFilename"]));
logger.Info("Email management loading...");
Global.EmailManager = Global.EmailManager ?? new EmailManager(new SmtpEmailSender(Global.SystemConfig.EmailHost, Global.SystemConfig.EmailPort));
logger.Info("Database loading...");
bool useInMemoryVariant = false;
Global.NapackStorageManager = Global.NapackStorageManager ??
((args.Length > 1 && bool.TryParse(args[1], out useInMemoryVariant) && useInMemoryVariant) ?
(INapackStorageManager) new InMemoryNapackStorageManager() :
new PostgresqlNapackStorageManager());
if (Global.NapackStorageManager.PerformsAutomatedBackups)
{
logger.Info("Database backup thread loading...");
dbBackupTimer = new System.Timers.Timer()
{
AutoReset = true,
Enabled = true,
Interval = TimeSpan.FromDays(1).TotalMilliseconds, // Run every day.
};
dbBackupTimer.Elapsed += Global.NapackStorageManager.RunDbBackup;
dbBackupTimer.Start();
}
logger.Info("System stats management loading...");
Global.SystemStats = new SystemStats();
// Turn off certificate validation, because it doesn't work with self-signed certificates.
ServicePointManager.ServerCertificateValidationCallback =
delegate(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
return(true);
};
if (args.Length < 1)
{
logger.Fatal("Expecting at a minimum the startup URL as the first argument!");
}
else
{
logger.Info("Napack Server Startup...");
Global.ShutdownEvent = new ManualResetEvent(false);
logger.Info("Analyst Setup...");
NapackAnalyst.Initialize(Global.SystemConfig.PackageValidationFilePath, Global.SystemConfig.NameValidationFilePath);
logger.Info("Starting web server...");
using (WebApp.Start <Startup>(args[0]))
{
Global.Initialized = true;
Global.ShutdownEvent.WaitOne();
logger.Info("Napack Server Shutting down...");
logger.Info("Databsae backup timer stopped.");
dbBackupTimer?.Stop();
logger.Info("Napack Server Shutdown.");
}
}
}
public void IdenticalApisCausePatch()
{
Assert.AreEqual(NapackAnalyst.UpversionType.Patch, NapackAnalyst.DeterminedRequiredUpversioning(oldSpec, oldSpec));
}
public NapackModule()
: base("/napacks")
{
// Gets a Napack package or series of package versions.
Get["/{packageName}/{version?}"] = parameters =>
{
string packageName = parameters.packageName;
string version = null;
try
{
version = parameters.version;
}
catch (RuntimeBinderException)
{
}
if (version == null)
{
// The user is asking for all major versions of the specified package.
NapackMetadata package = Global.NapackStorageManager.GetPackageMetadata(packageName, false);
return(this.Response.AsJson(package.AsSummaryJson()));
}
else
{
// Attempt to parse our the version string.
List <int> components;
try
{
components = version.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries).Select(item => int.Parse(item)).ToList();
}
catch (Exception)
{
throw new InvalidNapackVersionException();
}
// Handle the resulting version components.
if (components.Count == 1 || components.Count == 2)
{
NapackMetadata package = Global.NapackStorageManager.GetPackageMetadata(packageName, false);
NapackMajorVersionMetadata majorVersion = package.GetMajorVersion(components[0]);
return(this.Response.AsJson(majorVersion.AsSummaryJson()));
}
else if (components.Count == 3)
{
NapackVersion specificVersion = Global.NapackStorageManager.GetPackageVersion(new NapackVersionIdentifier(packageName, components[0], components[1], components[2]));
Global.NapackStorageManager.IncrementPackageDownload(packageName);
return(this.Response.AsJson(specificVersion.AsSummaryJson()));
}
else
{
throw new InvalidNapackVersionException();
}
}
};
// Creates a new Napack package.
Post["/{packageName}"] = parameters =>
{
string packageName = parameters.packageName;
if (Global.NapackStorageManager.ContainsNapack(packageName))
{
throw new DuplicateNapackException();
}
// Validate user, name and API.
NewNapack newNapack = SerializerExtensions.Deserialize <NewNapack>(this.Context);
newNapack.Validate();
UserIdentifier.VerifyAuthorization(this.Request.Headers.ToDictionary(hdr => hdr.Key, hdr => hdr.Value), Global.NapackStorageManager, newNapack.metadata.AuthorizedUserIds);
NapackSpec generatedApiSpec = NapackAnalyst.CreateNapackSpec(packageName, newNapack.NewNapackVersion.Files);
NapackModule.ValidateDependentPackages(Global.NapackStorageManager, newNapack.NewNapackVersion);
newNapack.NewNapackVersion.UpdateNamespaceOfFiles(packageName, 1);
Global.NapackStorageManager.SaveNewNapack(packageName, newNapack, generatedApiSpec);
return(this.Response.AsJson(new
{
Message = "Created package " + packageName
}, HttpStatusCode.Created));
};
// Updates the definition (metadata) of a Napack package.
Put["/{packageName"] = parameters =>
{
string packageName = parameters.packageName;
NapackMetadata package = Global.NapackStorageManager.GetPackageMetadata(packageName, true);
NewNapackMetadata metadata = SerializerExtensions.Deserialize <NewNapackMetadata>(this.Context);
UserIdentifier.VerifyAuthorization(this.Request.Headers.ToDictionary(hdr => hdr.Key, hdr => hdr.Value), Global.NapackStorageManager, metadata.AuthorizedUserIds);
if (metadata.AuthorizedUserIds.Count == 0)
{
throw new InvalidNapackException("At least one authorized user ID must be provided.");
}
package.AuthorizedUserIds = metadata.AuthorizedUserIds;
package.Description = metadata.Description;
package.MoreInformation = metadata.MoreInformation;
package.Tags = metadata.Tags;
Global.NapackStorageManager.UpdatePackageMetadata(package);
return(this.Response.AsJson(new
{
Message = "Updated package metadata " + packageName
}));
};
// Updates an existing Napack package.
Patch["/{packageName}"] = parameters =>
{
NewNapackVersion newNapackVersion = SerializerExtensions.Deserialize <NewNapackVersion>(this.Context);
newNapackVersion.Validate();
string packageName = parameters.packageName;
NapackMetadata package = Global.NapackStorageManager.GetPackageMetadata(packageName, true);
UserIdentifier.VerifyAuthorization(this.Request.Headers.ToDictionary(hdr => hdr.Key, hdr => hdr.Value), Global.NapackStorageManager, package.AuthorizedUserIds);
// Validate and create a spec for this new version.
NapackSpec newVersionSpec = NapackAnalyst.CreateNapackSpec(packageName, newNapackVersion.Files);
NapackModule.ValidateDependentPackages(Global.NapackStorageManager, newNapackVersion);
// Determine what upversioning will be performed.
int majorVersion = package.Versions.Max(version => version.Key);
int minorVersion = package.Versions[majorVersion].Versions.Max(version => version.Key);
int patchVersion = package.Versions[majorVersion].Versions[minorVersion].Max();
NapackAnalyst.UpversionType upversionType = NapackAnalyst.UpversionType.Patch;
if (newNapackVersion.ForceMajorUpversioning)
{
// Skip analysis as we know we must go to a new major version.
upversionType = NapackAnalyst.UpversionType.Major;
}
else
{
// Perform specification and license analysis.
NapackVersionIdentifier oldVersionId = new NapackVersionIdentifier(packageName, majorVersion, minorVersion, patchVersion);
NapackSpec oldVersionSpec = Global.NapackStorageManager.GetPackageSpecification(oldVersionId);
NapackAnalyst.UpversionType specUpversionType = NapackAnalyst.DeterminedRequiredUpversioning(oldVersionSpec, newVersionSpec);
if (specUpversionType == NapackAnalyst.UpversionType.Major || newNapackVersion.License.NeedsMajorUpversioning(package.GetMajorVersion(majorVersion).License))
{
upversionType = NapackAnalyst.UpversionType.Major;
}
}
if (upversionType == NapackAnalyst.UpversionType.Patch && newNapackVersion.ForceMinorUpversioning)
{
upversionType = NapackAnalyst.UpversionType.Minor;
}
newNapackVersion.UpdateNamespaceOfFiles(packageName, upversionType != NapackAnalyst.UpversionType.Major ? majorVersion : majorVersion + 1);
Global.NapackStorageManager.SaveNewNapackVersion(package, new NapackVersionIdentifier(packageName, majorVersion, minorVersion, patchVersion), upversionType, newNapackVersion, newVersionSpec);
return(this.Response.AsJson(new
{
Message = "Updated package " + packageName,
Major = majorVersion,
Minor = minorVersion,
Patch = patchVersion
}));
};
}
