public void zip_packager_unzips_the_file_properly()
{
string zipFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"res\test.zip");
var modulePackage = new ModulePackage
{
ModuleManifest =
new ModuleManifest(),
ModuleZip =
File.ReadAllBytes(zipFile)
};
// get the zip packager
IModulePackager packager = new ModulePackager();
// set up directory
string targetDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Updater\Zip\");
if (Directory.Exists(targetDirectory))
{
Directory.Delete(targetDirectory, true);
}
Directory.CreateDirectory(targetDirectory);
// perform test
packager.PerformUpdates(targetDirectory, modulePackage);
// assert test
Assert.IsTrue(File.Exists(Path.Combine(targetDirectory, "readme")));
}
public void preparing_updates_calls_proper_subsystems_publishes_msg_at_the_end()
{
// return the same - might stop working if some of the code is gonna be put to verify download };
var modulePacakge = new ModulePackage {
ModuleManifest = _moduleManifest
};
ModulesRepository.Setup(x => x.GetModule(It.Is <string>(y => y == _moduleName)))
.Returns(modulePacakge)
.Verifiable("This package should be downloaded");
EventAggregator.Setup(x => x.Publish(It.IsAny <NomadUpdatesReadyMessage>()))
.Callback <NomadUpdatesReadyMessage>(msg =>
{
Assert.IsFalse(msg.Error);
Assert.AreEqual(1, msg.ModuleManifests.Count);
Assert.AreSame(modulePacakge.ModuleManifest,
msg.ModuleManifests[0]);
})
.Returns(null)
.Verifiable("This message should be published upon exit");
NomadUpdater.PrepareUpdate(new List <ModuleManifest>()
{
_moduleManifest
});
EventAggregator.Verify();
ModulesRepository.Verify();
Assert.AreEqual(UpdaterStatus.Prepared, NomadUpdater.Status);
}
public void PerformUpdates(string targetDirectory, ModulePackage modulePackage)
{
using (ZipFile file = ZipFile.Read(modulePackage.ModuleZip))
{
file.ExtractAll(targetDirectory, ExtractExistingFileAction.OverwriteSilently);
}
}
void Write(ModulePackage package)
{
foreach (var kv in package.Modules)
{
if (kv.Value.ParseErrors.Count < 1)
{
continue;
}
hadErrors = true;
sw.WriteLine(kv.Value.ModuleName + "\t\t(" + kv.Value.FileName + ")");
foreach (var err in kv.Value.ParseErrors)
{
sw.WriteLine(string.Format("\t\t{0}\t{1}\t{2}", err.Location.Line, err.Location.Column, err.Message));
}
sw.WriteLine();
}
sw.Flush();
foreach (var kv in package.Packages)
{
Write(kv.Value);
}
}
public static bool AddOrUpdateModule(DModule module, out ModulePackage pack)
{
pack = null;
if (module == null || string.IsNullOrEmpty(module.ModuleName))
{
return(false);
}
pack = GetPackage(module, true);
if (pack == null)
{
return(false);
}
var file = module.FileName;
// Check if a module is already in the file lookup
DModule oldMod;
if (file != null && fileLookup.TryGetValue(file, out oldMod))
{
RemoveModule(oldMod);
oldMod = null;
}
pack.AddModule(module);
fileLookup.Add(file, module);
return(true);
}
public virtual IEnumerable<DModule> PrefilterSubnodes(ModulePackage pack, out ModulePackage[] subPackages)
{
subPackages = pack.GetPackages();
if(subPackages.Length == 0)
subPackages = null;
var mods = pack.GetModules();
return mods.Length != 0 ? mods : null;
}
public void creates_directory_when_no_manifest_provided()
{
// prepare some package
const string moduleString = "module1";
ModulePackage modulePackage = GetPackageWithName(moduleString);
var name = _moduleFinder.FindDirectoryForPackage(_testDirectory, modulePackage);
Assert.IsTrue(Directory.Exists(name),"The directory does not exisits");
}
public static DModule GetModule(string basePath, string moduleName, out ModulePackage pack)
{
pack = GetPackage(basePath, ModuleNameHelper.ExtractPackageName(moduleName));
if (pack == null)
{
return(null);
}
return(pack.GetModule(ModuleNameHelper.ExtractModuleName(moduleName)));
}
public static void EnumPackagesRecursively(ModulePackage pack, List <ModulePackage> list)
{
if (pack != null)
{
foreach (var kv in pack.packages)
{
list.Add(kv.Value);
EnumPackagesRecursively(kv.Value, list);
}
}
}
public static void EnumModulesRecursively(ModulePackage pack, List <DModule> list)
{
if (pack != null)
{
list.AddRange(pack.modules.Values);
foreach (var sub in pack.packages)
{
EnumModulesRecursively(sub.Value, list);
}
}
}
public virtual IEnumerable <DModule> PrefilterSubnodes(ModulePackage pack, out ModulePackage[] subPackages)
{
subPackages = pack.GetPackages();
if (subPackages.Length == 0)
{
subPackages = null;
}
var mods = pack.GetModules();
return(mods.Length != 0 ? mods : null);
}
private static ModulePackage GetPackageWithName(string moduleString)
{
var package = new ModulePackage
{
ModuleZip = new byte[] {0xFf},
ModuleManifest = new ModuleManifest
{
ModuleName = moduleString,
}
};
return package;
}
public override IEnumerable<DModule> PrefilterSubnodes(ModulePackage pack, out ModulePackage[] subPackages)
{
var subPack = pack.GetPackage(filterHash);
if(subPack != null)
subPackages = new[]{ subPack };
else
subPackages = null;
var ast = pack.GetModule(filterHash);
if(ast != null)
return new[]{ast};
return null;
}
/// <summary>
///
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
/// TODO: this method probably should not be public!
public bool AddModule(ModulePackage module)
{
try
{
var name = module.ModuleManifest.ModuleName;
var manifestFile = GetManifestPath(name);
var zipFile = GetZipPath(name);
var manifestData = XmlSerializerHelper.Serialize(module.ModuleManifest);
File.WriteAllBytes(manifestFile, manifestData);
File.WriteAllBytes(zipFile, module.ModuleZip);
return(true);
}
catch
{
return(false);
}
}
void Write(ModulePackage package)
{
foreach (var kv in package.Modules)
{
if (kv.Value.ParseErrors.Count < 1)
continue;
hadErrors = true;
sw.WriteLine(kv.Value.ModuleName + "\t\t(" + kv.Value.FileName + ")");
foreach (var err in kv.Value.ParseErrors)
sw.WriteLine(string.Format("\t\t{0}\t{1}\t{2}", err.Location.Line, err.Location.Column, err.Message));
sw.WriteLine();
}
sw.Flush();
foreach (var kv in package.Packages)
Write(kv.Value);
}
public string FindDirectoryForPackage(string targetDirectory, ModulePackage modulePackage)
{
if (string.IsNullOrEmpty(targetDirectory) || modulePackage == null)
{
throw new ArgumentException("Bot arguments must be provided");
}
// get module name from package
var moduleName = modulePackage.ModuleManifest.ModuleName;
// founded manifest
string manifestDirectory = string.Empty;
// search directory for the module with such name
var directoryInfo = new DirectoryInfo(targetDirectory);
const string searchPattern = "*" + ModuleManifest.ManifestFileNameSuffix;
var files = directoryInfo.GetFiles(searchPattern, SearchOption.AllDirectories);
foreach (var manifestFile in files)
{
// get manifest out of the file
var fileData = File.ReadAllBytes(manifestFile.FullName);
var manifest = XmlSerializerHelper.Deserialize <ModuleManifest>(fileData);
// check the names with the manifest)
if (manifest.ModuleName.Equals(moduleName))
{
manifestDirectory = manifestFile.DirectoryName;
break;
}
}
// if no manifest directory found then make the new folder containing the new module
if (string.IsNullOrEmpty(manifestDirectory))
{
manifestDirectory = Path.Combine(targetDirectory, moduleName);
Directory.CreateDirectory(manifestDirectory);
}
return(manifestDirectory);
}
void ParseThread()
{
var file = "";
ModulePackage pack = null;
while (queue.Count != 0)
{
lock (queue)
{
if (queue.Count == 0)
{
return;
}
var kv = queue.Pop();
file = kv.Key;
pack = kv.Value;
}
try
{
// If no debugger attached, save time + memory by skipping function bodies
var ast = DParser.ParseFile(file, !Debugger.IsAttached);
if (!(pack is RootPackage))
{
ast.ModuleName = pack.Path + "." + Path.GetFileNameWithoutExtension(file);
}
ast.FileName = file;
pack.Modules[ModuleNameHelper.ExtractModuleName(ast.ModuleName)] = ast;
}
catch (Exception ex)
{
LastException = ex;
}
}
}
public string FindDirectoryForPackage(string targetDirectory, ModulePackage modulePackage)
{
if (string.IsNullOrEmpty(targetDirectory) || modulePackage == null)
throw new ArgumentException("Bot arguments must be provided");
// get module name from package
var moduleName = modulePackage.ModuleManifest.ModuleName;
// founded manifest
string manifestDirectory = string.Empty;
// search directory for the module with such name
var directoryInfo = new DirectoryInfo(targetDirectory);
const string searchPattern = "*" + ModuleManifest.ManifestFileNameSuffix;
var files = directoryInfo.GetFiles(searchPattern, SearchOption.AllDirectories);
foreach (var manifestFile in files)
{
// get manifest out of the file
var fileData = File.ReadAllBytes(manifestFile.FullName);
var manifest = XmlSerializerHelper.Deserialize<ModuleManifest>(fileData);
// check the names with the manifest)
if (manifest.ModuleName.Equals(moduleName))
{
manifestDirectory = manifestFile.DirectoryName;
break;
}
}
// if no manifest directory found then make the new folder containing the new module
if (string.IsNullOrEmpty(manifestDirectory))
{
manifestDirectory = Path.Combine(targetDirectory, moduleName);
Directory.CreateDirectory(manifestDirectory);
}
return manifestDirectory;
}
internal static bool RemoveModule(DModule ast, ModulePackage pack)
{
if (ast == null || pack == null)
{
return(false);
}
fileLookup.Remove(ast.FileName);
if (!pack.RemoveModule(ast.ModuleName ?? ""))
{
return(false);
}
ModulePackage parPack;
if (pack.IsEmpty && (parPack = pack.Parent) != null)
{
parPack.RemovePackage(pack.Name);
}
return(true);
}
public override IEnumerable <DModule> PrefilterSubnodes(ModulePackage pack, out ModulePackage[] subPackages)
{
var subPack = pack.GetPackage(filterHash);
if (subPack != null)
{
subPackages = new[] { subPack }
}
;
else
{
subPackages = null;
}
var ast = pack.GetModule(filterHash);
if (ast != null)
{
return new[] { ast }
}
;
return(null);
}
bool _remFromPack(ModulePackage pack, IAbstractSyntaxTree ast)
{
if (pack.Modules.ContainsValue(ast))
{
foreach (var kv in pack.Modules)
{
if (kv.Value == ast)
{
pack.Modules.Remove(kv.Key);
return(true);
}
}
}
foreach (var p in pack.Packages)
{
if (_remFromPack(p.Value, ast))
{
return(true);
}
}
return(false);
}
public static DModule GetModule (string basePath, string moduleName, out ModulePackage pack)
{
pack = GetPackage (basePath, ModuleNameHelper.ExtractPackageName (moduleName));
if (pack == null)
return null;
return pack.GetModule (ModuleNameHelper.ExtractModuleName (moduleName));
}
public static string ContaningModules(this ModulePackage me) => string.Join(',', me.Modules.Select(m => m.FullName));
public PackageSymbol(ModulePackage pack,ISyntaxRegion td)
: base(td)
{
this.Package = pack;
}
public PackageSymbol(ModulePackage pack, ISyntaxRegion td) : base(td)
{
this.Package = pack;
}
public override IEnumerable<DModule> PrefilterSubnodes(ModulePackage pack, out ModulePackage[] subPackages)
{
subPackages = null;
return null;
}
public static bool AddOrUpdateModule (DModule module, out ModulePackage pack)
{
pack = null;
if (module == null || string.IsNullOrEmpty (module.ModuleName))
return false;
pack = GetPackage (module, true);
if (pack == null)
return false;
var file = module.FileName;
// Check if a module is already in the file lookup
DModule oldMod;
if (file != null && fileLookup.TryGetValue (file, out oldMod)) {
RemoveModule (oldMod);
oldMod = null;
}
pack.AddModule (module);
fileLookup.Add (file, module);
return true;
}
public static void EnumPackagesRecursively(ModulePackage pack, List<ModulePackage> list)
{
if (pack != null)
foreach (var kv in pack.packages)
{
list.Add(kv.Value);
EnumPackagesRecursively(kv.Value, list);
}
}
/// <summary>
/// Adds <see cref="LayoutModule">modules</see> and <see cref="LayoutService">stations</see> in a <see cref="ModulePackage"/> to a <see cref="Layout"/>
/// </summary>
/// <param name="principal"></param>
/// <param name="participantId"></param>
/// <param name="layoutId"></param>
/// <param name="package"></param>
/// <returns></returns>
public async Task <(int Count, string Message)> AddPackageModulesAsync(ClaimsPrincipal?principal, int participantId, int layoutId, ModulePackage package)
{
if (principal.IsAuthenticated())
{
var result = package.Modules.Count();
using var dbContext = Factory.CreateDbContext();
var participant = await dbContext.MeetingParticipants.Include(mp => mp.Meeting).SingleOrDefaultAsync(mp => mp.Id == participantId);
if (participant is null)
{
return(-1, Resources.Strings.NotFound);
}
foreach (var module in package.Modules)
{
var existing = await dbContext.LayoutModules.SingleOrDefaultAsync(lm => lm.ModuleId == module.Id);
if (existing is null)
{
var addedModule = new LayoutModule {
LayoutId = layoutId, ModuleId = module.Id, ParticipantId = participant.Id, RegisteredTime = TimeProvider.Now
};
dbContext.LayoutModules.Add(addedModule);
await AddLayoutStationAsync(dbContext, participantId, layoutId, module);
await dbContext.SaveChangesAsync();
}
else
{
result--;
}
}
return(result == 0 ? (-1, Resources.Strings.NoModification) : (1, Resources.Strings.Saved));
public static void EnumModulesRecursively(ModulePackage pack, List<DModule> list)
{
if (pack != null)
{
list.AddRange(pack.modules.Values);
foreach (var sub in pack.packages)
EnumModulesRecursively(sub.Value, list);
}
}
/// <summary>
/// Adds <see cref="LayoutModule">modules</see> and <see cref="LayoutService">stations</see> in a <see cref="ModulePackage"/> to a <see cref="Layout"/>
/// </summary>
/// <param name="principal"></param>
/// <param name="participantId"></param>
/// <param name="layoutId"></param>
/// <param name="package"></param>
/// <returns></returns>
public async Task <(int Count, string Message)> AddPackageModulesAsync(ClaimsPrincipal?principal, int layoutParticipantId, ModulePackage package)
{
if (principal.IsAuthenticated())
{
var result = package.Modules.Count();
using var dbContext = Factory.CreateDbContext();
var participant = await dbContext.LayoutParticipants
.SingleOrDefaultAsync(lp => lp.Id == layoutParticipantId);
if (participant is null)
{
return(-1, Resources.Strings.NotFound);
}
foreach (var module in package.Modules)
{
var existing = await dbContext.LayoutModules.SingleOrDefaultAsync(lm => lm.ModuleId == module.Id && lm.LayoutParticipantId == layoutParticipantId);
if (existing is null)
{
var layoutModule = new LayoutModule {
ModuleId = module.Id, LayoutParticipantId = participant.Id, RegisteredTime = TimeProvider.Now
};
if (module.StationId.HasValue)
{
var layoutStation = new LayoutStation {
StationId = module.StationId.Value
};
layoutModule.LayoutStation = layoutStation;
}
dbContext.LayoutModules.Add(layoutModule);
await dbContext.SaveChangesAsync();
}
else
{
result--;
}
}
return(result == 0 ? (-1, Resources.Strings.NoModification) : (1, Resources.Strings.Saved));
}
return(0, Resources.Strings.NotAuthorized);
}
internal static bool RemoveModule (DModule ast, ModulePackage pack)
{
if (ast == null || pack == null)
return false;
fileLookup.Remove (ast.FileName);
if (!pack.RemoveModule (ast.ModuleName ?? ""))
return false;
ModulePackage parPack;
if (pack.IsEmpty && (parPack = pack.Parent) != null)
parPack.RemovePackage (pack.Name);
return true;
}
public override IEnumerable <DModule> PrefilterSubnodes(ModulePackage pack, out ModulePackage[] subPackages)
{
subPackages = null;
return(null);
}
