public FDesktop(IEmailer emailer, ImageSaver imageSaver, StringWrapper stringWrapper, AppConfigManager appConfigManager, RecoveryManager recoveryManager, IScannedImageImporter scannedImageImporter, AutoUpdaterUI autoUpdaterUI, OcrDependencyManager ocrDependencyManager, IProfileManager profileManager, IScanPerformer scanPerformer, IScannedImagePrinter scannedImagePrinter, ChangeTracker changeTracker, EmailSettingsContainer emailSettingsContainer, FileNamePlaceholders fileNamePlaceholders, ImageSettingsContainer imageSettingsContainer, PdfSettingsContainer pdfSettingsContainer, PdfSaver pdfSaver, IErrorOutput errorOutput)
{
this.emailer = emailer;
this.imageSaver = imageSaver;
this.stringWrapper = stringWrapper;
this.appConfigManager = appConfigManager;
this.recoveryManager = recoveryManager;
this.scannedImageImporter = scannedImageImporter;
this.autoUpdaterUI = autoUpdaterUI;
this.ocrDependencyManager = ocrDependencyManager;
this.profileManager = profileManager;
this.scanPerformer = scanPerformer;
this.scannedImagePrinter = scannedImagePrinter;
this.changeTracker = changeTracker;
this.emailSettingsContainer = emailSettingsContainer;
this.fileNamePlaceholders = fileNamePlaceholders;
this.imageSettingsContainer = imageSettingsContainer;
this.pdfSettingsContainer = pdfSettingsContainer;
this.pdfSaver = pdfSaver;
this.errorOutput = errorOutput;
InitializeComponent();
thumbnailList1.MouseWheel += thumbnailList1_MouseWheel;
Shown += FDesktop_Shown;
FormClosing += FDesktop_FormClosing;
Closed += FDesktop_Closed;
}
/// <summary>
/// Saves a backup file after an interval
/// </summary>
private void BackupTimerTick(Object sender, EventArgs e)
{
if (this.IsEditable && !this.IsUntitled && this.IsModified && this.previousText != this.SciControl.Text)
{
RecoveryManager.SaveTemporaryFile(this.FileName, this.SciControl.Text, this.SciControl.Encoding);
this.previousText = this.SciControl.Text;
}
}
/// <summary>
/// Saves an editable document
/// </summary>
public void Save(String file)
{
if (!this.IsEditable)
{
return;
}
if (!this.IsUntitled && FileHelper.FileIsReadOnly(this.FileName))
{
String dlgTitle = TextHelper.GetString("Title.ConfirmDialog");
String message = TextHelper.GetString("Info.MakeReadOnlyWritable");
if (MessageBox.Show(Globals.MainForm, message, dlgTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
ScintillaManager.MakeFileWritable(this.SciControl);
}
else
{
return;
}
}
Boolean otherFile = (this.SciControl.FileName != file);
if (otherFile)
{
RecoveryManager.RemoveTemporaryFile(this.FileName);
TextEvent close = new TextEvent(EventType.FileClose, this.FileName);
EventManager.DispatchEvent(this, close);
}
TextEvent saving = new TextEvent(EventType.FileSaving, file);
EventManager.DispatchEvent(this, saving);
if (!saving.Handled)
{
this.UpdateDocumentIcon(file);
this.SciControl.FileName = file;
ScintillaManager.CleanUpCode(this.SciControl);
DataEvent de = new DataEvent(EventType.FileEncode, file, this.SciControl.Text);
EventManager.DispatchEvent(this, de); // Lets ask if a plugin wants to encode and save the data..
if (!de.Handled)
{
FileHelper.WriteFile(file, this.SciControl.Text, this.SciControl.Encoding, this.SciControl.SaveBOM);
}
this.IsModified = false;
this.SciControl.SetSavePoint();
RecoveryManager.RemoveTemporaryFile(this.FileName);
this.fileInfo = new FileInfo(this.FileName);
if (otherFile)
{
ScintillaManager.UpdateControlSyntax(this.SciControl);
Globals.MainForm.OnFileSave(this, true);
}
else
{
Globals.MainForm.OnFileSave(this, false);
}
}
this.UpdateToolTipText();
this.UpdateTabText();
}
private void CreateRecoveryMethods()
{
int count = abilityData.recoveryData.Count;
for (int i = 0; i < count; i++)
{
AbilityRecovery newRevovrey = EffectFactory.CreateRecovery(this, abilityData.recoveryData[i]);
RecoveryManager.AddRecoveryMethod(newRevovrey);
}
}
public void ManagedUpdate()
{
if (Equipped == false)
{
return;
}
RecoveryManager.ManagedUpdate();
EffectManager.ManagedUpdate();
UpdateTimers();
}
private bool HandleActivationConditions(Constants.AbilityActivationCondition[] conditions)
{
bool result = false;
if (RecoveryManager.HasRecovery == false)
{
return(true);
}
bool freeActivation = conditions.Contains(Constants.AbilityActivationCondition.IgnoreCost) && conditions.Contains(Constants.AbilityActivationCondition.IgnoreRecovery);
if (freeActivation)
{
return(true);
}
if (conditions.Contains(Constants.AbilityActivationCondition.Normal) || conditions.Length < 1)
{
//Check For Resource
result = RecoveryManager.HasCharges;
if (result == true)
{
RecoveryManager.SpendCharge();
//Spend Resource
}
return(result);
}
if (conditions.Contains(Constants.AbilityActivationCondition.IgnoreRecovery))
{
//Check For Resource
//Spend Resource
}
if (conditions.Contains(Constants.AbilityActivationCondition.IgnoreCost))
{
result = RecoveryManager.HasCharges;
if (result == true)
{
RecoveryManager.SpendCharge();
}
return(result);
}
return(result);
}
public void ManagedUpdate()
{
if (Equipped == false)
{
return;
}
//if(ParentAbility != null)
//Debug.Log(abilityName + " is being updated");
RecoveryManager.ManagedUpdate();
EffectManager.ManagedUpdate();
UpdateTimers();
UpdateSequencedAbilities();
}
public void RunRecovering(RestoreTaskInfo task)
{
switch (task.RestorationType)
{
case RestoreType.As7ZipArchive:
RecoveryManager.RestoreAs7ZipArchiveHelper(_imageReader, task.Record, task.Parameter);
break;
case RestoreType.ToPointedFolder:
RecoveryManager.RestoreToPointedFolderHelper(_imageReader, task.Record, task.Parameter, this.imageDataIsPasswordProtected, this.Password);
break;
case RestoreType.ToOriginal:
RecoveryManager.RestoreToOriginalLocation(_imageReader, task.Record, this.imageDataIsPasswordProtected, this.Password);
break;
}
}
public void CanRecoverFromUncommitedAndCommitedTransactions()
{
var page = _fileManager.ResolvePage();
var block = new Block(RandomFilename, 0);
page.Read(block);
page.SetInt(0, 222);
page.Write(block);
var startRecord = new StartRecord(_logManager, _bufferManager, 1);
var lsn = startRecord.WriteToLog();
_logManager.Flush(lsn);
var startRecord2 = new StartRecord(_logManager, _bufferManager, 2);
var lsn2 = startRecord2.WriteToLog();
_logManager.Flush(lsn2);
_recoveryManager = new RecoveryManager(_bufferManager, _logManager, 1);
var buffer = _bufferManager.Pin(block);
_recoveryManager.SetInt(buffer, 0, 123);
_recoveryManager.SetByte(buffer, 0, 1);
_recoveryManager.Commit();
var recoveryManager2 = new RecoveryManager(_bufferManager, _logManager, 2);
recoveryManager2.SetByte(buffer, 1, 0);
Assert.DoesNotThrow(() =>
{
recoveryManager2.Recover();
_bufferManager.Unpin(buffer);
});
page.Read(block);
_ = page.GetInt(0, out var resultValue);
Assert.AreEqual(222, resultValue);
}
/// <summary>
/// Creates and adds many point mappings to ShardMap.
/// </summary>
/// <param name="argsList">List of objects containing information about mappings to be added.</param>
public IEnumerable <PointMapping <TKey> > CreateFromPointMappings(IEnumerable <PointMappingCreationArgs <TKey> > argsList)
{
ExceptionUtils.DisallowNullArgument(argsList, "argsList");
// Partition the mappings by shardlocation.
IDictionary <ShardLocation, IList <PointMapping <TKey> > > pointMappings = new Dictionary <ShardLocation, IList <PointMapping <TKey> > >();
foreach (PointMappingCreationArgs <TKey> args in argsList)
{
ExceptionUtils.DisallowNullArgument(args, "args");
if (!pointMappings.ContainsKey(args.Shard.Location))
{
pointMappings[args.Shard.Location] = new List <PointMapping <TKey> >();
}
pointMappings[args.Shard.Location].Add(new PointMapping <TKey>(this.Manager, this.Id, args));
}
// For each shardlocation bulk add all the mappings to local only.
ConcurrentQueue <Exception> exceptions = new ConcurrentQueue <Exception>();
Parallel.ForEach(pointMappings, (kvp) =>
{
try
{
this.lsm.AddLocals(kvp.Value, kvp.Key);
}
catch (Exception e)
{
exceptions.Enqueue(e);
}
});
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
// Rebuild the global from locals.
RecoveryManager recoveryManager = this.Manager.GetRecoveryManager();
recoveryManager.RebuildShardMapManager(pointMappings.Keys);
return(pointMappings.Values.SelectMany(x => x.AsEnumerable()));
}
public async Task RegisterAsync(ShardingRequestModel request, ILogger log)
{
var connectionBuilder = new SqlConnectionStringBuilder()
{
DataSource = _configuration["Sharding:MapManagerServer"],
InitialCatalog = "Tenant",
UserID = _configuration["Sharding:MapManagerId"],
Password = _configuration["Sharding:MapManagerPassword"],
ApplicationIntent = ApplicationIntent.ReadOnly,
ApplicationName = "idp-function"
};
var tenantConnection = new SqlConnection(connectionBuilder.ConnectionString);
var query = "select * from shardings with(nolock) where 1 = 1";
if (!string.IsNullOrEmpty(request.DatabaseName))
{
query += " and DatabaseName = @DatabaseName";
}
if (!string.IsNullOrEmpty(request.EnvironmentName))
{
query += " and EnvironmentName = @EnvironmentName";
}
if (!string.IsNullOrEmpty(request.ServiceName))
{
query += " and ServiceName = @ServiceName";
}
await tenantConnection.OpenAsync();
var shardings = await tenantConnection.QueryAsync <ShardingModel>(query, request, commandTimeout : 500);
await tenantConnection.CloseAsync();
foreach (var sharding in shardings)
{
ShardLocation shardLocation = new ShardLocation(sharding.ServerName, sharding.DatabaseName, SqlProtocol.Tcp, 1433);
RecoveryManager rm = _shardingProvider.ShardMapManager.GetRecoveryManager();
rm.DetachShard(shardLocation);
var key = $"{sharding.TenantId}_{sharding.ServiceName}_{sharding.EnvironmentName}".Replace("__", "_").ToLower();
log?.LogInformation($"Register {key}");
_shardingProvider.RegisterNewShard(Encoding.UTF8.GetBytes(key), sharding.ServerName, sharding.DatabaseName);
}
}
public static void ShardMapManagerLoadTestsCleanup()
{
// Clear all connection pools.
SqlConnection.ClearAllPools();
// Detect inconsistencies for all shard locations in a shard map.
ShardMapManager smm = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
RecoveryManager rm = new RecoveryManager(smm);
bool inconsistencyDetected = false;
foreach (ShardLocation sl in smm.GetDistinctShardLocations())
{
IEnumerable <RecoveryToken> gs = rm.DetectMappingDifferences(sl);
foreach (RecoveryToken g in gs)
{
var kvps = rm.GetMappingDifferences(g);
if (kvps.Keys.Count > 0)
{
inconsistencyDetected = true;
Debug.WriteLine("LSM at location {0} is not consistent with GSM", sl);
}
}
}
bool deadlocksDetected = false;
// Check for deadlocks during the run and cleanup database and deadlock objects on successful run
using (SqlConnection conn = new SqlConnection(Globals.ShardMapManagerTestConnectionString))
{
conn.Open();
// check for any deadlocks occured during the run and cleanup deadlock monitoring objects
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = s_deadlockDetectionQuery;
cmd.CommandType = System.Data.CommandType.Text;
try
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
// some deadlocks occured during the test, collect xml plan for these deadlocks
deadlocksDetected = true;
while (reader.Read())
{
Debug.WriteLine("Deadlock information");
Debug.WriteLine(reader.GetSqlXml(0).Value);
}
}
}
}
catch (SqlException)
{
}
}
// cleanup only if there are no inconsistencies and deadlocks during the run.
if (!deadlocksDetected && !inconsistencyDetected)
{
foreach (string q in s_deadlockDetectionCleanupQueries)
{
using (SqlCommand cmd = new SqlCommand(q, conn))
{
try
{
cmd.ExecuteNonQuery();
}
catch (SqlException)
{
}
}
}
// Drop shard databases
for (int i = 0; i < ShardMapManagerLoadTests.s_shardedDBs.Length; i++)
{
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.DropDatabaseQuery, ShardMapManagerLoadTests.s_shardedDBs[i]),
conn))
{
cmd.ExecuteNonQuery();
}
}
// Drop shard map manager database
using (SqlCommand cmd = new SqlCommand(
string.Format(Globals.DropDatabaseQuery, Globals.ShardMapManagerDatabaseName),
conn))
{
cmd.ExecuteNonQuery();
}
}
}
}
private bool HandleActivationConditions(Constants.AbilityActivationCondition[] conditions)
{
bool result = false;
if (RecoveryManager.HasRecovery == false)
{
return(true);
}
bool freeActivation = conditions.Contains(Constants.AbilityActivationCondition.IgnoreCost) && conditions.Contains(Constants.AbilityActivationCondition.IgnoreRecovery);
if (freeActivation)
{
return(true);
}
if (conditions.Contains(Constants.AbilityActivationCondition.Normal) || conditions.Length < 1)
{
//Check For Resource
result = RecoveryManager.HasCharges;
//Debug.Log(abilityName + " has charges to spend " + result);
//Debug.Log(RecoveryManager.Charges + " charges left on " + abilityName);
if (result == true)
{
RecoveryManager.SpendCharge();
//Spend Resource
}
BufferMe(result);
return(result);
}
if (conditions.Contains(Constants.AbilityActivationCondition.IgnoreRecovery))
{
//Check For Resource
//Spend Resource
}
if (conditions.Contains(Constants.AbilityActivationCondition.IgnoreCost))
{
result = RecoveryManager.HasCharges;
if (result == true)
{
RecoveryManager.SpendCharge();
}
BufferMe(result);
return(result);
}
if (Source.Entity() is EntityEnemy)
{
EntityEnemy baddie = Source.Entity() as EntityEnemy;
if (MeetsRequiredConditions(baddie.AISensor.ClosestTarget) == false)
{
result = false;
}
}
else
{
if (MeetsRequiredConditions(null) == false)
{
//Debug.Log(abilityName + " failed to meet requirements");
result = false;
}
}
BufferMe(result);
return(result);
}
private bool HandleActivationConditions(Constants.AbilityActivationCondition[] conditions)
{
//Debug.Log("handeling activation conditions");
bool result = false;
if (RecoveryManager.HasRecovery == false)
{
result = true;
}
bool freeActivation = conditions.Contains(Constants.AbilityActivationCondition.IgnoreCost) && conditions.Contains(Constants.AbilityActivationCondition.IgnoreRecovery);
if (freeActivation)
{
result = true;
}
if (conditions.Contains(Constants.AbilityActivationCondition.Normal) || conditions.Length < 1)
{
//Check For Resource
result = RecoveryManager.HasCharges;
//Debug.Log(abilityName + " has charges to spend " + result);
//Debug.Log(RecoveryManager.Charges + " charges left on " + abilityName);
if (result == true)
{
RecoveryManager.SpendCharge();
//Spend Resource
}
//BufferMe(result);
//re result;
}
if (conditions.Contains(Constants.AbilityActivationCondition.IgnoreRecovery))
{
//Check For Resource
//Spend Resource
}
if (conditions.Contains(Constants.AbilityActivationCondition.IgnoreCost))
{
result = RecoveryManager.HasCharges;
if (result == true)
{
RecoveryManager.SpendCharge();
}
BufferMe(result);
return(result);
}
if (Source.Entity() is EntityEnemy)
{
EntityEnemy baddie = Source.Entity() as EntityEnemy;
if (MeetsRequiredConditions(baddie.AISensor.ClosestTarget) == false)
{
result = false;
}
}
else
{
//Debug.Log("Checking conditions for " + abilityName + " at the ability level");
if (MeetsRequiredConditions(null) == false)
{
//Debug.Log(abilityName + " failed to meet requirements");
result = false;
}
}
if (ParentAbility != null)
{
result = IsSequenceRight();
}
//Debug.Log("Result for handle activatons is " + result);
BufferMe(result);
return(result);
}
