Пример #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void failedInstanceShouldReceiveCorrectCoordinatorIdUponRejoiningCluster() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void FailedInstanceShouldReceiveCorrectCoordinatorIdUponRejoiningCluster()
        {
            // Given
            HighlyAvailableGraphDatabase initialMaster = _cluster.Master;

            // When
            _cluster.shutdown(initialMaster);
            _cluster.await(masterAvailable(initialMaster));
            _cluster.await(masterSeesSlavesAsAvailable(1));

            // create node on new master to ensure that it has the greatest tx id
            CreateNodeOn(_cluster.Master);
            _cluster.sync();

            LifeSupport         life          = new LifeSupport();
            ClusterClientModule clusterClient = NewClusterClient(life, new InstanceId(1));

            Cleanup.add(life);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.cluster.InstanceId> coordinatorIdWhenReJoined = new java.util.concurrent.atomic.AtomicReference<>();
            AtomicReference <InstanceId> coordinatorIdWhenReJoined = new AtomicReference <InstanceId>();

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch latch = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
            clusterClient.ClusterClient.addClusterListener(new ClusterListener_AdapterAnonymousInnerClass(this, coordinatorIdWhenReJoined, latch));

            life.Start();

            // Then
            assertTrue(latch.await(20, SECONDS));
            assertEquals(new InstanceId(2), coordinatorIdWhenReJoined.get());
        }
Пример #2
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHaveConfigurableJettyThreadPoolSize() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldHaveConfigurableJettyThreadPoolSize()
        {
            Jetty9WebServer server               = new Jetty9WebServer(NullLogProvider.Instance, Config.defaults(), NetworkConnectionTracker.NO_OP);
            int             numCores             = 1;
            int             configuredMaxThreads = 12;                                                       // 12 is the new min max Threads value, for one core
            int             acceptorThreads      = 1;                                                        // In this configuration, 1 thread will become an acceptor...
            int             selectorThreads      = 1;                                                        // ... and 1 thread will become a selector...
            int             jobThreads           = configuredMaxThreads - acceptorThreads - selectorThreads; // ... and the rest are job threads

            server.MaxThreads  = numCores;
            server.HttpAddress = new ListenSocketAddress("localhost", 0);
            try
            {
                server.Start();
                QueuedThreadPool threadPool = ( QueuedThreadPool )server.Jetty.ThreadPool;
                threadPool.start();
                System.Threading.CountdownEvent startLatch = new System.Threading.CountdownEvent(jobThreads);
                System.Threading.CountdownEvent endLatch   = LoadThreadPool(threadPool, configuredMaxThreads + 1, startLatch);
                startLatch.await();                         // Wait for threadPool to create threads
                int threads = threadPool.Threads;
                assertEquals("Wrong number of threads in pool", configuredMaxThreads, threads);
                endLatch.Signal();
            }
            finally
            {
                server.Stop();
            }
        }
Пример #3
0
 public Crawler(int numFrontQueues, int numBackQueues, TimeSpan timebetweenVisits, TimeSpan maxAgeOfRobots, IEnumerable<PrettyURL> seed, ConcurrentQueue<Tuple<PrettyURL, string, DateTime>> queue, System.Threading.CountdownEvent cte)
 {
     Robot_IAm = new RobotsStuff(maxAgeOfRobots);
     Mercator_IAm = new Mercator(numFrontQueues, numBackQueues, timebetweenVisits, seed);
     CrawledQueue = queue;
     CTE = cte;
 }
        public virtual void test_combineFuturesAsMap_exception()
        {
            CompletableFuture <string> future1 = new CompletableFuture <string>();

            future1.complete("A");
            System.Threading.CountdownEvent latch   = new System.Threading.CountdownEvent(1);
            CompletableFuture <string>      future2 = CompletableFuture.supplyAsync(() =>
            {
                try
                {
                    latch.await();
                }
                catch (InterruptedException)
                {
                }
                throw new System.InvalidOperationException("Oops");
            });
            IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2);

            CompletableFuture <IDictionary <string, string> > test = Guavate.combineFuturesAsMap(input);

            assertEquals(test.Done, false);
            latch.Signal();
            assertThrows(typeof(CompletionException), () => test.join());
            assertEquals(test.Done, true);
            assertEquals(test.CompletedExceptionally, true);
        }
Пример #5
0
        private void SendCommandASynch()
        {
            countDown = new System.Threading.CountdownEvent(1);

            foreach (DataGridViewRow row in dgvComputers.Rows)
            {
                if (!_closing && !_wrongCrendentialsWatcher.IsAbortRequested)
                {
                    countDown.AddCount();
                    CommandParameters parameters = GetCommonParameters();
                    parameters.Row            = row;
                    parameters.TargetComputer = (ADComputer)row.Cells["ADComputer"].Value;

                    parameters.Login    = _login;
                    parameters.Password = _password;
                    System.Threading.ThreadPool.QueueUserWorkItem(SendCommandToComputer, (object)parameters);
                }
            }
            countDown.Signal();
            countDown.Wait(5000 * dgvComputers.Rows.Count);
            DisplayProgress();
            Action action = () =>
            {
                dgvComputers.Sort(dgvComputers.Columns["Result"], ListSortDirection.Descending);
                btnClose.Enabled = true;
                btnAbort.Enabled = false;
            };

            if (!_closing)
            {
                this.Invoke(action);
            }
        }
        public virtual void test_toCombinedFutureMap()
        {
            CompletableFuture <string> future1 = new CompletableFuture <string>();

            future1.complete("A");
            System.Threading.CountdownEvent latch   = new System.Threading.CountdownEvent(1);
            CompletableFuture <string>      future2 = CompletableFuture.supplyAsync(() =>
            {
                try
                {
                    latch.await();
                }
                catch (InterruptedException)
                {
                }
                return("B");
            });
            IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2);

//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
            CompletableFuture <IDictionary <string, string> > test = input.SetOfKeyValuePairs().collect(Guavate.toCombinedFutureMap());

            assertEquals(test.Done, false);
            latch.Signal();
            IDictionary <string, string> combined = test.join();

            assertEquals(test.Done, true);
            assertEquals(combined.Count, 2);
            assertEquals(combined["a"], "A");
            assertEquals(combined["b"], "B");
        }
Пример #7
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static void await(java.util.concurrent.CountDownLatch latch) throws InterruptedException
        private static void Await(System.Threading.CountdownEvent latch)
        {
            if (!latch.await(1, TimeUnit.MINUTES))
            {
                fail("Count down did not happen");
            }
        }
Пример #8
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldMutexAccessBetweenInvalidateAndinstance() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldMutexAccessBetweenInvalidateAndinstance()
        {
            // GIVEN
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch latch = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger initCalls = new java.util.concurrent.atomic.AtomicInteger();
            AtomicInteger             initCalls = new AtomicInteger();
            LazySingleReference <int> @ref      = new LazySingleReferenceAnonymousInnerClass2(this, latch, initCalls);
            Future <int> t1Evaluate             = _t1.executeDontWait(Evaluate(@ref));

            _t1.waitUntilWaiting();

            // WHEN
            Future <Void> t2Invalidate = _t2.executeDontWait(Invalidate(@ref));

            _t2.waitUntilBlocked();
            latch.Signal();
            int e = t1Evaluate.get();

            t2Invalidate.get();

            // THEN
            assertEquals("Evaluation", 1, e);
        }
Пример #9
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStopLockSessionOnFailureWhereThereIsAnActiveLockAcquisition() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldStopLockSessionOnFailureWhereThereIsAnActiveLockAcquisition()
        {
            // GIVEN
            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
            try
            {
                Locks_Client    client    = NewWaitingLocksClient(latch);
                MasterImpl      master    = NewMasterWithLocksClient(client);
                HandshakeResult handshake = master.Handshake(1, newStoreIdForCurrentVersion()).response();

                // WHEN
                RequestContext context = new RequestContext(handshake.Epoch(), 1, 2, 0, 0);
                master.NewLockSession(context);
                Future <Void> acquireFuture = OtherThread.execute(state =>
                {
                    master.AcquireExclusiveLock(context, ResourceTypes.NODE, 1L);
                    return(null);
                });
                OtherThread.get().waitUntilWaiting();
                master.EndLockSession(context, false);
                verify(client).stop();
                verify(client, never()).close();
                latch.Signal();
                acquireFuture.get();

                // THEN
                verify(client).close();
            }
            finally
            {
                latch.Signal();
            }
        }
Пример #10
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldBeAbleToRecoverInTheMiddleOfPopulatingAnIndexWhereLogHasRotated() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldBeAbleToRecoverInTheMiddleOfPopulatingAnIndexWhereLogHasRotated()
        {
            // Given
            StartDb();

            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
            when(_mockedIndexProvider.getPopulator(any(typeof(StoreIndexDescriptor)), any(typeof(IndexSamplingConfig)), any())).thenReturn(IndexPopulatorWithControlledCompletionTiming(latch));
            CreateIndex(_myLabel);
            RotateLogsAndCheckPoint();

            // And Given
            Future <Void> killFuture = KillDbInSeparateThread();

            latch.Signal();
            killFuture.get();
            latch = new System.Threading.CountdownEvent(1);
            when(_mockedIndexProvider.getPopulator(any(typeof(StoreIndexDescriptor)), any(typeof(IndexSamplingConfig)), any())).thenReturn(IndexPopulatorWithControlledCompletionTiming(latch));
            when(_mockedIndexProvider.getInitialState(any(typeof(StoreIndexDescriptor)))).thenReturn(InternalIndexState.POPULATING);

            // When
            StartDb();

            // Then
            assertThat(getIndexes(_db, _myLabel), inTx(_db, hasSize(1)));
            assertThat(getIndexes(_db, _myLabel), inTx(_db, haveState(_db, Org.Neo4j.Graphdb.schema.Schema_IndexState.Populating)));
            verify(_mockedIndexProvider, times(2)).getPopulator(any(typeof(StoreIndexDescriptor)), any(typeof(IndexSamplingConfig)), any());
            verify(_mockedIndexProvider, never()).getOnlineAccessor(any(typeof(StoreIndexDescriptor)), any(typeof(IndexSamplingConfig)));
            latch.Signal();
        }
Пример #11
0
 public AbstractComponentSwitcherAnonymousInnerClass(HighAvailabilityMemberStateMachineTest outerInstance, UnknownType mock, DelegateInvocationHandler <Master> handler, System.Threading.CountdownEvent latch, AtomicReference <Master> @ref) : base(mock)
 {
     this.outerInstance = outerInstance;
     this._handler      = handler;
     this._latch        = latch;
     this.@ref          = @ref;
 }
Пример #12
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMasterElectionAfterMasterRecoversInSlaveOnlyCluster() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void TestMasterElectionAfterMasterRecoversInSlaveOnlyCluster()
        {
            ClusterManager.ManagedCluster cluster = ClusterRule.startCluster();
            assertThat(cluster.GetServerId(cluster.Master), equalTo(new InstanceId(3)));
            HighlyAvailableGraphDatabase master = cluster.Master;

            System.Threading.CountdownEvent masterFailedLatch = CreateMasterFailLatch(cluster);
            ClusterManager.RepairKit        repairKit         = cluster.Fail(master);
            try
            {
                assertTrue(masterFailedLatch.await(60, TimeUnit.SECONDS));
            }
            finally
            {
                repairKit.Repair();
            }

            cluster.Await(allSeesAllAsAvailable());
            long nodeId = CreateNodeWithPropertyOn(cluster.AnySlave, PROPERTY, VALUE);

            using (Transaction ignore = master.BeginTx())
            {
                assertThat(master.GetNodeById(nodeId).getProperty(PROPERTY), equalTo(VALUE));
            }
        }
Пример #13
0
        //-------------------------------------------------------------------------
        public virtual void test_combineFuturesAsMap()
        {
            CompletableFuture <string> future1 = new CompletableFuture <string>();

            future1.complete("A");
            System.Threading.CountdownEvent latch   = new System.Threading.CountdownEvent(1);
            CompletableFuture <string>      future2 = CompletableFuture.supplyAsync(() =>
            {
                try
                {
                    latch.await();
                }
                catch (InterruptedException)
                {
                }
                return("B");
            });
            IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2);

            CompletableFuture <IDictionary <string, string> > test = Guavate.combineFuturesAsMap(input);

            assertEquals(test.Done, false);
            latch.Signal();
            IDictionary <string, string> combined = test.join();

            assertEquals(test.Done, true);
            assertEquals(combined.Count, 2);
            assertEquals(combined["a"], "A");
            assertEquals(combined["b"], "B");
        }
Пример #14
0
 internal virtual void Initialize(int numberOfUpdateTrackers)
 {
     UpdateTrackerCompletionLatch = new System.Threading.CountdownEvent(numberOfUpdateTrackers);
     if (numberOfUpdateTrackers > 0)
     {
         Barrier = new Org.Neo4j.Test.Barrier_Control();
     }
 }
Пример #15
0
 public ClusterMemberListener_AdapterAnonymousInnerClass(ClusterTopologyChangesIT outerInstance, Org.Neo4j.Kernel.ha.HighlyAvailableGraphDatabase newSlave1, Org.Neo4j.Kernel.ha.HighlyAvailableGraphDatabase newSlave2, System.Threading.CountdownEvent slave1Unavailable, System.Threading.CountdownEvent slave2Unavailable)
 {
     this.outerInstance      = outerInstance;
     this._newSlave1         = newSlave1;
     this._newSlave2         = newSlave2;
     this._slave1Unavailable = slave1Unavailable;
     this._slave2Unavailable = slave2Unavailable;
 }
Пример #16
0
 public HeartbeatListener_AdapterAnonymousInnerClass(ClusterTopologyChangesIT outerInstance, Org.Neo4j.Kernel.ha.HighlyAvailableGraphDatabase slave1, Org.Neo4j.Kernel.ha.HighlyAvailableGraphDatabase slave2, System.Threading.CountdownEvent slave1Left, System.Threading.CountdownEvent slave2Left)
 {
     this.outerInstance = outerInstance;
     this._slave1       = slave1;
     this._slave2       = slave2;
     this._slave1Left   = slave1Left;
     this._slave2Left   = slave2Left;
 }
Пример #17
0
 internal SharedDiscoveryService()
 {
     _coreMembers      = new ConcurrentDictionary <MemberId, CoreServerInfo>();
     _readReplicas     = new ConcurrentDictionary <MemberId, ReadReplicaInfo>();
     _listeningClients = new CopyOnWriteArrayList <SharedDiscoveryCoreClient>();
     _clusterIdDbNames = new ConcurrentDictionary <string, ClusterId>();
     _leaderMap        = new ConcurrentDictionary <string, LeaderInfo>();
     _enoughMembers    = new System.Threading.CountdownEvent(MIN_DISCOVERY_MEMBERS);
 }
Пример #18
0
 public override void TearDownPageCache(MuninnPageCache pageCache)
 {
     if (BackgroundFlushLatch != null)
     {
         BackgroundFlushLatch.Signal();
         BackgroundFlushLatch = null;
     }
     pageCache.Close();
     _allocator.close();
 }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void startMonitoringWhenLifecycleStarting() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void StartMonitoringWhenLifecycleStarting()
        {
            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
            FileWatcher watcher = new TestFileWatcher(latch);
            DefaultFileSystemWatcherService service = new DefaultFileSystemWatcherService(_jobScheduler, watcher);

            service.Init();
            service.Start();

            latch.await();
        }
        private void SendCommandToComputer(object data)
        {
            ADComputer      computer        = null;
            DataForComputer dataForComputer = (DataForComputer)data;
            DataGridViewRow row             = dataForComputer.Row;

            String[] options = dataForComputer.Options;
            System.Threading.CountdownEvent countDown = dataForComputer.CountDown;

            try
            {
                Action startAction = () =>
                {
                    lock (dtGrvComputers)
                    {
                        if (!_closing && !_aborting)
                        {
                            row.Cells["Status"].Value = resMan.GetString("SendingCommand");
                            computer = (ADComputer)row.Cells["Computer"].Value;
                        }
                    }
                    Logger.Write("Will try to send InstallPendingUpdates on : " + computer.Name);
                };
                if (!_closing && !_aborting)
                {
                    this.Invoke(startAction);
                }

                ADComputer.InstallPendingUpdatesResult result = ADComputer.InstallPendingUpdatesResult.FailToSendCommand;
                if (!_closing && !_aborting)
                {
                    result = computer.InstallPendingUpdates(options, Username, Password);
                }

                Action endAction = () =>
                {
                    Logger.Write("Result for " + computer.Name + " is : " + result.ToString());

                    lock (dtGrvComputers)
                    {
                        if (!_closing && !_aborting)
                        {
                            row.Cells["Status"].Value = resMan.GetString(result.ToString());
                        }
                    }
                };
                if (!_closing && !_aborting)
                {
                    this.Invoke(endAction);
                }
            }
            catch (Exception) { }
            finally { countDown.Signal(); }
        }
Пример #21
0
        private void StartResetSusClientID()
        {
            System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo(Properties.Settings.Default.Language);

            Credentials cred = Credentials.GetInstance();

            if (dtGrdVResult.SelectedRows.Count != 0)
            {
                if (cred.InitializeCredential() == false)
                {
                    return;
                }
            }
            Logger.Write(lblCredentials);

            Action startAction = () => { lblCredentials.Text = cred.CredentialNotice; };

            if (!_closing)
            {
                this.Invoke(startAction);
            }

            System.Threading.CountdownEvent countEvent = new System.Threading.CountdownEvent(1);

            foreach (DataGridViewRow row in dtGrdVResult.SelectedRows)
            {
                countEvent.AddCount();
                ASyncClientParameters parameters = new ASyncClientParameters();
                parameters.RowIndex   = row.Index;
                parameters.Login      = cred.Login;
                parameters.Password   = cred.Password;
                parameters.CountEvent = countEvent;

                if (!_closing & !_aborting)
                {
                    System.Threading.ThreadPool.QueueUserWorkItem(ResetSusClientID, parameters);
                }
            }
            countEvent.Signal();
            countEvent.Wait(10000 * dtGrdVResult.SelectedRows.Count);

            if (!_closing && !_aborting)
            {
                SearchDuplicateWsusClientID();
            }

            Action endAction = () => { ChangeUIAccess(true); };

            if (!_closing)
            {
                this.Invoke(endAction);
            }
        }
Пример #22
0
//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 org.neo4j.kernel.impl.locking.Locks_Client newWaitingLocksClient(final java.util.concurrent.CountDownLatch latch)
        private Locks_Client NewWaitingLocksClient(System.Threading.CountdownEvent latch)
        {
            Locks_Client client = mock(typeof(Locks_Client));

            doAnswer(invocation =>
            {
                latch.await();
                return(null);
            }).when(client).acquireExclusive(eq(LockTracer.NONE), any(typeof(ResourceType)), anyLong());

            return(client);
        }
Пример #23
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private <T extends org.neo4j.graphdb.PropertyContainer> Resource<T> test(System.Func<T> setup, String... queries) throws InterruptedException, java.util.concurrent.ExecutionException
        private Resource <T> Test <T>(System.Func <T> setup, params string[] queries) where T : Org.Neo4j.Graphdb.PropertyContainer
        {
            System.Threading.CountdownEvent resourceLocked     = new System.Threading.CountdownEvent(1);
            System.Threading.CountdownEvent listQueriesLatch   = new System.Threading.CountdownEvent(1);
            System.Threading.CountdownEvent finishQueriesLatch = new System.Threading.CountdownEvent(1);
            T resource;

            using (Transaction tx = _db.beginTx())
            {
                resource = setup();
                tx.Success();
            }
            _threads.execute(parameter =>
            {
                using (Transaction tx = _db.beginTx())
                {
                    tx.AcquireWriteLock(resource);
                    resourceLocked.Signal();
                    listQueriesLatch.await();
                }
                return(null);
            }, null);
            resourceLocked.await();

            _threads.executeAndAwait(parameter =>
            {
                try
                {
                    using (Transaction tx = _db.beginTx())
                    {
                        foreach (string query in queries)
                        {
                            _db.execute(query).close();
                        }
                        tx.Success();
                    }
                }
                catch (Exception t)
                {
                    Console.WriteLine(t.ToString());
                    Console.Write(t.StackTrace);
                    throw new Exception(t);
                }
                finally
                {
                    finishQueriesLatch.Signal();
                }
                return(null);
            }, null, waitingWhileIn(typeof(GraphDatabaseFacade), "execute"), SECONDS_TIMEOUT, SECONDS);

            return(new Resource <T>(listQueriesLatch, finishQueriesLatch, resource));
        }
Пример #24
0
        private System.Threading.CountdownEvent CreateMasterFailLatch(ClusterManager.ManagedCluster cluster)
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch failedLatch = new java.util.concurrent.CountDownLatch(2);
            System.Threading.CountdownEvent failedLatch = new System.Threading.CountdownEvent(2);
            foreach (HighlyAvailableGraphDatabase db in cluster.AllMembers)
            {
                if (!Db.Master)
                {
                    Db.DependencyResolver.resolveDependency(typeof(ClusterClient)).addHeartbeatListener(new HeartbeatListenerAnonymousInnerClass(this, failedLatch));
                }
            }
            return(failedLatch);
        }
Пример #25
0
 private static void Await(System.Threading.CountdownEvent latch)
 {
     try
     {
         bool result = latch.await(30, TimeUnit.SECONDS);
         if (!result)
         {
             throw new Exception("Count down did not happen. Current count: " + latch.CurrentCount);
         }
     }
     catch (InterruptedException e)
     {
         throw new Exception(e);
     }
 }
Пример #26
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = 3000) public void conversationCanNotBeStoppedAndClosedConcurrently() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ConversationCanNotBeStoppedAndClosedConcurrently()
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch answerLatch = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent answerLatch = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch stopLatch = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent stopLatch = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch stopReadyLatch = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent stopReadyLatch = new System.Threading.CountdownEvent(1);
            const int sleepTime = 1000;

            doAnswer(invocation =>
            {
                stopReadyLatch.Signal();
                stopLatch.await();
                TimeUnit.MILLISECONDS.sleep(sleepTime);
                return(null);
            }).when(_client).stop();
            doAnswer(invocation =>
            {
                answerLatch.Signal();
                return(null);
            }).when(_client).close();

            ThreadingRule.execute(_conversation =>
            {
                _conversation.stop();
                return(null);
            }, _conversation);

            stopReadyLatch.await();
            ThreadingRule.execute(_conversation =>
            {
                _conversation.close();
                return(null);
            }, _conversation);

            long raceStartTime = DateTimeHelper.CurrentUnixTimeMillis();

            stopLatch.Signal();
            answerLatch.await();
            // execution time should be at least 1000 millis
            long executionTime = DateTimeHelper.CurrentUnixTimeMillis() - raceStartTime;

            assertTrue(string.Format("Execution time should be at least equal to {0:D}, but was {1:D}.", sleepTime, executionTime), executionTime >= sleepTime);
        }
Пример #27
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(timeout = 60_000) public void possibleToShutdownDbWhenItIsNotHealthyAndNotAllTransactionsAreApplied() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void PossibleToShutdownDbWhenItIsNotHealthyAndNotAllTransactionsAreApplied()
        {
            // adversary that makes page cache throw exception when node store is used
            ClassGuardedAdversary adversary = new ClassGuardedAdversary(new CountingAdversary(1, true), typeof(NodeStore));

            adversary.Disable();

            GraphDatabaseService db = AdversarialPageCacheGraphDatabaseFactory.create(_fs, adversary).newEmbeddedDatabaseBuilder(_testDir.databaseDir()).newGraphDatabase();

            System.Threading.CountdownEvent txStartLatch  = new System.Threading.CountdownEvent(1);
            System.Threading.CountdownEvent txCommitLatch = new System.Threading.CountdownEvent(1);

//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.concurrent.Future<?> result = java.util.concurrent.ForkJoinPool.commonPool().submit(() ->
            Future <object> result = ForkJoinPool.commonPool().submit(() =>
            {
                using (Transaction tx = Db.beginTx())
                {
                    txStartLatch.Signal();
                    Db.createNode();
                    Await(txCommitLatch);
                    tx.success();
                }
            });

            Await(txStartLatch);

            adversary.Enable();

            txCommitLatch.Signal();

            try
            {
                result.get();
                fail("Exception expected");
            }
            catch (ExecutionException ee)
            {
                // transaction is expected to fail because write through the page cache fails
                assertThat(ee.InnerException, instanceOf(typeof(TransactionFailureException)));
            }
            adversary.Disable();

            // shutdown should complete without any problems
            Db.shutdown();
        }
Пример #28
0
        private static long[] MergeAll(long[] output, LinkedList <int> bounds)
        {
            var buffer = new long[output.Count()];

            while (bounds.Count > 2)
            {
                var tmp_src = output;
                var tmp_buf = buffer;

                var w_node = bounds.First.Next;
                var w_copy = (bounds.Count - 1) % 2 == 1;
                int merges = (bounds.Count - 1) / 2;

                var counter = new System.Threading.CountdownEvent(merges);

                while (merges > 0)
                {
                    System.Threading.ThreadPool.QueueUserWorkItem(
                        w =>
                    {
                        MergeTwo(tmp_src, tmp_buf, (MergeWindow)w);
                        counter.Signal();
                    },
                        new MergeWindow(w_node)
                        );
                    var w_next = w_node.Next.Next;
                    bounds.Remove(w_node);
                    w_node = w_next;
                    merges--;
                }

                if (w_copy)
                {
                    var w_prev = w_node.Previous;
                    Array.Copy(tmp_src, w_prev.Value, tmp_buf, w_prev.Value, w_node.Value - w_prev.Value);
                }

                counter.Wait();

                output = tmp_buf;
                buffer = tmp_src;
            }

            return(output);
        }
Пример #29
0
        private IEnumerable RunChildren()
        {
            int childCount = Children.Count;

            if (childCount == 0)
            {
                throw new InvalidOperationException("RunChildren called but item has no children");
            }

            _childTestCountdown = new CountdownEvent(childCount);

            foreach (UnityWorkItem child in Children)
            {
                if (CheckForCancellation())
                {
                    yield break;
                }

                var unityTestExecutionContext = new UnityTestExecutionContext(Context);
                child.InitializeContext(unityTestExecutionContext);

                var enumerable = child.Execute().GetEnumerator();

                while (true)
                {
                    if (!enumerable.MoveNext())
                    {
                        break;
                    }
                    ResultedInDomainReload |= child.ResultedInDomainReload;
                    yield return(enumerable.Current);
                }

                _suiteResult.AddResult(child.Result);
                childCount--;
            }

            if (childCount > 0)
            {
                while (childCount-- > 0)
                {
                    CountDownChildTest();
                }
            }
        }
Пример #30
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void closeClientAfterLockStopped(boolean shared) throws Exception
        private void CloseClientAfterLockStopped(bool shared)
        {
            AcquiredLock thisThreadsExclusiveLock = AcquireExclusiveLockInThisThread();

            System.Threading.CountdownEvent firstLockAcquired = new System.Threading.CountdownEvent(1);
            LockAcquisition acquisition = TryAcquireTwoLocksLockInAnotherThread(shared, firstLockAcquired);

            Await(firstLockAcquired);
            AssertThreadIsWaitingForLock(acquisition);
            AssertLocksHeld(FIRST_NODE_ID, SECOND_NODE_ID);

            acquisition.Stop();
            AssertLockAcquisitionFailed(acquisition);
            AssertLocksHeld(FIRST_NODE_ID);

            thisThreadsExclusiveLock.Release();
            AssertNoLocksHeld();
        }
Пример #31
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void acquireLockAfterOtherLockStoppedSameThread(boolean firstLockShared, boolean secondLockShared) throws Exception
        private void AcquireLockAfterOtherLockStoppedSameThread(bool firstLockShared, bool secondLockShared)
        {
            AcquiredLock thisThreadsExclusiveLock = AcquireExclusiveLockInThisThread();

            System.Threading.CountdownEvent firstLockFailed = new System.Threading.CountdownEvent(1);
            System.Threading.CountdownEvent startSecondLock = new System.Threading.CountdownEvent(1);

            LockAcquisition lockAcquisition = AcquireTwoLocksInAnotherThread(firstLockShared, secondLockShared, firstLockFailed, startSecondLock);

            AssertThreadIsWaitingForLock(lockAcquisition);

            lockAcquisition.Stop();
            Await(firstLockFailed);
            thisThreadsExclusiveLock.Release();
            startSecondLock.Signal();

            AssertLockAcquisitionSucceeded(lockAcquisition);
        }
            public static double[] ETCToPTC(double[][] Octave_ETC, double CutOffTime, int sample_frequency_in, int sample_frequency_out, double Rho_C)
            {
                int length = 4096;
                double[] IR = new double[(int)Math.Floor(sample_frequency_out * CutOffTime) + (int)length];
                double BW = (double)sample_frequency_out / (double)sample_frequency_in;

                //Convert to Pressure & Interpolate full resolution IR
                int ct = 0;
                System.Threading.Semaphore S = new System.Threading.Semaphore(0, 1);
                S.Release(1);

                double[] time = new double[(int)Math.Floor(sample_frequency_out * CutOffTime) + (int)length];
                double dt = 1f/(float)sample_frequency_out;
                for (int i = 0; i < time.Length; i++)
                {
                    time[i] = i * dt;
                }

                int proc = UI.PachydermAc_PlugIn.Instance.ProcessorSpec();
                double[][] output = new double[proc][];
                double[][] samplep = new double[proc][];
                System.Threading.Thread[] T = new System.Threading.Thread[proc];
                int[] to = new int[proc];
                int[] from = new int[proc];

                System.Threading.CountdownEvent CDE = new System.Threading.CountdownEvent(Octave_ETC[0].Length);

                for (int p = 0; p < proc; p++)
                {
                    output[p] = new double[length];
                    samplep[p] = new double[length * 2];
                    to[p] = p * Octave_ETC[0].Length / proc;
                    from[p] = (p + 1) * Octave_ETC[0].Length / proc;

                    T[p] = new System.Threading.Thread((thread) =>
                    {
                        int thr = (int)thread;
                        for (int t = to[thr]; t < from[thr]; t++)
                        {
                            ct++;
                            double[] pr = new double[8];
                            for (int oct = 0; oct < 8; oct++) pr[oct] = Math.Sqrt(Octave_ETC[oct][t] * Rho_C);

                            double sum = 0;
                            foreach (double d in pr) sum += d;
                            if (sum > 0)
                            {
                                output[thr] = Filter.Signal(pr, sample_frequency_out, 4096, thr);
                                //Audio.Pach_SP.Raised_Cosine_Window(ref output[thr]);
                                for (int k = 0; k < length; k++)
                                {
                                    IR[(int)Math.Floor(t * BW) + k] += output[thr][k];
                                }
                            }
                            CDE.Signal();
                        }
                    });
                    T[p].Start(p);
                }

                ProgressBox VB = new ProgressBox("Signal Production Progress");
                VB.Show();
                do
                {
                    if (CDE.IsSet)
                    {
                        break;
                    }
                    VB.Populate((int)(100 * (1f - ((float)CDE.CurrentCount / (float)IR.Length))));

                    System.Threading.Thread.Sleep(500);

                } while (true);

                //CDE.Wait();
                VB.Close();
                return IR;
            }
        public void TestRunTwoExperimentsSimultanouslyAndTerminateOneExperiment()
        {
            //assure workspace is empty
            AppContext.WorkspaceInstance.Clear();

            var done = new System.Threading.CountdownEvent(2);

            //start experiment one (takes more than 2 seconds to finish successfully)
            Experiment experimentOne = LoadExperiment("long-experiment.teml");
            MockProgress progressOne = new MockProgress();
            experimentOne.RunExperiment(progressOne, AppContext.WorkspaceInstance, AppContext.Components);
            experimentOne.ExperimentCompleted += (sender, args) =>
            {
                done.Signal();
            };

            //start experiment two and terminate it
            MockProgress progressTwo = new MockProgress();
            Experiment experimentTwo = LoadExperiment("infinite_loop_terminate_experiment_test.teml");
            experimentTwo.RunExperiment(progressTwo, AppContext.WorkspaceInstance, AppContext.Components);
            experimentTwo.ExperimentStarted += (sender, args) =>
            {
                experimentTwo.StopRunningExperiment();
            };
            experimentTwo.ExperimentCompleted += (sender, args) =>
            {
                done.Signal();
            };

            //wait for both experiment to end
            done.Wait(5000);

            //the experiment one should have ended successfully (it SHOULD NOT have been terminated)
            Assert.IsFalse(progressOne.HasError);
            Assert.AreEqual(Messages.ExperimentRunnerSuccessMessage, progressOne.CurrentStatus);

            //while exepriment two should be terminated
            Assert.IsTrue(progressTwo.HasError);
            Assert.AreEqual(Messages.ExperimentExecutionTerminated, progressTwo.CurrentStatus);
        }