public SerializedModuleMetadata(IModuleMetadata metadata)
{
Assert(metadata != null);
if (metadata.Module == default || metadata.Version == default)
{
throw new ArgumentException("Neither the metadata's module nor its version must be the respective type's default value.", nameof(metadata));
}
Module = metadata.Module;
Version = metadata.Version;
ReleaseDate = metadata.ReleaseDate;
Name = metadata.Name;
Description = metadata.Description;
Author = metadata.Author;
EntryAssemblyCommand = metadata.EntryAssemblyCommand;
EntryAssemblyArguments = metadata.EntryAssemblyArguments;
foreach (var(module, versionRange) in metadata.Dependencies)
{
if (Dependencies == null)
{
Dependencies = new Dictionary <ModuleIdentifier, ModuleVersionRange>();
}
Dependencies.Add(module, versionRange);
}
}
public ModuleMetadata(IModuleMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
if (metadata.Module == default || metadata.Version == default)
{
throw new ArgumentException("Neither the metadata's module nor its version must be the respective type's default value.", nameof(metadata));
}
Module = metadata.Module;
Version = metadata.Version;
ReleaseDate = metadata.ReleaseDate;
Name = metadata.Name;
Description = metadata.Description;
Author = metadata.Author;
EntryAssemblyCommand = metadata.EntryAssemblyCommand;
EntryAssemblyArguments = metadata.EntryAssemblyArguments;
if (metadata.Dependencies.Any())
{
_dependencies = new ModuleDependencyCollection(metadata.Dependencies);
}
}
public IModule ActivateModule(IModuleMetadata metadata)
{
var modules = _container.GetExports<IModule, IModuleMetadata>();
var module = (from m in modules
where m.Metadata.Name.Equals(metadata.Name)
select m.Value).FirstOrDefault();
if (module != null)
{
module.Initialize(this.ServicePool);
}
return module;
}
internal ModuleRelease(Module module, IModuleMetadata metadata, IModuleSource moduleSource)
{
Assert(module != null);
Assert(metadata != null);
Assert(moduleSource != null);
_sources = new HashSet <Snapshot <IModuleSource> > {
new Snapshot <IModuleSource>(moduleSource)
};
_metadata = new SerializedModuleMetadata(metadata);
Module = module;
}
private Task <Process> StartProcessAsync(IModuleMetadata moduleMetadata,
CancellationToken cancellation)
{
Assert(moduleMetadata != null);
var entryAssemblyCommand = ReplaceMetadataConstants(moduleMetadata.EntryAssemblyCommand);
var entryAssemblyArguments = ReplaceMetadataConstants(moduleMetadata.EntryAssemblyArguments);
var processStartInfo = BuildProcessStartInfo(entryAssemblyCommand, entryAssemblyArguments);
var process = Process.Start(processStartInfo);
return(Task.FromResult(process));
}
public IModule ActivateModule(IModuleMetadata metadata)
{
var modules = _container.GetExports <IModule, IModuleMetadata>();
var module = (from m in modules
where m.Metadata.Name.Equals(metadata.Name)
select m.Value).FirstOrDefault();
if (module != null)
{
module.Initialize(this.ServicePool);
}
return(module);
}
private static async Task WritePackageToStreamAsync(IModuleMetadata metadata, string inputDir, MemoryStream stream, CancellationToken cancellation)
{
using (var archive = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
{
await PackDirectoryAsync(archive, inputDir, cancellation);
var manifestEntry = archive.CreateEntry("module.json");
using (var manifestEntryStream = manifestEntry.Open())
{
await _metadataWriter.WriteMetadataAsync(manifestEntryStream, metadata, cancellation);
}
}
}
private ModuleEntry CreateModuleEntry(IModuleInfo moduleInfo, IModuleMetadata metadata)
{
return(new ModuleEntry()
{
Name = metadata.Name,
Author = metadata.Author,
Description = metadata.Description,
Version = metadata.Version,
ModuleLocation = moduleInfo.Ref,
Views = GetViews <ModuleViewAttribute>(moduleInfo),
SettingViews = GetViews <ModuleSettingsViewAttribute>(moduleInfo)
});
}
public IModule CreateModule(IModuleMetadata metadata)
{
var modules = _container.GetExports<IModule, IModuleMetadata>();
foreach (var mod in modules)
{
if (mod.Metadata.Name.Equals(metadata.Name))
{
var module = mod.Value;
module.Initialize(ServicePool.Current);
return module;
}
}
return null;
}
private void WriteMetadataInternal(MemoryStream stream, IModuleMetadata metadata)
{
var serializer = JsonSerializer.CreateDefault();
using (var streamWriter = new StreamWriter(stream, Encoding.UTF8, bufferSize: 4096, leaveOpen: true))
using (var writer = new JsonTextWriter(streamWriter))
{
try
{
var serializedMetadata = (metadata as SerializedModuleMetadata) ?? new SerializedModuleMetadata(metadata);
serializer.Serialize(writer, serializedMetadata, typeof(SerializedModuleMetadata));
}
catch (JsonSerializationException exc)
{
throw new ModuleMetadataFormatException("The module metadata is malformed.", exc);
}
}
}
public Module(IModuleMetadata metadata, IModuleSource moduleSource) : base(metadata.Module)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
if (moduleSource == null)
{
throw new ArgumentNullException(nameof(moduleSource));
}
_releases = new Dictionary <ModuleVersion, ModuleRelease>()
{
[metadata.Version] = new ModuleRelease(this, metadata, moduleSource)
};
Notify(new ModuleReleaseAdded(Id, metadata.Version));
}
public SerializedModuleMetadata(IModuleMetadata moduleMetadata)
{
if (moduleMetadata == null)
{
throw new ArgumentNullException(nameof(moduleMetadata));
}
foreach (var item in moduleMetadata.Dependencies)
{
Dependencies.Add(item.Module, item.VersionRange);
}
Author = moduleMetadata.Author;
Description = moduleMetadata.Description;
EntryAssemblyArguments = moduleMetadata.EntryAssemblyArguments;
EntryAssemblyCommand = moduleMetadata.EntryAssemblyCommand;
Module = moduleMetadata.Module;
Name = moduleMetadata.Name;
ReleaseDate = moduleMetadata.ReleaseDate;
Version = moduleMetadata.Version;
}
public async Task WriteMetadataAsync(Stream stream, IModuleMetadata metadata, CancellationToken cancellation)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
using (var memoryStream = new MemoryStream())
{
WriteMetadataInternal(memoryStream, metadata);
memoryStream.Position = 0;
using (stream)
{
await memoryStream.CopyToAsync(stream, bufferSize : 4096, cancellation);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="metadata"></param>
public UserControlMetaDataViewModel(IModuleMetadata metadata)
{
Metadata = metadata;
}
protected internal virtual PackageBuilder BuildManifest(IModuleMetadata module, IFileSystem moduleRoot)
{
string nuspecName = String.Format("{0}.nuspec", module.Name);
PackageBuilder builder;
if (moduleRoot.FileExists(nuspecName))
{
using (Stream strm = moduleRoot.OpenFile(nuspecName))
{
builder = OpenManifest(module.ModuleBase, strm);
}
}
else
{
// Create the package
builder = new PackageBuilder();
builder.Id = module.Name;
builder.Version = new SemanticVersion(module.Version);
if (!String.IsNullOrEmpty(module.Author))
{
builder.Authors.AddRange(module.Author.Split(',').Select(s => s.Trim()));
}
else
{
builder.Authors.Add(Environment.UserName);
}
builder.Description = module.Description;
}
// Add all files under the module base if there aren't any already
if (!builder.Files.Any())
{
foreach (var file in moduleRoot.GetAllFiles())
{
builder.Files.Add(new PhysicalPackageFile()
{
SourcePath = moduleRoot.GetFullPath(file),
TargetPath = file
});
}
}
// Set overrides
builder.Description = Description ?? builder.Description;
builder.Id = PackageId ?? builder.Id;
builder.Version = Version ?? builder.Version;
if (Authors != null)
{
builder.Authors.Clear();
builder.Authors.AddRange(Authors);
}
builder.Copyright = Copyright;
builder.IconUrl = String.IsNullOrEmpty(IconUrl) ? null : new Uri(IconUrl);
builder.Language = Language;
builder.LicenseUrl = String.IsNullOrEmpty(LicenseUrl) ? null : new Uri(LicenseUrl);
if (Owners != null)
{
builder.Owners.Clear();
builder.Owners.AddRange(Owners);
}
builder.ProjectUrl = String.IsNullOrEmpty(ProjectUrl) ? null : new Uri(ProjectUrl);
builder.ReleaseNotes = ReleaseNotes;
builder.RequireLicenseAcceptance = RequireLicenseAcceptance.IsPresent;
builder.Summary = Summary;
if (Tags != null)
{
builder.Tags.Clear();
builder.Tags.AddRange(Tags);
}
builder.Title = Title;
return builder;
}
