private void FixedUpdate()
{
if (!StateFile.IsEmpty(Path))
{
StateFile.Write(Path, Constants.DELIMITER);
}
var history = stateHistoryMB.deltaStateHistory;
if (history.Count > 0)
{
var latestDeltaState = stateHistoryMB.deltaStateHistory[history.Count - 1];
if (latestDeltaState.startStateTick != latestDeltaState.endStateTick)
{
var bytes = latestDeltaState.ToBytes().ToArray();
StateFile.Write(Path, bytes);
}
}
}
private void FixedUpdate()
{
if (StateFile.HasChanged(Path))
{
var bytes = StateFile.ReadBytes(Path);
deltaStateHistory.FromBytes(new ByteQueue(bytes));
count = deltaStateHistory.Count;
}
if (count > 0 && isPlaying)
{
var deltaState = deltaStateHistory.GetDeltaState(state.tick);
if (deltaState != null)
{
state = (TransformState)deltaState.GenerateEndState(state);
StateToScene.SpawnEntities(state, clones, transform);
StateToScene.DespawnEntities(state, clones);
StateToScene.ApplyChangesToEntites(state, clones);
}
tick = state.tick;
}
}
private void FixedUpdate()
{
time = Time.time;
if (stateMB.state.tick > 0 && stateMB.state.tick % Constants.TICK_RATE == 0)
{
var deltaState = new TransformDeltaState();
deltaState.Create(previousState, stateMB.state);
deltaStateHistory.Add(deltaState);
if (!StateFile.IsEmpty(Path))
{
StateFile.Write(Path, Constants.DELIMITER);
}
var bytes = deltaState.ToBytes().ToArray();
StateFile.Write(Path, bytes);
previousState.tick = stateMB.state.tick;
previousState.entities.Clear();
previousState.entities.AddRange(stateMB.state.entities.Clone());
}
}
private void FixedUpdate()
{
time = Time.time;
if (Time.time > 0)
{
currentTick += playbackSpeed;
}
if (currentTick >= endState.tick)
{
var bytes = StateFile.ReadBytes(Path);
deltaStateHistory.FromBytes(new ByteQueue(bytes));
if (targetTick < deltaStateHistory.Count)
{
var deltaState = deltaStateHistory[targetTick];
if (deltaState != null)
{
startState = endState;
endState = (TransformState)deltaState.GenerateEndState(endState);
}
targetTick++;
}
}
}
private async Task ExportAsync(StateFile stateFile)
{
if (Path.IsPathRooted(stateFile.File))
{
Env.Notifier.Warning($"Cannot export '{stateFile.File}', only relative paths are allowed.");
return;
}
var sourceFile = Path.Combine(Env.Config.DataDir, stateFile.File);
if (!File.Exists(sourceFile))
{
Env.Notifier.Warning($"Cannot export '{sourceFile}', file not found.");
return;
}
string text;
if (stateFile.Flags.HasFlag(StateHandlerFlags.UseCipher))
{
text = await Env.Cipher.TryDecryptFileAsync(sourceFile);
if (text == null)
{
Env.Notifier.Warning($"Cannot export '{sourceFile}', decryption failed.");
return;
}
}
else
{
text = File.ReadAllText(sourceFile);
}
var targetFile = Path.Combine(_directory, stateFile.File);
Directory.CreateDirectory(Path.GetDirectoryName(targetFile));
File.WriteAllText(targetFile, text);
Env.Notifier.Info($"Created file '{targetFile}'.");
}
private void OnDisable()
{
StateFile.Close(Path);
}
private void OnEnable()
{
StateFile.OpenAndResetForWrite(Path);
}
public string Save(string sourceDir, string targetDir, Semaphore MaxSizeSemaphore)
{
try
{
//Folder naming
DirectoryInfo dir1 = new DirectoryInfo(sourceDir);
IEnumerable <FileInfo> list1 = dir1.GetFiles("*.*", System.IO.SearchOption.AllDirectories);
string dateDay = DateTime.Now.ToString("dd");
string dateMonth = DateTime.Now.ToString("MM");
string dateYear = DateTime.Now.ToString("yyyy");
string dateHour = DateTime.Now.ToString("HH");
string dateMin = DateTime.Now.ToString("mm");
string dateSec = DateTime.Now.ToString("ss");
string folderName = "\\" + dateYear + "-" + dateMonth + "-" + dateDay + "_" + dateHour + "h" + dateMin + "min" + dateSec + "-FullSave";
string[] filesListSource = Directory.GetFiles(sourceDir, "*.*", System.IO.SearchOption.AllDirectories);
string[] extensions = File.ReadAllLines("ExtensionFile.txt");
FileSort fileSort = new FileSort();
List <FileInfo> prioList = fileSort.PriorizeList(list1);
TimeSpan cryptingTime;
cryptingTime = TimeSpan.Zero;
StateFile statefile = new StateFile();
Save save = new Save();
//If there are files to transfer
if (filesListSource.Length != 0)
{
// Create the save directory
Directory.CreateDirectory(targetDir + folderName);
DateTime D1 = DateTime.Now;
// Create all the Directories needed
foreach (string dirPath in Directory.GetDirectories(sourceDir, "*", System.IO.SearchOption.AllDirectories))
{
Directory.CreateDirectory(dirPath.Replace(sourceDir, targetDir + folderName));
}
// Copy all the files in the associated directory
foreach (var file in prioList)
{
// Remove path from the file name.
string fileName = file.Name;
string vPath = file.FullName.Substring(sourceDir.Length + 1);
bool FileLargerParameter = false;
if (File.Exists("FileSizeLimit.txt"))
{
if (FileSystem.GetFileInfo($"{sourceDir}/{vPath}").Length > Convert.ToInt64(File.ReadAllText($"{Environment.CurrentDirectory}/FileSizeLimit.txt")))
{
MaxSizeSemaphore.WaitOne();
FileLargerParameter = true;
}
}
try
{
bool file2Crypt = false;
foreach (var ext in extensions)
{
if (ext == file.Extension)
{
file2Crypt = true;
}
}
if (file2Crypt == true)
{
while (Controller.EnterpriseSoftwareRunning() == true)
{
}
;
if (file.Extension != File.ReadAllText("PriorityFiles.txt"))
{
Controller.Barrier.SignalAndWait();
}
Process processus = new Process();
processus.StartInfo.FileName = Directory.GetCurrentDirectory() + "\\Cryptosoft.exe";
processus.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
Console.WriteLine("\nTransfert du fichier " + fileName + "...");
processus.StartInfo.Arguments = "-c " + sourceDir + "\\" + vPath + " fe3a2d57c378d7dc946589e9aa8cee011cae8013 " + targetDir + folderName + "\\" + vPath;
processus.EnableRaisingEvents = true;
processus.Exited += new EventHandler(myProcess_Exited);
processus.Start();
Console.WriteLine("Cryptage du fichier" + fileName + " en cours...");
processus.WaitForExit();
cryptingTime += ((Process)processus).ExitTime - ((Process)processus).StartTime;
}
else
{
file.CopyTo(targetDir + "//" + folderName + "//" + vPath);
}
save.SaveUpdate(folderName, sourceDir, targetDir, fileName);
statefile.UpdateStateFile(save);
}
// Catch exception if the file was already copied.
catch (IOException copyError)
{
Console.WriteLine(copyError.Message);
}
if (FileLargerParameter)
{
MaxSizeSemaphore.Release();
}
}
// Calculate the transfer time
DateTime D2 = DateTime.Now;
TimeSpan transferTime = D2 - D1;
Console.WriteLine("Le temps de transfert total des fichiers a été de " + transferTime);
Console.WriteLine("Le temps de cryptage total des fichiers a été de " + cryptingTime);
// Create and update the logs file
LogSave logSave = new LogSave();
logSave.CreateLog(folderName, sourceDir, targetDir, transferTime, cryptingTime);
logSave.UpdateLogFile(logSave);
}
else
{
Console.WriteLine("No files to copy");
}
return(folderName);
}
catch (DirectoryNotFoundException dirNotFound)
{
Console.WriteLine(dirNotFound.Message);
return("error");
}
}
private void OnEnable()
{
Time.fixedDeltaTime = SimulationUpdatesPerSecond;
StateFile.OpenAndResetForWrite(Path);
}
private static void CMLoad()
{
VitaNexCore.TryCatch(() => StateFile.Deserialize(State.Deserialize), CMOptions.ToConsole);
}
/// <summary>
/// Resolves lambda code.
/// For embedded (ZipFile) scripts, creates zipper resources for the files extracted by <see cref="LambdaFunctionImporter"/>.
/// For S3 and container lambdas, sets the appropriate properties
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="stateFile">The state file.</param>
private void ResolveLambdaCode(TextWriter writer, StateFile stateFile)
{
foreach (var cloudFormationResource in this.settings.Template.Resources.Where(
r => r.Type == TerraformExporterConstants.AwsLambdaFunction && r.GetResourcePropertyValue("Code") != null))
{
var mapping =
this.module.ResourceMappings.FirstOrDefault(ir => ir.LogicalId == cloudFormationResource.Name);
if (mapping == null)
{
continue;
}
var terraformResource = stateFile.FilteredResources(this.module.Name).FirstOrDefault(
rd => rd.Name == mapping.LogicalId && rd.Type == mapping.TerraformType);
if (terraformResource == null)
{
continue;
}
// Fix up state file.
// ReSharper disable once AssignNullToNotNullAttribute - already asserted that this has a value in foreach statement.
var lambdaCode =
((Dictionary <object, object>)cloudFormationResource.GetResourcePropertyValue("Code")).ToDictionary(
kv => kv.Key.ToString(),
kv => kv.Value);
var attributes = terraformResource.Instances.First().Attributes;
if (lambdaCode.ContainsKey("ZipFile"))
{
var runtimeObject = cloudFormationResource.GetResourcePropertyValue("Runtime");
if (runtimeObject == null)
{
// No runtime specified
continue;
}
ResolveLambdaZipCode(
writer,
runtimeObject.ToString(),
cloudFormationResource,
attributes,
mapping,
this.module.Inputs);
}
else if (lambdaCode.ContainsKey("ImageUri"))
{
UpdatePropertyValue(
"image_uri",
cloudFormationResource.Template,
attributes,
mapping,
this.module.Inputs,
lambdaCode["ImageUri"]);
}
else
{
ResolveLambdaS3Code(cloudFormationResource, attributes, mapping, this.module.Inputs, lambdaCode);
}
}
}
/// <summary>
/// Serializes the specified state file to HCL.
/// </summary>
/// <param name="stateFile">The state file.</param>
public void Serialize(StateFile stateFile)
{
this.Serialize(stateFile, null);
}
private void FixedUpdate()
{
var stateBytes = stateMB.state.ToBytes().ToArray();
StateFile.ResetAndWrite(Path, stateBytes);
}
