public VFSDirectory(string repositoryUri, string lockUri)
{
try
{
fsManager = VFS.getManager();
directory = fsManager.resolveFile(repositoryUri);
if (!directory.exists())
{
directory.createFolder();
}
locker = fsManager.resolveFile(lockUri);
if (!locker.exists())
{
locker.createFolder();
}
}
catch (System.IO.IOException ioe)
{
throw ioe;
}
catch (Exception e)
{
throw e;
}
}
public void Detect()
{
FileSystemManager fsm = new FileSystemManager();
MemoryStream shortStream = new MemoryStream(new byte[5]);
Assert.AreEqual(0, fsm.DetectFileSystems(shortStream).Length);
MemoryStream longStream = new MemoryStream(new byte[100000]);
Assert.AreEqual(0, fsm.DetectFileSystems(longStream).Length);
}
public void ReturnAvailableFilesTest()
{
FileSystemManager fs = new FileSystemManager();
var path = @"L:\";
var result = fs.ReturnAvailableFiles(path);
foreach (var item in result)
{
Console.WriteLine(item);
}
Assert.IsNotNull(result);
}
private void AddSteps()
{
var fileSystemManager = new FileSystemManager();
_steps.Add(new ExtractPackageStep(_parameters, fileSystemManager, Logger));
_steps.Add(new BackupStep(new DateProvider(), _parameters, Logger));
_steps.Add(new ClearDestinationFolderStep(_parameters, Logger));
_steps.Add(new DeployFilesStep(fileSystemManager, _parameters, Logger));
_steps.Add(new MigrateDatabaseStep(_parameters, fileSystemManager, Logger));
_steps.Add(new ReplaceWebConfigStep(_parameters, Logger));
_steps.Add(new ResetFileAttributesStep(_parameters, Logger));
_steps.Add(new CleanUpStep(fileSystemManager, _parameters, Logger));
}
internal FileSystemInfo(FileSystemManager parent, string name, string path, bool loadDirectories = false, bool loadFiles = false)
{
Parent = parent;
Name = name;
Path = path;
Drives = new DrvInfo[0];
Directories = new FolderInfo[0];
Files = new FiInfo[0];
if (loadDirectories)
LoadDirectories();
if (loadFiles)
LoadFiles();
}
private static void MessageHandler(object args)
{
try
{
StorageEvent ev = args as StorageEvent;
if (ev == null)
{
return;
}
lock (_volumes)
{
if (ev.EventType == StorageEventType.Insert)
{
VolumeInfo volume = new VolumeInfo(ev.Handle);
_volumes.Add(volume);
if (Insert != null)
{
MediaEventArgs mediaEventArgs = new MediaEventArgs(volume, ev.Time);
Insert(null, mediaEventArgs);
}
}
else if (ev.EventType == StorageEventType.Eject)
{
VolumeInfo volumeInfo = RemoveVolume(ev.Handle);
if (volumeInfo != null)
{
FileSystemManager.ForceRemoveNameSpace(volumeInfo.Name);
if (Eject != null)
{
MediaEventArgs mediaEventArgs = new MediaEventArgs(new VolumeInfo(volumeInfo), ev.Time);
Eject(null, mediaEventArgs);
}
}
}
}
}
finally
{
// get rid of this timer
_events.Dequeue();
}
}
public static void CopyDirectoryWithProgress(FileSystemManager fs, string sourcePath, string destPath,
CreateFileOptions options = CreateFileOptions.None, IProgressReport logger = null)
{
try
{
logger?.SetTotal(GetTotalSize(fs, sourcePath));
CopyDirectoryWithProgressInternal(fs, sourcePath, destPath, options, logger);
}
finally
{
logger?.SetTotal(0);
}
}
public string ReadAllText(PathDescriptor path)
{
string location = path.ToFileSystemFormat();
if (File.Exists(location))
{
return(FileSystemManager.ReadAllText(location));
}
using (var webClient = WebClientFactory.CreateWebClient())
{
return(webClient.DownloadString(path));
}
}
/// <summary>
/// Registers the types provided by an assembly to all relevant DiscUtils managers
/// </summary>
/// <param name="assembly"></param>
public static void RegisterAssembly(Assembly assembly)
{
lock (_alreadyLoaded)
{
if (!_alreadyLoaded.Add(assembly.FullName))
{
return;
}
FileSystemManager.RegisterFileSystems(assembly);
VirtualDiskManager.RegisterVirtualDiskTypes(assembly);
VolumeManager.RegisterLogicalVolumeFactory(assembly);
}
}
public static void SerializeObjectToBinaryFile(object serializableObject, string outputFileFullPath)
{
FileSystemManager mgr = new FileSystemManager();
if (mgr.FileExists(outputFileFullPath))
{
mgr.DeleteFile(outputFileFullPath);
}
using (Stream stream = new FileStream(outputFileFullPath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
{
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, serializableObject);
stream.Close();
}
}
public static IContext run(string rootDirectory)
{
IPathBuilder pathBuilder = getPathBuilder(rootDirectory);
FileSystemInstaller.run(pathBuilder);
IFileSystemManager fileSystemManager = new FileSystemManager(pathBuilder);
string databaseFilePath = pathBuilder.getPath(SpecialFile.DATABASE);
IDatabaseManager databaseManager = DatabaseInstaller.run(databaseFilePath);
IRecordIdMap recordIdMap = new RecordIdMap(fileSystemManager, true);
IContext context = new Context(rootDirectory);
return(context);
}
internal DiscFileSystem GetFileSystem(VolumeInfo volInfo)
{
DiscFileSystem result;
if (!_fsCache.TryGetValue(volInfo.Identity, out result))
{
FileSystemManager fsmgr = new FileSystemManager();
FileSystemInfo[] fsInfo = fsmgr.DetectFileSystems(volInfo);
if (fsInfo != null && fsInfo.Length > 0)
{
result = fsInfo[0].Open(volInfo);
_fsCache.Add(volInfo.Identity, result);
}
}
return result;
}
static void Main(string[] args)
{
ICarrierStreamFactory factory = new CarrierStreamFactory(CARRIER_STREAM_PROVIDER_DIRECTORY);
using (Stream carrierClusterStream = factory.BuildClusterStream("Basic",
new OneKeySequence(), GetClusterFiles()))
{
DiscUtils.FileSystemInfo[] fsInfos = FileSystemManager.DetectDefaultFileSystems(carrierClusterStream);
if (fsInfos != null && fsInfos.Count() > 0)
{
using (FatFileSystem fs = (FatFileSystem)fsInfos[0].Open(carrierClusterStream))
{
foreach (DiscDirectoryInfo info in fs.Root.GetDirectories())
{
Console.WriteLine(info.FullName);
}
DisplayDiskSize(fs);
}
}
else
{
carrierClusterStream.Position = 0;
Geometry geometry = Geometry.FromCapacity(carrierClusterStream.Length - 512);
using (FatFileSystem fs = FatFileSystem.FormatPartition(carrierClusterStream,
string.Empty, geometry, 0, geometry.TotalSectors, 13))
{
DateTime start = DateTime.Now;
for (int i = 0; i < 511; ++i)
{
fs.CreateDirectory(@"D" + i);
}
Console.WriteLine("511 Directories created in {0}", DateTime.Now - start);
foreach (DiscDirectoryInfo info in fs.Root.GetDirectories())
{
Console.WriteLine(info.FullName);
}
DisplayDiskSize(fs);
}
}
}
Console.ReadLine();
}
private async Task DownloadItemImplAsync(
SemaphoreSlim downloadThrottle,
ContainerItem ticketedItem,
string downloadPath,
CancellationToken cancellationToken)
{
try
{
lock (_lock)
{
ExecutionLogger.Debug(StringUtil.Format("Acquiring semaphore to download file {0}", downloadPath));
}
await downloadThrottle.WaitAsync().ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
return;
}
// Download the file content to a temp file on the same drive.
// Assumption: the build won't produce files ending in .download.
string tmpDownloadPath = downloadPath + ".download";
FileSystemManager.EnsureParentDirectory(tmpDownloadPath);
FileSystemManager.DeleteFile(downloadPath);
lock (_lock)
{
ExecutionLogger.Output(StringUtil.Loc("RMDownloadStartDownloadOfFile", downloadPath));
}
await GetFileAsync(ticketedItem, tmpDownloadPath, cancellationToken).ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
return;
}
// With the content successfully downloaded, move the tmp file to its permanent location.
FileSystemManager.MoveFile(tmpDownloadPath, downloadPath);
}
finally
{
downloadThrottle.Release();
}
}
private string Transform(MasterDataKeyValue bundle, string localHost, string source, string dist)
{
FileSystemManager.CreatDirectoryIfNotExist(AuthorizeManager.AuthorizeActionOnPath
(dist.Substring(0, dist.LastIndexOf("/", StringComparison.Ordinal)),
ActionKey.WriteToDisk));
var bundlePath = source.ToLower().Replace("~/", "");
var bundleOption = new List <BundleOption>
{
new BundleOption()
{
Url = "~/BrowsersCodeOutPut/" + bundle.Guid + "/" + bundle.Version + "/" + bundlePath,
Sources = new List <string>()
{
source
}
}
};
foreach (var option in bundleOption)
{
foreach (var sourceUrl in option.Sources)
{
AuthorizeManager.AuthorizeActionOnPath(sourceUrl, ActionKey.ReadFromDisk);
}
}
_bundleManager.AddBundle(bundleOption);
var bundleNmae = "~/BrowsersCodeOutPut/" + bundle.Guid + "/" + bundle.Version + "/" + bundlePath
.Replace(".", "-");
var url = bundleNmae.Replace("~", localHost);
string contents;
using (var wc = new System.Net.WebClient())
{
wc.Encoding = Encoding.UTF8;
contents = wc.DownloadString(url);
}
_bundleManager.RemoveBundle(bundleNmae);
return(contents);
}
public void ReturnCountTest()
{
// create test folder
// create test file/files with different size
// test method
if (!Directory.Exists(@"C:\Users\<!!!!>\Desktop\TestFolder\"))
{
Directory.CreateDirectory(@"C:\Users\<!!!!>\Desktop\TestFolder\");
File.Create(@"C:\Users\<!!!!>\Desktop\TestFolder\testfile.txt");
FileInfo fi = new FileInfo(@"C:\Users\<!!!!>\Desktop\TestFolder\testfile.txt");
var fileSize = fi.Length;
FileSystemManager fs = new FileSystemManager();
var count = fs.ReturnCount(@"C:\Users\<!!!!>\Desktop\TestFolder", p => p.Length == fileSize);
Assert.IsTrue(count == 1);
}
}
public static void Default_0_GetDiskSpaceFor_WithNonExistPath()
{
if (!Runtime.Platform.IsWindows)
{
return;
}
var directoryInfo = new DirectoryInfo("R:\\");
Assert.False(directoryInfo.Exists);
var diskSpaceInfo = FileSystemManager.GetDiskSpaceFor(directoryInfo);
Assert.NotNull(diskSpaceInfo);
Assert.False(string.IsNullOrWhiteSpace(diskSpaceInfo.Path));
Assert.True(diskSpaceInfo.FreeOfBytes == -1);
Assert.True(diskSpaceInfo.TotalOfBytes == -1);
Assert.True(diskSpaceInfo.TotalFreeOfBytes == -1);
}
public void TestInitialize()
{
if (!this.Initialized)
{
MasterLog.Initialize();
Loader load = new Loader();
string msg = string.Empty;
SettingsManager.Initialize();
FileSystemManager.Initialize();
load.LoadAll(ref msg, new List <IGameLoader>
{
new ProtoTypeLoader(),
new ProtoManager(),
});
this.Initialized = true;
}
}
/// <summary>
/// 上传
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnUpload_Click(object sender, EventArgs e)
{
if (FileSystemManager.IsSafeName(FileUpload1.FileName))
{
if (FileUpload1.HasFile)
{
string path = lblCurrentPath.Text + "\\";
path += Path.GetFileName(FileUpload1.FileName);
FileUpload1.PostedFile.SaveAs(path);
}
}
else
{
ShowErr("非法文件格式！");
}
BindGrid(lblCurrentPath.Text);
}
static void Main(string[] args)
{
SetupHelper.RegisterAssembly(typeof(Program).Assembly);
MemoryStream dummyFileSystemData = new MemoryStream(Encoding.ASCII.GetBytes("MYFS"));
VirtualDisk dummyDisk = new DiscUtils.Raw.Disk(dummyFileSystemData, Ownership.None);
VolumeManager volMgr = new VolumeManager(dummyDisk);
VolumeInfo volInfo = volMgr.GetLogicalVolumes()[0];
DiscUtils.FileSystemInfo fsInfo = FileSystemManager.DetectFileSystems(volInfo)[0];
DiscFileSystem fs = fsInfo.Open(volInfo);
ShowDir(fs.Root, 4);
}
private void RetrieveModel(Action <SettingsModel> modelSetter)
{
SettingsModel model = null;
try
{
model = FileSystemManager.ReadLocalSetting <SettingsModel>(this.key);
}
catch (Exception ex)
{
DependencyService.Get <Infrastructure.ILoggingService>().Error(ex);
}
Core.CoreHelpers.ValidateDefined(model, "SettingsModel is required");
modelSetter(model);
}
protected override void DoRun()
{
VolumeManager volMgr = new VolumeManager();
foreach (string disk in _diskFiles.Values)
{
volMgr.AddDisk(VirtualDisk.OpenDisk(disk, _diskType.IsPresent ? _diskType.Value : null, FileAccess.Read, UserName, Password));
}
VolumeInfo volInfo = null;
if (!string.IsNullOrEmpty(VolumeId))
{
volInfo = volMgr.GetVolume(VolumeId);
}
else if (Partition >= 0)
{
volInfo = volMgr.GetPhysicalVolumes()[Partition];
}
else
{
volInfo = volMgr.GetLogicalVolumes()[0];
}
DiscUtils.FileSystemInfo fsInfo = FileSystemManager.DetectDefaultFileSystems(volInfo)[0];
using (DiscFileSystem fs = fsInfo.Open(volInfo))
{
using (Stream source = fs.OpenFile(_inFilePath.Value, FileMode.Open, FileAccess.Read))
{
using (FileStream outFile = new FileStream(_outFilePath.Value, FileMode.Create, FileAccess.ReadWrite))
{
PumpStreams(source, outFile);
}
if (_hexDump.IsPresent)
{
source.Position = 0;
HexDump.Generate(source, Console.Out);
}
}
}
}
public static MoversAndShakersServerInfoDataModel ReadRegisteredDiscordGuilds()
{
FileSystemManager fileSystem = new FileSystemManager();
string FilePath = Path.Combine(serverInfoLocation, registeredServerNames);
if (fileSystem.IsFileExists(registeredServerNames, serverInfoLocation))
{
return(JsonConvert.DeserializeObject <MoversAndShakersServerInfoDataModel>(fileSystem.ReadJsonFileFromSpecificLocation(registeredServerNames, serverInfoLocation)));
}
else
{
return(new MoversAndShakersServerInfoDataModel
{
ListOfRegisteredDiscordGuilds = new List <ulong>()
});
}
}
internal DiscFileSystem GetFileSystem(VolumeInfo volInfo)
{
DiscFileSystem result;
if (!_fsCache.TryGetValue(volInfo.Identity, out result))
{
FileSystemManager fsmgr = new FileSystemManager();
FileSystemInfo[] fsInfo = fsmgr.DetectFileSystems(volInfo);
if (fsInfo != null && fsInfo.Length > 0)
{
result = fsInfo[0].Open(volInfo);
_fsCache.Add(volInfo.Identity, result);
}
}
return(result);
}
public void Cyrillic()
{
#if NET40
SetupHelper.RegisterAssembly(typeof(FatFileSystem).Assembly);
#else
SetupHelper.RegisterAssembly(typeof(FatFileSystem).GetTypeInfo().Assembly);
#endif
string lowerDE = "\x0434";
string upperDE = "\x0414";
MemoryStream ms = new MemoryStream();
using (FatFileSystem fs = FatFileSystem.FormatFloppy(ms, FloppyDiskType.HighDensity, "KBFLOPPY "))
{
fs.FatOptions.FileNameEncoding = Encoding.GetEncoding(855);
string name = lowerDE;
fs.CreateDirectory(name);
string[] dirs = fs.GetDirectories("");
Assert.Equal(1, dirs.Length);
Assert.Equal(upperDE, dirs[0]); // Uppercase
Assert.True(fs.DirectoryExists(lowerDE));
Assert.True(fs.DirectoryExists(upperDE));
fs.CreateDirectory(lowerDE + lowerDE + lowerDE);
Assert.Equal(2, fs.GetDirectories("").Length);
fs.DeleteDirectory(lowerDE + lowerDE + lowerDE);
Assert.Equal(1, fs.GetDirectories("").Length);
}
FileSystemInfo[] detectDefaultFileSystems = FileSystemManager.DetectFileSystems(ms);
DiscFileSystem fs2 = detectDefaultFileSystems[0].Open(
ms,
new FileSystemParameters {
FileNameEncoding = Encoding.GetEncoding(855)
});
Assert.True(fs2.DirectoryExists(lowerDE));
Assert.True(fs2.DirectoryExists(upperDE));
Assert.Equal(1, fs2.GetDirectories("").Length);
}
public static MoverCardDataModel ReadMoversShakersJsonByName(string fileName)
{
FileSystemManager fileSystem = new FileSystemManager();
if (fileSystem.IsFileExists(fileName, FileLocation))
{
return(JsonConvert.DeserializeObject <MoverCardDataModel>(fileSystem.ReadJsonFileFromSpecificLocation(fileName, FileLocation)));
}
else
{
return(new MoverCardDataModel
{
DailyIncreaseList = new List <MoverCardDataModel.CardInfo>(),
DailyDecreaseList = new List <MoverCardDataModel.CardInfo>(),
PageLastUpdated = DateTime.MinValue
});
}
}
public async Task SpellLookup(string spellName)
{
var programDirectory = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var fileManager = new FileSystemManager();
var spellsFromFile = fileManager.ReadJsonFileFromSpecificLocation("AllSpells.json", $"{programDirectory}\\SpellData");
var spells = JsonConvert.DeserializeObject <List <SpellModel> >(spellsFromFile);
var spell = spells.Find(x => x.Name == spellName.UpperCaseFirstLetter());
if (spell != null)
{
await Context.Channel.SendMessageAsync(embed : SpellOutputEmbed.SpellOutput(spell).Build());
}
else
{
await Context.Channel.SendMessageAsync($"{spellName} wasn't able to be found. Please double check your spelling or contact my developer.");
}
}
public static DateTime AcquireLastScrapeTime()
{
string serverLocation = ConfigurationManager.AppSettings.Get("MoversAndShakersScrapedDataLocation");
string fileName = ConfigurationManager.AppSettings.Get("SavedScrapedTimeFileName");
FileSystemManager fileSystem = new FileSystemManager();
if (fileSystem.IsFileExists(fileName, serverLocation))
{
return(JsonConvert.DeserializeObject <MoversAndShakersServerInfoDataModel>(fileSystem.ReadJsonFileFromSpecificLocation(fileName, serverLocation)).LastSuccessfulScrape);
}
else
{
return(new MoversAndShakersServerInfoDataModel
{
LastSuccessfulScrape = DateTime.Now
}.LastSuccessfulScrape);
}
}
private void LoadContainer(string filePath)
{
disk = VirtualDisk.OpenDisk(filePath, FileAccess.ReadWrite);
Debug.WriteLine(disk.Capacity + ", " + disk.DiskTypeInfo.Name);
volume = VolumeManager.GetPhysicalVolumes(disk.Content)[0];
fsInfo = FileSystemManager.DetectFileSystems(volume)[0];
discFs = fsInfo.Open(volume);
tmpFiles = new List <string>();
Debug.WriteLine(fsInfo.Name + " - " + fsInfo.Description);
fsHandler = new FileSystemHandler.FileSystemHandler(this);
}
protected void Save_Btn(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(this.PositionName.Value))
{
Sys_UserInfo sys_UserInfo = this.ViewState["su"] as Sys_UserInfo;
sys_UserInfo.PositionName = this.PositionName.Value;
sys_UserInfo.Sex = Convert.ToInt32(this.Sex.SelectedValue);
sys_UserInfo.Birthday = this.Birthday.Value;
sys_UserInfo.Phone = this.Phone.Value;
sys_UserInfo.Tel = this.Tel.Value;
sys_UserInfo.QQ = this.QQ.Value;
sys_UserInfo.Email = this.Email.Value;
sys_UserInfo.HomeAddress = this.HomeAddress.Value;
sys_UserInfo.JoinTime = this.JoinTime.Value;
sys_UserInfo.Notes = this.Notes.Value;
if (this.Fup.HasFile)
{
FileExtension[] fileEx = new FileExtension[]
{
FileExtension.GIF,
FileExtension.JPG,
FileExtension.PNG,
FileExtension.BMP
};
if (FileSystemManager.IsAllowedExtension(this.Fup, fileEx))
{
string userName = sys_UserInfo.UserName;
string text = base.Server.MapPath("~/Files/common/");
string text2 = userName + Path.GetExtension(this.Fup.FileName);
text += text2;
this.Fup.PostedFile.SaveAs(text);
sys_UserInfo.PerPic = text2;
this.Fup.Dispose();
}
}
Sys_User.Init().Update(sys_UserInfo);
Help.UpdateIMUser(sys_UserInfo);
MessageBox.ShowAndRedirect(this, "资料编辑成功!", "UserMenu.aspx");
}
else
{
MessageBox.ShowAndRedirect(this, "职务不能为空!", "User_InfoEdit.aspx");
}
}
protected void Save_Btn(object sender, EventArgs e)
{
Sys_UserInfo sys_UserInfo = this.ViewState["su"] as Sys_UserInfo;
sys_UserInfo.PositionName = this.PositionName.Value;
sys_UserInfo.Sex = Convert.ToInt32(this.Sex.SelectedValue);
sys_UserInfo.Birthday = this.Birthday.Value;
sys_UserInfo.Phone = this.Phone.Value;
sys_UserInfo.Tel = this.Tel.Value;
sys_UserInfo.QQ = this.QQ.Value;
sys_UserInfo.Email = this.Email.Value;
sys_UserInfo.HomeAddress = this.HomeAddress.Value;
sys_UserInfo.JoinTime = this.JoinTime.Value;
sys_UserInfo.Notes = this.Notes.Value;
sys_UserInfo.MsgTime = Convert.ToInt32(this.RoleGUID.SelectedValue);
sys_UserInfo.MemoShare = Convert.ToInt32(this.MemoShare.Checked);
sys_UserInfo.et6 = this.userlist.Value;
sys_UserInfo.et5 = this.namelist.Value;
if (this.Fup.HasFile)
{
FileExtension[] fileEx = new FileExtension[]
{
FileExtension.GIF,
FileExtension.JPG,
FileExtension.PNG,
FileExtension.BMP
};
if (FileSystemManager.IsAllowedExtension(this.Fup, fileEx))
{
string userName = sys_UserInfo.UserName;
string text = base.Server.MapPath("~/Files/common/");
string text2 = userName + Path.GetExtension(this.Fup.FileName);
text += text2;
this.Fup.PostedFile.SaveAs(text);
sys_UserInfo.PerPic = text2;
this.Fup.Dispose();
}
}
Sys_User.Init().Update(sys_UserInfo);
//Help.UpdateIMUser(sys_UserInfo);
string str = HttpContext.Current.Server.HtmlEncode("您好!基本资料修改成功!");
base.Response.Redirect("~/InfoTip/Operate_Success.aspx?returnpage=" + base.Request.Url.AbsoluteUri + "&tip=" + str);
}
/// <summary>
/// Dump the FileEntries from a Logical Volume asynchronously
/// </summary>
/// <param name="volume">The Volume to dump</param>
/// <param name="parentPath">The Path to the parent Disc</param>
/// <param name="options">Extractor Options to use</param>
/// <param name="governor">Resource Governor to use</param>
/// <param name="Context">Extractor context to use</param>
/// <param name="parent">The Parent FilEntry</param>
/// <returns></returns>
public static async IAsyncEnumerable <FileEntry> DumpLogicalVolumeAsync(LogicalVolumeInfo volume, string parentPath, ExtractorOptions options, ResourceGovernor governor, Extractor Context, FileEntry?parent = null)
{
DiscUtils.FileSystemInfo[]? fsInfos = null;
try
{
fsInfos = FileSystemManager.DetectFileSystems(volume);
}
catch (Exception e)
{
Logger.Debug("Failed to get file systems from logical volume {0} Image {1} ({2}:{3})", volume.Identity, parentPath, e.GetType(), e.Message);
}
foreach (var fsInfo in fsInfos ?? Array.Empty <DiscUtils.FileSystemInfo>())
{
using var fs = fsInfo.Open(volume);
var diskFiles = fs.GetFiles(fs.Root.FullName, "*.*", SearchOption.AllDirectories).ToList();
foreach (var file in diskFiles)
{
Stream? fileStream = null;
DiscFileInfo?fi = null;
try
{
fi = fs.GetFileInfo(file);
governor.CheckResourceGovernor(fi.Length);
fileStream = fi.OpenRead();
}
catch (Exception e)
{
Logger.Debug(e, "Failed to open {0} in volume {1}", file, volume.Identity);
}
if (fileStream != null && fi != null)
{
var newFileEntry = await FileEntry.FromStreamAsync($"{volume.Identity}{Path.DirectorySeparatorChar}{fi.FullName}", fileStream, parent);
var entries = Context.ExtractAsync(newFileEntry, options, governor);
await foreach (var entry in entries)
{
yield return(entry);
}
}
}
}
}
private static IEnumerable <IWizardStep <IStepView> > GetSteps(WizardModel model)
{
var fileSystemManager = new FileSystemManager();
var folderAutoCompleteProvider = new FileSystemAutoCompleteProvider(fileSystemManager, CompletionType.FoldersOnly);
var databaseTypes = new[] { "sqlserver", "mysql", "sqlite", "oracle" };
var steps = new List <IWizardStep <IStepView> >
{
new SelectProfileStep(model, new WpfSelectProfileStepView(), ProfileManager.Instance),
new SelectPackageStep(model, new WpfSelectPackageStepView(), fileSystemManager),
new SetUpBackupStep(model, new WpfSetUpBackupStepView(folderAutoCompleteProvider), fileSystemManager),
new SetUpDeployStatusStep(model, new WpfSetUpDeployStatusStepView(), fileSystemManager),
new SetUpGenerateWebConfigStep(model, new WpfSetUpGenerateWebConfigStepView(), fileSystemManager),
new SetUpDestinationStep(model, new WpfSetUpDestinationStepView(), fileSystemManager),
new SetUpMigrationStep(new DatabaseConnectionTester(), model, new WpfSetUpMigrationStepView(databaseTypes)),
new SummaryStep(model, new WpfSummaryStepView())
};
return(steps);
}
//Replace With correct Manager
protected override void OnLoadingContent()
{
Console.WriteLine("Something");
FileSystemManager fileSystemManager = new FileSystemManager("E:\rendu\\EIP\\MakersSquare\\AComponent");
this.contentManager = ContentManager.Create("Content");
LoadContentManifests(contentManager);
AudioManager audioManager = new AudioManager();
Song song = this.contentManager.Load <Song>(GlobalSongID.SabatonTheLastStand);
audioManager.addSong(song);
// this.song = TODO load song
songPlayer = SongPlayer.Create();
songPlayer.Play(song);
base.OnLoadingContent();
}
public void QuickSortFullTest()
{
FileSystemManager manager = FileSystemManager.Get();
CancellationToken cancellationToken = new();
IList <IFileSystemEntry> entries = new List <IFileSystemEntry>();
string path = @"C:\Users\julie\Documents";
manager.GetFileSystemEntries(path, cancellationToken, entries, (IList <IFileSystemEntry> list, IFileSystemEntry entry) => { list.Add(entry); });
IFileSystemEntry[] array = new IFileSystemEntry[entries.Count];
entries.CopyTo(array, 0);
QuickSort.Sort(array, 0, array.Length - 1);
for (int i = 0; i < array.Length - 1; i++)
{
Assert.IsFalse(array[i].CompareTo(array[i + 1]) > 0, nameof(array) + " is not sorted.");
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceCollection ConfigureServicesSlime(IServiceCollection services)
{
services.AddDbContext <SlimeDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity <ApplicationUser, ApplicationRole>(options => options.SignIn.RequireConfirmedAccount = true)
.AddEntityFrameworkStores <SlimeDbContext>()
.AddDefaultTokenProviders();
services.AddMvcCore().AddControllersAsServices()
.AddRazorPages();
//services.AddDefaultIdentity<ApplicationUser>(options => options.SignIn.RequireConfirmedAccount = true)
// .AddEntityFrameworkStores<SlimeDbContext>();
//this.extensionsPath = Path.Combine(hostingEnvironment.ContentRootPath, configuration["Extensions:Path"]);
this.extensionsPath = Path.Combine(FileSystemManager.GetAppRootBinaryFolderAbsolutePath(), AppSettingsManager.GetExtetionPath());
//Configuration["Extensions:Path"];
if (string.IsNullOrWhiteSpace(extensionsPath) == false)
{
services.AddExtCore(this.extensionsPath);
}
services.Configure <StorageContextOptions>(options =>
{
// options.MigrationsAssembly = typeof(DesignTimeStorageContextFactory).GetTypeInfo().Assembly.FullName;
});
services.AddScoped <IStorageContext, SlimeDbContext>();
//services.AddSingleton<IStorageContext, SlimeDbContext>();
// DesignTimeStorageContextFactory.Initialize(services.BuildServiceProvider());
services.AddSingleton <IEmailSender, EmailSender>();
Direcotrybrowse = AppSettingsManager.GetAllowDirectoryBrowseSetting();
if (Direcotrybrowse)
{
services.AddDirectoryBrowser();
}
services.Configure <KestrelServerOptions>(
Configuration.GetSection("Kestrel"));
return(services);
}
public void ReturnAvailableDirInfoTest()
{
FileSystemManager fs = new FileSystemManager();
var path = @"L:\";
FileSystemViewModel vm = new FileSystemViewModel();
vm = fs.ReturnAvailableDirInfo(path);
foreach (var item in vm.Folders)
{
Console.WriteLine(item);
}
foreach (var item in vm.Files)
{
Console.WriteLine(item);
}
Console.WriteLine(vm.Count10mb);
Console.WriteLine(vm.Count50mb);
Console.WriteLine(vm.Count100mb);
Assert.IsNotNull(vm.Files);
Assert.IsNotNull(vm.Folders);
}
internal static void Receive(WorldTransferHeaderMessage msg)
{
ExpectedChunks = 0;
ExpectedItemRegistries = 0;
ReceivedChunks = 0;
ReceivedItemRegistries = 0;
SaveName = FileSystemManager.GetIOSafeTime();
WorldStorage.Initialize(SaveName);
foreach (DimensionHeader item in msg.DimensionHeaders)
{
ExpectedChunks += item.Height * item.Width;
ExpectedItemRegistries++;
DirectoryInfo dirInfo = Directory.CreateDirectory(WorldStorage.DimensionSaveFolder + Path.DirectorySeparatorChar + item.ID);
WorldStorage.DimensionPaths.Add(item.ID, dirInfo.FullName);
WorldStorage.DimensionStorage.SerializeDimensionHeader(item, DiskSink, dirInfo.FullName);
}
}
internal FolderInfo(FileSystemManager parent, string name, string path, bool loadDirectories = false, bool loadFiles = false) : base(parent, name, path, loadDirectories, loadFiles)
{
}
public void ReturnDrivesTest()
{
FileSystemManager fs = new FileSystemManager();
var drives = fs.ReturnDrives();
Assert.IsNotNull(drives);
}
public FileSystemManagerTestContext()
{
fileSystem = Substitute.For<PlatformFileSystem>();
manager = new FileSystemManager(fileSystem);
}
protected override void Establish_context()
{
base.Establish_context();
FileSystemManager = new FileSystemManager(Logger.Object);
}
public FileSystemController()
{
_fsManager = new FileSystemManager();
}
public void ReturnDirectoryNameTest()
{
var path = @"C:\Program Files";
var path2 = "C:\\Program Files";
var path3 = @"C:\ ProgramFiles";
FileSystemManager fs = new FileSystemManager();
var name = fs.ReturnDirectoryName(path);
var name2 = fs.ReturnDirectoryName(path2);
var name3 = fs.ReturnDirectoryName(path3);
var expectedname = "Program Files";
Assert.IsNotNull(name);
Assert.IsNotNull(name2);
Assert.IsNull(name3);
Assert.AreEqual(expectedname, name);
Assert.AreEqual(expectedname, name2);
Assert.AreNotEqual(expectedname, name3);
}
internal DrvInfoRoot(FileSystemManager parent, string name, string path, bool loadDirectories = false, bool loadFiles = false) : base(parent, name, path, loadDirectories, loadFiles)
{
Drives = new DrvInfo[0];
}
internal DrvInfo(FileSystemManager parent, string name, string label, string path, DriveType type, bool isReady, bool loadDirectories = false, bool loadFiles = false) : base(parent, name, path, loadDirectories, loadFiles)
{
Type = type;
Label = label;
IsReady = isReady;
}
public bool MainRoutine()
{
try
{
//Load File System Service
FileSystemManager fileMgr = new FileSystemManager();
NewElasticService.ServiceWCFClient svc = new ServiceWCFClient();
bool delete = svc.deleteAllRecommendedJob();
JobManager jobMgr = new JobManager();
String[] job_list = jobMgr.selectExpressionNames(); //job_names
double[] X = jobMgr.selectExpressionDifficulty(); //X
double[,] new_X = new double[X.Length, 1];
for (int i = 0; i < X.Length; i++)
{
new_X[i, 0] = X[i];
}
//User Profile (just the user ID, I still need the user self rating)
RecruiteeManager recMgr = new RecruiteeManager();
String[] recruitee_names = recMgr.selectRecruiteeNames();
double[] recruitee_skill = recMgr.selectRecruiteeSkills();
UserProfile[] users_profile = new UserProfile[recruitee_skill.Length];
for (int i = 0; i < recruitee_skill.Length; i++)
{
users_profile[i] = new UserProfile("", 0);
users_profile[i].UserID = recruitee_names[i];
users_profile[i].UserRating = recruitee_skill[i];
}
//new_Y
ElasticManager elaMgr = new ElasticManager();
double[,] Y = elaMgr.selectRatings(job_list, users_profile);
/////// WRITING VARIABLES IN FILE ////////////
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
////used to insert recommended jobs for a user in the database
fileMgr.writeFiles(job_list, new_X, users_profile, Y);
}).Start();
//Object to Hold Task Parameters
TaskDimensions task = new TaskDimensions();
task.num_features = new_X.GetLength(1); //1 is the number of columns
task.num_jobs_init = job_list.Length;
task.num_users_init = recruitee_names.Length;
//User number to start proccessing
int user_number = 1;
//Creating a variable to write in a File the job recommendations and comparisons
//Load File Writer
StreamWriter writeTextResult = fileMgr.getResultStreamWriter();
StreamWriter writeTextAverages = fileMgr.getAverageStreamWriter();
StreamWriter writeText = fileMgr.getIdandAvgStreamWriter();
StreamWriter writeTextDiff = fileMgr.getDifficultyStreamWriter();
double[] users_calculated_raitings = new double[task.num_users_init];
double total_rating_avg_system = 0;
double total_similarity_avg_system = 0;
double total_inaccuracy_system = 0;
MatlabManager matlabMgr = new MatlabManager();
while (user_number <= task.num_users_init)
{
double[,] my_ratings = new double[task.num_jobs_init, 1];
double[,] new_Y = new double[task.num_jobs_init, task.num_users_init - 1];
double[,] R = new double[task.num_jobs_init, task.num_users_init - 1];
for (int i = 0; i < job_list.Length; i++)
{
int k = 0;
for (int n = 0; n < users_profile.Length; n++)
{
if (n != (user_number - 1))
{
new_Y[i, k] = Y[i, n];
if (Y[i, n] != 0)
R[i, k] = 1;
else
R[i, k] = 0;
k++;
}
else
my_ratings[i, 0] = Y[i, n];
}
}
//Creating a MatLab reference to execute the recommended job script
object[] res = matlabMgr.executeFilter(task, job_list, Directory.GetCurrentDirectory() + DirectoryPaths.MATLAB, my_ratings, new_Y, R, new_X);
//Each time creates a to be used to write the recommended jobs in a file
List<TopJobData> mylist = fileMgr.writeValuesToFile(writeTextResult, res, job_list, user_number, new_X);
//Calculate Averages for Jobs for a User
DataResult avgs = new DataResult(mylist, mylist.Count, users_profile[user_number - 1]);
avgs.AverageForEachJob();
fileMgr.writeAveragesToFile(avgs, writeTextAverages, users_profile[user_number - 1]);
total_rating_avg_system += avgs.Rating_total_avg;
total_similarity_avg_system += avgs.Percentage_total_avg;
total_inaccuracy_system += avgs.Self_inaccuracy;
//adding the list at the Dictionary for each user
//ID and AVGs file
writeText.WriteLine(users_profile[user_number - 1].UserID + "\t" + avgs.Rating_total_avg);
users_calculated_raitings[user_number - 1] = avgs.Rating_total_avg;
//writing in the difficulty file
fileMgr.writeDifficultyToFile(writeTextDiff, avgs);
//used to insert recommended jobs for a user in the database
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
////used to insert recommended jobs for a user in the database
bool result = elaMgr.insertRecommenderJob(avgs);
}).Start();
user_number++;
}
total_rating_avg_system /= task.num_users_init;
total_similarity_avg_system /= task.num_users_init;
total_inaccuracy_system /= task.num_users_init;
//writing some more global information
fileMgr.writeGlobalAveragesInformation(total_rating_avg_system, total_similarity_avg_system, total_inaccuracy_system,
task, writeTextAverages, users_profile, users_calculated_raitings);
//closing the three files
writeText.Close();
writeTextResult.Close();
writeTextAverages.Close();
writeTextDiff.Close();
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
////used to insert recommended jobs for a user in the database
bool result = elaMgr.updateRanking(DirectoryPaths.FILE_ID_AVG);
}).Start();
Console.WriteLine("DONE");
//Wait until fisnih
Console.ReadLine();
return true;
}
catch (Exception ex)
{
return false;
}
}
public void ReturnFileSystemEntriesTest()
{
var invalidPath = "";
var invalidPath2 = " ";
var invalidPath3 = " ";
var invalidPath4 = "sdfodvove iifvbdibda";
var invalidPath5 = "C";
var invalidPath6 = @"L:\";
FileSystemManager fs = new FileSystemManager();
var entries = fs.ReturnFileSystemEntries(invalidPath);
var entries2 = fs.ReturnFileSystemEntries(invalidPath2);
var entries3 = fs.ReturnFileSystemEntries(invalidPath3);
var entries4 = fs.ReturnFileSystemEntries(invalidPath4);
var entries5 = fs.ReturnFileSystemEntries(invalidPath5);
var entries6 = fs.ReturnFileSystemEntries(invalidPath6);
Assert.IsNull(entries);
Assert.IsNull(entries2);
Assert.IsNull(entries3);
Assert.IsNull(entries4);
Assert.IsNull(entries5);
Assert.IsNotNull(entries6);
foreach (var entry in entries6)
{
Console.WriteLine(entry);
}
}
public void TraverseAvailableFilesTest()
{
FileSystemManager fs = new FileSystemManager();
var path = @"L:\";
var delegates = new List<Func<FileInfo, bool>>() { entry => entry.Length < 10485760, entry => entry.Length > 10485760 && entry.Length < 52428800, entry => entry.Length > 104857600 };
var filesCount = fs.TraverseAvailableFiles(path, delegates);
foreach (var item in filesCount)
{
Console.WriteLine(item.Value);
}
Assert.IsNotNull(filesCount);
}
internal FiInfo(FileSystemManager parent, string name, string path, long lenght) : base(parent, name, path)
{
Size = lenght;
}
public LocalFilePropertyService(FileSystemManager fileSystem, string fileName)
: this(fileSystem, fileName, new Clock())
{
}
public bool ExecuteMainRoutine()
{
try
{
ElasticManager elasticMgr = new ElasticManager();
//Object to Hold Task Parameters
TaskDimensions task = new TaskDimensions();
//User number to start proccessing
int user_number = 1;
//Load File System Service
FileSystemManager fileSystemMgr = new FileSystemManager();
//Method call to get the number of jobs and users from the file Y
fileSystemMgr.detectSizeOfJobsColumns(task, path_fix + "files/new_Y_53.txt");
//Method call to get the number of features from the file X, and allocating the X matrix
double[,] X = fileSystemMgr.getNumberOfFeaturesX(path_fix + "files/X.txt", task);
fileSystemMgr.readFeaturesX(X, path_fix + "files/X.txt", task);
//Method call to get the jobs names
String[] job_list = fileSystemMgr.readJobNames(path_fix + "files/expressions.txt", task);
//method that return the users profile
UserProfile[] users_profile = fileSystemMgr.readUserProfile(path_fix + "files/new_user_table_53.txt", task);
//Creating a variable to write in a File the job recommendations and comparisons
//Load File Writer
StreamWriter writeTextResult = fileSystemMgr.getResultStreamWriter();
StreamWriter writeTextAverages = fileSystemMgr.getAverageStreamWriter();
StreamWriter writeText = fileSystemMgr.getIdandAvgStreamWriter();
StreamWriter writeTextDiff = fileSystemMgr.getDifficultyStreamWriter();
double[] users_calculated_raitings = new double[task.num_users_init];
double total_rating_avg_system = 0;
double total_similarity_avg_system = 0;
double total_inaccuracy_system = 0;
//Creating a MatLab reference to execute the recommended job script
MatlabManager matlabMgr = new MatlabManager();
while (user_number <= task.num_users_init)
{
// job rating file for a user
double[,] my_ratings = new double[task.num_jobs_init, 1];
//Now we read R and Y from theirs files (-1 because I will remove the chosen user from the matrixes)
double[,] Y = fileSystemMgr.readTrainingY(path_fix + "files/new_Y_53.txt", task, my_ratings, user_number);
double[,] R = fileSystemMgr.readTrainingR(path_fix + "files/new_R_53.txt", task, user_number);
object[] res = matlabMgr.executeFilter(task, job_list, path_fix + "files", my_ratings, Y, R, X);
//Each time creates a to be used to write the recommended jobs in a file
List<TopJobData> mylist = fileSystemMgr.writeValuesToFile(writeTextResult, res, job_list, user_number, X);
//Calculate Averages for Jobs for a User
DataResult avgs = new DataResult(mylist, mylist.Count, users_profile[user_number - 1]);
avgs.AverageForEachJob();
fileSystemMgr.writeAveragesToFile(avgs, writeTextAverages, users_profile[user_number - 1]);
total_rating_avg_system += avgs.Rating_total_avg;
total_similarity_avg_system += avgs.Percentage_total_avg;
total_inaccuracy_system += avgs.Self_inaccuracy;
//adding the list at the Dictionary for each user
//ID and AVGs file
writeText.WriteLine(users_profile[user_number - 1].UserID + "\t" + avgs.Rating_total_avg);
users_calculated_raitings[user_number - 1] = avgs.Rating_total_avg;
//writing in the difficulty file
fileSystemMgr.writeDifficultyToFile(writeTextDiff, avgs);
new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
// ////used to insert recommended jobs for a user in the database
bool result = elasticMgr.insertRecommenderJob(avgs);
}).Start();
user_number++;
}
total_rating_avg_system /= task.num_users_init;
total_similarity_avg_system /= task.num_users_init;
total_inaccuracy_system /= task.num_users_init;
//writing some more global information
fileSystemMgr.writeGlobalAveragesInformation(total_rating_avg_system, total_similarity_avg_system, total_inaccuracy_system,
task, writeTextAverages, users_profile, users_calculated_raitings);
//closing the three files
writeText.Close();
writeTextResult.Close();
writeTextAverages.Close();
writeTextDiff.Close();
return true;
/*
* Used to insert rating for task performed by workers. (User interface need to be built)
*
double[,] full_Y = svc.readFullY(Directory.GetCurrentDirectory() + "/files/Y.txt", task);
IElasticSvc e = new ElasticSvcImpl();
e.InsertRatings(job_list, users_profile, full_Y);
*/
}
catch (Exception ex)
{
return false;
}
}
internal ContainerHostService(FileSystemManager fileSystem, IProcessRunner processRunner, ContainerHostDependencyHelper dependencyHelper)
{
this.fileSystem = fileSystem;
this.processRunner = processRunner;
this.dependencyHelper = dependencyHelper;
}
public LocalFilePropertyService(FileSystemManager fileSystem, string fileName, Clock clock)
{
this.fileSystem = fileSystem;
this.fileName = fileName;
this.clock = clock;
}
public void ReturnDesktopPathTest()
{
string expectedPath = @"C:\Users\<!!!!>\Desktop";
FileSystemManager fs = new FileSystemManager();
string actual = fs.ReturnDesktopPath();
Assert.AreEqual(expectedPath, actual);
Console.WriteLine("expected path: {0}, \n actual path: {1}", expectedPath, actual);
}
