/// <summary>
/// Sends CharacterUnlock to creature's client.
/// </summary>
public static void CharacterUnlock(Creature creature, Locks type)
{
var packet = new Packet(Op.CharacterUnlock, creature.EntityId);
packet.PutUInt((uint)type);
creature.Client.Send(packet);
}
private IProjectFile GetOrCreateSameDestinationFile(
[NotNull] IProjectModelTransactionCookie cookie,
[NotNull] IT4File file,
[NotNull] string destinationName
)
{
Locks.AssertWriteAccessAllowed();
var existingFile = GetSameDestinationFile(file, destinationName);
if (existingFile != null)
{
return(existingFile);
}
return(CreateSameDestinationFile(cookie, file, destinationName));
}
/// <summary>
/// Gets the active locks.
/// </summary>
/// <returns></returns>
public IEnumerable <Lock.Lock> GetActiveLocks()
{
if (Locks == null)
{
return(Enumerable.Empty <Lock.Lock>());
}
var now = DateTime.Now;
var activeLocks = Locks
.Where(l => l.UnlockedAt > now || l.UnlockedAt == default(DateTime))
.ToList();
return(activeLocks);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private void assertLocksHeld(final Long... expectedResourceIds)
private void AssertLocksHeld(params Long[] expectedResourceIds)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<long> expectedLockedIds = java.util.Arrays.asList(expectedResourceIds);
IList <long> expectedLockedIds = Arrays.asList(expectedResourceIds);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<long> seenLockedIds = new java.util.ArrayList<>();
IList <long> seenLockedIds = new List <long>();
Locks.accept((resourceType, resourceId, description, estimatedWaitTime, lockIdentityHashCode) => seenLockedIds.Add(resourceId));
expectedLockedIds.Sort();
seenLockedIds.Sort();
assertEquals("unexpected locked resource ids", expectedLockedIds, seenLockedIds);
}
public void CreateLockTest()
{
long currentMaxId = GetMaxLocksId();
Lock l = new Lock();
l.IpAddress = "10.20.1.1";
l.LockDate = DateTime.Now;
l.UnlockDate = DateTime.Now.AddDays(1);
l.Port = 0;
l.Status = Lock.LOCK_STATUS_HARDLOCK;
l.NumberOfSoftLocks = 2;
l.TriggerIncident = 100;
l.Id = Locks.CreateLock(l);
Assert.AreEqual(currentMaxId + 1, l.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustReleaseUnpreparedLocksOnStop()
public virtual void MustReleaseUnpreparedLocksOnStop()
{
// Given
ClientA.acquireShared(_tracer, NODE, 1L);
ClientA.acquireExclusive(_tracer, NODE, 2L);
// When
ClientA.stop();
// The client was stopped before it could enter the prepare phase, so all of its locks are released
LockCountVisitor lockCountVisitor = new LockCountVisitor();
Locks.accept(lockCountVisitor);
assertEquals(0, lockCountVisitor.LockCount);
}
public bool TryGetOrCreateResourceStore(string tenantId, out Task <RavenFileSystem> fileSystem)
{
if (ResourcesStoresCache.TryGetValue(tenantId, out fileSystem))
{
if (fileSystem.IsFaulted || fileSystem.IsCanceled)
{
ResourcesStoresCache.TryRemove(tenantId, out fileSystem);
DateTime time;
LastRecentlyUsed.TryRemove(tenantId, out time);
// and now we will try creating it again
}
else
{
return(true);
}
}
if (Locks.Contains(tenantId))
{
throw new InvalidOperationException("FileSystem '" + tenantId + "' is currently locked and cannot be accessed");
}
var config = CreateTenantConfiguration(tenantId);
if (config == null)
{
return(false);
}
fileSystem = ResourcesStoresCache.GetOrAdd(tenantId, __ => Task.Factory.StartNew(() =>
{
var transportState = ResourseTransportStates.GetOrAdd(tenantId, s => new TransportState());
var fs = new RavenFileSystem(config, tenantId, transportState);
AssertLicenseParameters();
// if we have a very long init process, make sure that we reset the last idle time for this db.
LastRecentlyUsed.AddOrUpdate(tenantId, SystemTime.UtcNow, (_, time) => SystemTime.UtcNow);
return(fs);
}).ContinueWith(task =>
{
if (task.Status == TaskStatus.Faulted) // this observes the task exception
{
Logger.WarnException("Failed to create filesystem " + tenantId, task.Exception);
}
return(task);
}).Unwrap());
return(true);
}
private void Disposition(WaitKey key, Action <PendingWait> action)
{
if (Waits.TryGetValue(key, out var queue) && queue.TryDequeue(out var wait))
{
action(wait);
wait.Dispose();
if (Locks.TryGetValue(key, out var recordLock))
{
// enter a read lock first; TryPeek and TryDequeue are atomic so there's no risky operation until later.
recordLock.EnterUpgradeableReadLock();
try
{
// clean up entries in the Waits and Locks dictionaries if the corresponding ConcurrentQueue is empty. this is
// tricky, because we don't want to remove a record if another thread is in the process of enqueueing a new wait.
if (queue.IsEmpty)
{
// enter the write lock to prevent Wait() (which obtains a read lock) from enqueing any more waits before
// we can delete the dictionary record. it's ok and expected that Wait() might add this record back to the
// dictionary as soon as this unblocks; we're preventing new waits from being discarded if they are added
// by another thread just prior to the TryRemove() operation below.
recordLock.EnterWriteLock();
try
{
// check the queue again to ensure Wait() didn't enqueue anything between the last check and when we
// entered the write lock. this is guarateed to be safe since we now have exclusive access to the
// record and it should be impossible to remove a record containing a non-empty queue
if (queue.IsEmpty)
{
Waits.TryRemove(key, out _);
Locks.TryRemove(key, out _);
}
}
finally
{
recordLock.ExitWriteLock();
}
}
}
finally
{
recordLock.ExitUpgradeableReadLock();
}
}
}
}
public override async Task <bool> ShouldShowAsync(AccountDataItem account)
{
// Don't show for offline accounts or for devices that aren't Desktop
if (account == null || !account.IsOnlineAccount || InterfacesUWP.DeviceInfo.DeviceFamily != InterfacesUWP.DeviceFamily.Desktop)
{
return(false);
}
if (ApplicationData.Current.RoamingSettings.Values.ContainsKey(SETTING_HAS_PROMOTED_ANDROID_AND_IOS))
{
return(false);
}
var dataStore = await AccountDataStore.Get(account.LocalAccountId);
// If they actually have some classes
bool hasContent;
using (await Locks.LockDataForReadAsync())
{
hasContent = dataStore.TableClasses.Count() > 1;
}
if (hasContent)
{
// Try downloading and then show
ShouldSuggestOtherPlatformsResponse response = await account.PostAuthenticatedAsync <ShouldSuggestOtherPlatformsRequest, ShouldSuggestOtherPlatformsResponse>(
Website.URL + "shouldsuggestotherplatforms",
new ShouldSuggestOtherPlatformsRequest()
{
CurrentPlatform = "Windows 10"
});
if (response.ShouldSuggest)
{
return(true);
}
// No need to suggest in the future nor show now
MarkShown(account);
return(false);
}
else
{
// Not enough content to show right now
return(false);
}
}
private static async Task <ClassData> LoadDataBlocking(AccountDataStore data, Guid classId, DateTime todayAsUtc, ClassTileSettings settings)
{
DateTime dateToStartDisplayingFrom = DateTime.SpecifyKind(settings.GetDateToStartDisplayingOn(todayAsUtc), DateTimeKind.Local);
Guid semesterId = Guid.Empty;
// We lock the outside, since we are allowing trackChanges on the view items groups (so we have a chance of loading a cached one)... and since we're on a background thread, the lists inside the
// view items groups could change while we're enumerating, hence throwing an exception. So we lock it to ensure this won't happen, and then we return a copy of the items that we need.
using (await Locks.LockDataForReadAsync())
{
// First we need to obtain the semester id
var c = data.TableClasses.FirstOrDefault(i => i.Identifier == classId);
if (c == null)
{
return(null);
}
semesterId = c.UpperIdentifier;
}
// We need all classes loaded, to know what time the end of day is
var scheduleViewItemsGroup = await ScheduleViewItemsGroup.LoadAsync(data.LocalAccountId, semesterId, trackChanges : true, includeWeightCategories : false);
var classViewItemsGroup = await ClassViewItemsGroup.LoadAsync(
localAccountId : data.LocalAccountId,
classId : classId,
today : DateTime.SpecifyKind(todayAsUtc, DateTimeKind.Local),
viewItemSemester : scheduleViewItemsGroup.Semester,
includeWeights : false);
classViewItemsGroup.LoadTasksAndEvents();
await classViewItemsGroup.LoadTasksAndEventsTask;
List <ViewItemTaskOrEvent> copied;
using (await classViewItemsGroup.DataChangeLock.LockForReadAsync())
{
// Class view group sorts the items, so no need to sort
copied = classViewItemsGroup.Class.TasksAndEvents.Where(i => i.Date.Date >= dateToStartDisplayingFrom).ToList();
}
return(new ClassData()
{
Class = classViewItemsGroup.Class,
AllUpcoming = copied
});
}
public bool TryGetOrCreateResourceStore(string tenantId, out Task <DocumentDatabase> database)
{
if (ResourcesStoresCache.TryGetValue(tenantId, out database))
{
if (database.IsFaulted || database.IsCanceled)
{
ResourcesStoresCache.TryRemove(tenantId, out database);
DateTime time;
LastRecentlyUsed.TryRemove(tenantId, out time);
// and now we will try creating it again
}
else
{
return(true);
}
}
if (Locks.Contains(tenantId))
{
throw new InvalidOperationException("Database '" + tenantId + "' is currently locked and cannot be accessed");
}
var config = CreateTenantConfiguration(tenantId);
if (config == null)
{
return(false);
}
database = ResourcesStoresCache.GetOrAdd(tenantId, __ => Task.Factory.StartNew(() =>
{
var documentDatabase = new DocumentDatabase(config);
AssertLicenseParameters(config);
documentDatabase.SpinBackgroundWorkers();
// if we have a very long init process, make sure that we reset the last idle time for this db.
LastRecentlyUsed.AddOrUpdate(tenantId, SystemTime.UtcNow, (_, time) => SystemTime.UtcNow);
return(documentDatabase);
}).ContinueWith(task =>
{
if (task.Status == TaskStatus.Faulted) // this observes the task exception
{
Logger.WarnException("Failed to create database " + tenantId, task.Exception);
}
return(task);
}).Unwrap());
return(true);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void prepareMustAllowAcquiringNewLocksAfterStop()
public virtual void PrepareMustAllowAcquiringNewLocksAfterStop()
{
// Given
ClientA.prepare();
ClientA.stop();
// When
ClientA.acquireShared(_tracer, NODE, 1);
ClientA.acquireExclusive(_tracer, NODE, 2);
// Stopped essentially has no effect when it comes after the client has entered the prepare phase
LockCountVisitor lockCountVisitor = new LockCountVisitor();
Locks.accept(lockCountVisitor);
assertEquals(2, lockCountVisitor.LockCount);
}
/// <inheritdoc/>
protected override void OnDisposeStarted()
{
// We are under tree lock here
// ---------------------------------------------------------
// This method is not reenterant.
// ---------------------------------------------------------
_locks.ForEach(x => x.PulseDispose());
if (Locks.All(x => x is IxInstanceChildLock))
{
SetDisposeSuspended(false);
}
base.OnDisposeStarted();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustNotReleaseLocksAfterPrepareOnStop()
public virtual void MustNotReleaseLocksAfterPrepareOnStop()
{
// Given
ClientA.acquireShared(_tracer, NODE, 1L);
ClientA.acquireExclusive(_tracer, NODE, 2L);
ClientA.prepare();
// When
ClientA.stop();
// The client entered the prepare phase, so it gets to keep its locks
LockCountVisitor lockCountVisitor = new LockCountVisitor();
Locks.accept(lockCountVisitor);
assertEquals(2, lockCountVisitor.LockCount);
}
private void UpdateDisposeSuspendState()
{
try
{
bool nonChildLocksExists = !Locks.All(x => x is IxInstanceChildLock);
SetDisposeSuspended(nonChildLocksExists);
if (!nonChildLocksExists && ProviderNode.AutoDisposeEnabled)
{
DisposeAsync();
}
}
catch (InvalidOperationException)
{
Critical.Assert(false, "Cannot set lock, self dispose was started.");
}
}
private IProjectFile GetSameDestinationFile([NotNull] IT4File file, [NotNull] string temporaryName)
{
Locks.AssertWriteAccessAllowed();
var sourceFile = file.PhysicalPsiSourceFile.NotNull();
var candidates = sourceFile
.ToProjectFile()
?.ParentFolder
?.GetSubItems(temporaryName)
.ToList()
.OfType <IProjectFile>()
.AsList();
Assertion.AssertNotNull(candidates, "candidates != null");
Assertion.Assert(candidates.Count <= 1, "candidates.Value.Length <= 1");
return(candidates.SingleOrDefault());
}
private static void Release([NotNull] object key)
{
InnerLock _lock;
lock (Locks)
{
lock (_lock = Locks[key])
{
_lock.Release();
if (_lock.CanDispose)
{
Locks.Remove(key);
_lock.Dispose();
}
}
}
}
public static void UpdateActorLocks(AbstractActor source, ICombatant target, VisualScanType visualLock, SensorScanType sensorLock)
{
if (source != null && target != null)
{
Locks newLocks = new Locks(source, target, visualLock, sensorLock);
if (PlayerActorLocks.ContainsKey(source.GUID))
{
PlayerActorLocks[source.GUID][target.GUID] = newLocks;
}
else
{
PlayerActorLocks[source.GUID] = new Dictionary <string, Locks> {
[target.GUID] = newLocks
};
}
}
}
public override void BeforeSave(Sungero.Domain.BeforeSaveEventArgs e)
{
// Проверка шаблона сайта.
if (!string.IsNullOrEmpty(_obj.Url))
{
_obj.Url = _obj.Url.Trim();
var error = Functions.DueDiligenceWebsite.CheckDueDiligenceWebsiteUrl(_obj.Url);
if (!string.IsNullOrWhiteSpace(error))
{
e.AddError(_obj.Info.Properties.Url, error);
}
}
// Проверка шаблона сайта (ИП).
if (!string.IsNullOrEmpty(_obj.UrlForSelfEmployed))
{
_obj.UrlForSelfEmployed = _obj.UrlForSelfEmployed.Trim();
var error = Functions.DueDiligenceWebsite.CheckDueDiligenceWebsiteUrl(_obj.UrlForSelfEmployed);
if (!string.IsNullOrWhiteSpace(error))
{
e.AddError(_obj.Info.Properties.UrlForSelfEmployed, error);
}
}
// Если установить для текущего сайта флаг по умолчанию, то с другого сайта этот флаг снимается.
if (_obj.IsDefault == true)
{
var defaultWebsite = Functions.DueDiligenceWebsite.GetDefaultDueDiligenceWebsite();
if (defaultWebsite != null && !Equals(defaultWebsite, _obj))
{
var lockInfo = Locks.GetLockInfo(defaultWebsite);
if (lockInfo != null && lockInfo.IsLocked)
{
var error = Commons.Resources.LinkedEntityLockedFormat(
defaultWebsite.Name,
defaultWebsite.Id,
lockInfo.OwnerName);
e.AddError(error);
}
defaultWebsite.IsDefault = false;
}
}
_obj.HomeUrl = _obj.HomeUrl.Trim();
}
public T4BuildResult Compile(Lifetime lifetime, IPsiSourceFile sourceFile)
{
Logger.Verbose("Compiling a file");
Locks.AssertReadAccessAllowed();
// Since we need no context when compiling a file, we need to build the tree manually
var file = sourceFile.BuildT4Tree();
var error = file.ThisAndDescendants<IErrorElement>().Collect();
if (!error.IsEmpty()) return Converter.SyntaxErrors(error);
return lifetime.UsingNested(nested =>
{
try
{
// Prepare the code
var references = ReferenceExtractionManager.ExtractPortableReferencesTransitive(lifetime, file);
string code = GenerateCode(file);
// Prepare the paths
var executablePath = TargetManager.GetTemporaryExecutableLocation(file);
var compilation = CreateCompilation(code, references, executablePath);
executablePath.Parent.CreateDirectory();
var pdbPath = executablePath.Parent.Combine(executablePath.Name.WithOtherExtension("pdb"));
// Delegate to Roslyn
var emitOptions = new EmitOptions(
debugInformationFormat: DebugInformationFormat.PortablePdb,
pdbFilePath: pdbPath.FullPath
);
using var executableStream = executablePath.OpenFileForWriting();
using var pdbStream = pdbPath.OpenFileForWriting();
var emitResult = compilation.Emit(
peStream: executableStream,
pdbStream: pdbStream,
options: emitOptions,
cancellationToken: nested
);
return Converter.ToT4BuildResult(emitResult.Diagnostics.AsList(), file);
}
catch (T4OutputGenerationException e)
{
return Converter.ToT4BuildResult(e);
}
});
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mustReleaseReadLockWaitersOnStop()
public virtual void MustReleaseReadLockWaitersOnStop()
{
// Given
ClientA.acquireExclusive(_tracer, NODE, 1L);
ClientB.acquireExclusive(_tracer, NODE, 2L);
AcquireShared(ClientB, _tracer, NODE, 1L).callAndAssertWaiting();
// When
ClientB.stop();
ClientA.stop();
// All locks clients should be stopped at this point, and all all locks should be released because none of the
// clients entered the prepare phase
LockCountVisitor lockCountVisitor = new LockCountVisitor();
Locks.accept(lockCountVisitor);
assertEquals(0, lockCountVisitor.LockCount);
}
public static void SaveLog(string testName, string log)
{
if (!Locks.TryGetValue(testName, out var lockObject))
{
lockObject = new object();
if (!Locks.TryAdd(testName, lockObject))
{
lockObject = Locks[testName];
}
}
lock (lockObject)
{
var filePath = System.IO.Path.Combine(Path, testName + ".txt");
Directory.CreateDirectory(Path);
File.AppendAllLines(filePath, new[] { log });
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void SetUp()
{
_master = mock(typeof(Master));
_databaseAvailabilityGuard = new DatabaseAvailabilityGuard(DEFAULT_DATABASE_NAME, Clocks.fakeClock(), Instance);
_lockManager = new CommunityLockManger(Config.defaults(), Clocks.systemClock());
_local = spy(_lockManager.newClient());
_logProvider = new AssertableLogProvider();
LockResult lockResultOk = new LockResult(LockStatus.OkLocked);
TransactionStreamResponse <LockResult> responseOk = new TransactionStreamResponse <LockResult>(lockResultOk, null, Org.Neo4j.com.TransactionStream_Fields.Empty, Org.Neo4j.com.ResourceReleaser_Fields.NoOp);
WhenMasterAcquireShared().thenReturn(responseOk);
WhenMasterAcquireExclusive().thenReturn(responseOk);
_client = new SlaveLocksClient(_master, _local, _lockManager, mock(typeof(RequestContextFactory)), _databaseAvailabilityGuard, _logProvider);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void loadSimpleStatementLocksFactoryWhenNoServices()
public virtual void LoadSimpleStatementLocksFactoryWhenNoServices()
{
Locks locks = mock(typeof(Locks));
Locks_Client locksClient = mock(typeof(Locks_Client));
when(locks.NewClient()).thenReturn(locksClient);
StatementLocksFactorySelector loader = NewLoader(locks);
StatementLocksFactory factory = loader.Select();
StatementLocks statementLocks = factory.NewInstance();
assertThat(factory, instanceOf(typeof(SimpleStatementLocksFactory)));
assertThat(statementLocks, instanceOf(typeof(SimpleStatementLocks)));
assertSame(locksClient, statementLocks.Optimistic());
assertSame(locksClient, statementLocks.Pessimistic());
}
public override async Task <T> InvokeAndStrip(
ComputeMethodInput input, IComputed?usedBy, ComputeContext?context,
CancellationToken cancellationToken = default)
{
context ??= ComputeContext.Current;
ResultBox <T>?output;
// Read-Lock-RetryRead-Compute-Store pattern
var computed = TryGetExisting(input);
if (computed != null)
{
output = await computed.TryUseExisting(context, usedBy, cancellationToken)
.ConfigureAwait(false);
if (output != null)
{
return(output.Value);
}
}
using var @lock = await Locks.Lock(input, cancellationToken).ConfigureAwait(false);
computed = TryGetExisting(input);
if (computed != null)
{
output = await computed.TryUseExisting(context, usedBy, cancellationToken)
.ConfigureAwait(false);
if (output != null)
{
return(output.Value);
}
}
computed = (IAsyncComputed <T>) await Compute(input, computed, cancellationToken)
.ConfigureAwait(false);
var rOutput = computed.Output; // RenewTimeouts isn't called yet, so it's ok
computed.UseNew(context, usedBy);
return(rOutput !.Value);
}
private ConcurrentBigSet(
int concurrencyLevel,
BigBuffer <TItem> backingItemsBuffer,
BigBuffer <Node> backingNodesBuffer,
Buckets backingBuckets,
int nodeLength,
int capacity = DefaultCapacity,
int ratio = DefaultBucketToItemsRatio,
int itemsPerEntryBufferBitWidth = 12)
{
Contract.Requires(concurrencyLevel >= 1);
Contract.Requires(ratio >= 1);
concurrencyLevel = Math.Max(concurrencyLevel, MinConcurrencyLevel);
if (concurrencyLevel > capacity)
{
capacity = concurrencyLevel;
}
var actualConcurrencyLevel = (int)Bits.HighestBitSet((uint)concurrencyLevel);
var actualCapacity = (int)Bits.HighestBitSet((uint)capacity);
capacity = capacity > actualCapacity ? actualCapacity << 1 : actualCapacity;
concurrencyLevel = concurrencyLevel > actualConcurrencyLevel ? actualConcurrencyLevel << 1 : actualConcurrencyLevel;
m_locks = new Locks(concurrencyLevel);
// Create free node pointer for every lock
m_freeNodes = new int[m_locks.Length];
for (int i = 0; i < m_freeNodes.Length; i++)
{
m_freeNodes[i] = -1;
}
m_lockBitMask = concurrencyLevel - 1;
m_items = backingItemsBuffer ?? new BigBuffer <TItem>(itemsPerEntryBufferBitWidth);
m_nodes = backingNodesBuffer ?? new BigBuffer <Node>(NodesPerEntryBufferBitWidth);
m_buckets = backingBuckets ?? new Buckets(capacity, ratio);
m_nodeLength = nodeLength;
m_accessors = new Accessors(this);
}
public void BeginGuardedOperation()
{
lock (sync)
{
if (lockID == Guid.Empty)
{
throw new InvalidOperationException("Guarded operation " +
"was blocked because no lock has been obtained.");
}
object currentLock;
Locks.TryGetValue(lockID, out currentLock);
if (currentLock != SlotMarker)
{
throw new InvalidOperationException("Guarded operation " +
"was blocked because the lock was obtained on a " +
"different thread from the calling thread.");
}
}
}
public override void Deleting(Sungero.Domain.DeletingEventArgs e)
{
var document = _obj.DocumentGroup.OfficialDocuments.FirstOrDefault();
if (document == null || Locks.GetLockInfo(document).IsLocked)
{
return;
}
// Удалить записи о выдаче документа (иначе не даст удалить из-за зависимостей).
var tracking = document.Tracking.Where(r => Equals(r.ReturnTask, _obj)).ToList();
foreach (var row in tracking)
{
row.ReturnTask = null;
}
document.Save();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static KernelTransactions newKernelTransactions(boolean testKernelTransactions, TransactionCommitProcess commitProcess, org.neo4j.storageengine.api.StorageReader firstReader, org.neo4j.storageengine.api.StorageReader... otherReaders) throws Throwable
private static KernelTransactions NewKernelTransactions(bool testKernelTransactions, TransactionCommitProcess commitProcess, StorageReader firstReader, params StorageReader[] otherReaders)
{
Locks locks = mock(typeof(Locks));
Org.Neo4j.Kernel.impl.locking.Locks_Client client = mock(typeof(Org.Neo4j.Kernel.impl.locking.Locks_Client));
when(locks.NewClient()).thenReturn(client);
StorageEngine storageEngine = mock(typeof(StorageEngine));
when(storageEngine.NewReader()).thenReturn(firstReader, otherReaders);
doAnswer(invocation =>
{
ICollection <StorageCommand> argument = invocation.getArgument(0);
argument.add(mock(typeof(StorageCommand)));
return(null);
}).when(storageEngine).createCommands(anyCollection(), any(typeof(ReadableTransactionState)), any(typeof(StorageReader)), any(typeof(ResourceLocker)), anyLong(), any(typeof(TxStateVisitor.Decorator)));
return(NewKernelTransactions(locks, storageEngine, commitProcess, testKernelTransactions));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void newInstanceCreatesDeferredLocksWhenConfigSet()
public virtual void NewInstanceCreatesDeferredLocksWhenConfigSet()
{
Locks locks = mock(typeof(Locks));
Locks_Client client = mock(typeof(Locks_Client));
when(locks.NewClient()).thenReturn(client);
Config config = Config.defaults(deferred_locks_enabled, Settings.TRUE);
DeferringStatementLocksFactory factory = new DeferringStatementLocksFactory();
factory.Initialize(locks, config);
StatementLocks statementLocks = factory.NewInstance();
assertThat(statementLocks, instanceOf(typeof(DeferringStatementLocks)));
assertThat(statementLocks.Optimistic(), instanceOf(typeof(DeferringLockClient)));
assertSame(client, statementLocks.Pessimistic());
}
public override void BeforeSave(Sungero.Domain.BeforeSaveEventArgs e)
{
Functions.Employee.UpdateName(_obj, _obj.Person);
if (string.IsNullOrEmpty(_obj.Name))
{
_obj.Name = " ";
}
if (!Functions.Employee.IsValidEmail(_obj.Email))
{
e.AddWarning(_obj.Info.Properties.Email, Parties.Resources.WrongEmailFormat);
}
else if (!Docflow.PublicFunctions.Module.IsASCII(_obj.Email))
{
e.AddWarning(_obj.Info.Properties.Email, Docflow.Resources.ASCIIWarning);
}
var oldDepartment = _obj.State.Properties.Department.OriginalValue;
var newDepartment = _obj.Department;
if (!Equals(oldDepartment, newDepartment))
{
if (newDepartment != null)
{
var newDepartmentLockInfo = Locks.GetLockInfo(newDepartment);
if (newDepartmentLockInfo.IsLockedByOther)
{
e.AddError(Employees.Resources.DeparmentLockedByUserFormat(newDepartment.Name, newDepartmentLockInfo.OwnerName));
}
}
if (oldDepartment != null)
{
var oldDepartmentLockInfo = Locks.GetLockInfo(oldDepartment);
if (oldDepartmentLockInfo.IsLockedByOther)
{
e.AddError(Employees.Resources.DeparmentLockedByUserFormat(oldDepartment.Name, oldDepartmentLockInfo.OwnerName));
}
}
}
}
