public static ClusterInstance NewClusterInstance(InstanceId id, URI uri, Monitors monitors, ClusterConfiguration configuration, int maxSurvivableFailedMembers, LogProvider logging) { MultiPaxosServerFactory factory = new MultiPaxosServerFactory(configuration, logging, monitors.NewMonitor(typeof(StateMachines.Monitor))); ClusterInstanceInput input = new ClusterInstanceInput(); ClusterInstanceOutput output = new ClusterInstanceOutput(uri); ObjectStreamFactory objStreamFactory = new ObjectStreamFactory(); ProverTimeouts timeouts = new ProverTimeouts(uri); InMemoryAcceptorInstanceStore acceptorInstances = new InMemoryAcceptorInstanceStore(); Config config = mock(typeof(Config)); when(config.Get(ClusterSettings.max_acceptors)).thenReturn(maxSurvivableFailedMembers); DelayedDirectExecutor executor = new DelayedDirectExecutor(logging); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.context.MultiPaxosContext context = new org.neo4j.cluster.protocol.atomicbroadcast.multipaxos.context.MultiPaxosContext(id, org.neo4j.helpers.collection.Iterables.iterable(new org.neo4j.cluster.protocol.election.ElectionRole(org.neo4j.cluster.protocol.cluster.ClusterConfiguration.COORDINATOR)), new org.neo4j.cluster.protocol.cluster.ClusterConfiguration(configuration.getName(), logging, configuration.getMemberURIs()), executor, logging, objStreamFactory, objStreamFactory, acceptorInstances, timeouts, new org.neo4j.kernel.ha.cluster.DefaultElectionCredentialsProvider(id, new StateVerifierLastTxIdGetter(), new MemberInfoProvider()), config); MultiPaxosContext context = new MultiPaxosContext(id, Iterables.iterable(new ElectionRole(ClusterConfiguration.COORDINATOR)), new ClusterConfiguration(configuration.Name, logging, configuration.MemberURIs), executor, logging, objStreamFactory, objStreamFactory, acceptorInstances, timeouts, new DefaultElectionCredentialsProvider(id, new StateVerifierLastTxIdGetter(), new MemberInfoProvider()), config); context.ClusterContext.BoundAt = uri; SnapshotContext snapshotContext = new SnapshotContext(context.ClusterContext, context.LearnerContext); DelayedDirectExecutor taskExecutor = new DelayedDirectExecutor(logging); ProtocolServer ps = factory.NewProtocolServer(id, input, output, DirectExecutor, taskExecutor, timeouts, context, snapshotContext); return(new ClusterInstance(DirectExecutor, logging, factory, ps, context, acceptorInstances, timeouts, input, output, uri)); }
public virtual ClusterInstance NewCopy() { // A very invasive method of cloning a protocol server. Nonetheless, since this is mostly an experiment at this // point, it seems we can refactor later on to have a cleaner clone mechanism. // Because state machines share state, and are simultaneously conceptually unaware of each other, implementing // a clean snapshot mechanism is very hard. I've opted for having a dirty one here in the test code rather // than introducing a hack into the runtime code. ProverTimeouts timeoutsSnapshot = _timeouts.snapshot(); InMemoryAcceptorInstanceStore snapshotAcceptorInstances = _acceptorInstanceStore.snapshot(); ClusterInstanceOutput output = new ClusterInstanceOutput(_uri); ClusterInstanceInput input = new ClusterInstanceInput(); DelayedDirectExecutor executor = new DelayedDirectExecutor(_logging); ObjectStreamFactory objectStreamFactory = new ObjectStreamFactory(); MultiPaxosContext snapshotCtx = _ctx.snapshot(_logging, timeoutsSnapshot, executor, snapshotAcceptorInstances, objectStreamFactory, objectStreamFactory, new DefaultElectionCredentialsProvider(_server.ServerId, new StateVerifierLastTxIdGetter(), new MemberInfoProvider()) ); IList <StateMachine> snapshotMachines = new List <StateMachine>(); foreach (StateMachine stateMachine in _server.StateMachines.StateMachines) { snapshotMachines.Add(SnapshotStateMachine(_logging, snapshotCtx, stateMachine)); } ProtocolServer snapshotProtocolServer = _factory.constructSupportingInfrastructureFor(_server.ServerId, input, output, executor, timeoutsSnapshot, _stateMachineExecutor, snapshotCtx, snapshotMachines.ToArray()); return(new ClusterInstance(_stateMachineExecutor, _logging, _factory, snapshotProtocolServer, snapshotCtx, snapshotAcceptorInstances, timeoutsSnapshot, input, output, _uri)); }
public override void run(string format, string[] args) { if (0 == args.Length) { Console.WriteLine(Help); } else { format = args[0]; ObjectStreamFactory streamFactory = getStreamFactory(format); string[] formatArgs = new string[args.Length - 1]; Array.Copy(args, 1, formatArgs, 0, formatArgs.Length); string helpString = createHelpString(format, ArgumentParser.createUsage(streamFactory.Parameters)); if (0 == formatArgs.Length || (1 == formatArgs.Length && "help".Equals(formatArgs[0]))) { Console.WriteLine(helpString); Environment.Exit(0); } string errorMessage = ArgumentParser.validateArgumentsLoudly(formatArgs, streamFactory.Parameters); if (null != errorMessage) { throw new TerminateToolException(1, errorMessage + "\n" + helpString); } ObjectStream <T> sampleStream = streamFactory.create(formatArgs); try { object sample; while ((sample = sampleStream.read()) != null) { Console.WriteLine(sample.ToString()); } } catch (IOException e) { throw new TerminateToolException(-1, "IO error while converting data : " + e.Message, e); } finally { if (sampleStream != null) { try { sampleStream.close(); } catch (IOException) { // sorry that this can fail } } } } }
/// <summary> /// Validates arguments for a format processed by the <code>factory</code>. </summary> /// <param name="factory"> a stream factory </param> /// <param name="args"> arguments </param> protected internal virtual void validateFactoryArgs(ObjectStreamFactory factory, string[] args) { string errMessage = ArgumentParser.validateArgumentsLoudly(args, factory.Parameters); if (null != errMessage) { throw new TerminateToolException(1, "Format parameters are invalid: " + errMessage + "\n" + "Usage: " + ArgumentParser.createUsage(factory.Parameters)); } }
/// <summary> /// Validates arguments using parameters from <code>argProxyInterface</code> and the parameters of the /// <code>format</code>. /// </summary> /// <param name="args"> arguments </param> /// <param name="argProxyInterface"> interface with parameter descriptions </param> /// <param name="format"> data format name </param> /// @param <A> A </param> protected internal virtual void validateAllArgs <A>(string[] args, Type argProxyInterface, string format) { ObjectStreamFactory factory = getStreamFactory(format); string errMessage = ArgumentParser.validateArgumentsLoudly(args, argProxyInterface, factory.getParameters <A>()); if (null != errMessage) { throw new TerminateToolException(1, errMessage + "\n" + getHelp(format)); } }
public override void run(string format, string[] args) { validateAllArgs(args, this.paramsClass, format); @params = ArgumentParser.parse(ArgumentParser.filter(args, this.paramsClass), this.paramsClass); factory = getStreamFactory(format); string[] fargs = ArgumentParser.filter(args, factory.Parameters); validateFactoryArgs(factory, fargs); sampleStream = factory.create(fargs); }
/// <summary> /// Returns stream factory for the type of this tool for the </code>format</code>. /// </summary> /// <param name="format"> data format name </param> /// <returns> stream factory for the type of this tool for the format </returns> protected internal virtual ObjectStreamFactory getStreamFactory(string format) { ObjectStreamFactory factory = StreamFactoryRegistry.getFactory(type, format); if (null != factory) { return(factory); } else { throw new TerminateToolException(1, "Format " + format + " is not found.\n" + Help); } }
public override string getHelp(string format) { if ("".Equals(format) || StreamFactoryRegistry.DEFAULT_FORMAT.Equals(format)) { return(getBasicHelp(paramsClass, StreamFactoryRegistry.getFactory(type, StreamFactoryRegistry.DEFAULT_FORMAT).getParameters <P>())); } else { ObjectStreamFactory factory = StreamFactoryRegistry.getFactory(type, format); if (null == factory) { throw new TerminateToolException(1, "Format " + format + " is not found.\n" + Help); } return("Usage: " + CLI.CMD + " " + Name + "." + format + " " + ArgumentParser.createUsage(paramsClass, factory.getParameters <P>())); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testFailure() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void TestFailure() { ScriptableNetworkFailureLatencyStrategy networkLatency = new ScriptableNetworkFailureLatencyStrategy(); NetworkMock network = new NetworkMock(NullLogService.Instance, new Monitors(), 50, new MultipleFailureLatencyStrategy(networkLatency), new MessageTimeoutStrategy(new FixedTimeoutStrategy(1000))); IList <TestProtocolServer> nodes = new List <TestProtocolServer>(); TestProtocolServer server = network.AddServer(1, URI.create("cluster://server1")); server.NewClient(typeof(Cluster)).create("default"); network.TickUntilDone(); nodes.Add(server); for (int i = 1; i < 3; i++) { TestProtocolServer protocolServer = network.AddServer(i + 1, new URI("cluster://server" + (i + 1))); protocolServer.NewClient(typeof(Cluster)).join("default", new URI("cluster://server1")); network.Tick(10); nodes.Add(protocolServer); } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.cluster.protocol.atomicbroadcast.AtomicBroadcast atomicBroadcast = nodes.get(0).newClient(org.neo4j.cluster.protocol.atomicbroadcast.AtomicBroadcast.class); AtomicBroadcast atomicBroadcast = nodes[0].NewClient(typeof(AtomicBroadcast)); ObjectStreamFactory objectStreamFactory = new ObjectStreamFactory(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.cluster.protocol.atomicbroadcast.AtomicBroadcastSerializer serializer = new org.neo4j.cluster.protocol.atomicbroadcast.AtomicBroadcastSerializer(objectStreamFactory, objectStreamFactory); AtomicBroadcastSerializer serializer = new AtomicBroadcastSerializer(objectStreamFactory, objectStreamFactory); atomicBroadcast.Broadcast(serializer.Broadcast(new DaPayload())); networkLatency.NodeIsDown("cluster://server2"); networkLatency.NodeIsDown("cluster://server3"); atomicBroadcast.Broadcast(serializer.Broadcast(new DaPayload())); network.Tick(100); networkLatency.NodeIsUp("cluster://server3"); network.Tick(1000); foreach (TestProtocolServer node in nodes) { node.NewClient(typeof(Cluster)).leave(); network.Tick(10); } }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public ClusterClientModule(org.neo4j.kernel.lifecycle.LifeSupport life, org.neo4j.kernel.impl.util.Dependencies dependencies, final org.neo4j.kernel.monitoring.Monitors monitors, final org.neo4j.kernel.configuration.Config config, org.neo4j.logging.internal.LogService logService, org.neo4j.cluster.protocol.election.ElectionCredentialsProvider electionCredentialsProvider) public ClusterClientModule(LifeSupport life, Dependencies dependencies, Monitors monitors, Config config, LogService logService, ElectionCredentialsProvider electionCredentialsProvider) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.logging.LogProvider logging = org.neo4j.cluster.logging.AsyncLogging.provider(life, logService.getInternalLogProvider()); LogProvider logging = AsyncLogging.provider(life, logService.InternalLogProvider); InternalLoggerFactory.DefaultFactory = new NettyLoggerFactory(logging); TimeoutStrategy timeoutStrategy = (new MessageTimeoutStrategy(new FixedTimeoutStrategy(config.Get(ClusterSettings.default_timeout).toMillis()))).timeout(HeartbeatMessage.sendHeartbeat, config.Get(ClusterSettings.heartbeat_interval).toMillis()).timeout(HeartbeatMessage.timed_out, config.Get(ClusterSettings.heartbeat_timeout).toMillis()).timeout(AtomicBroadcastMessage.broadcastTimeout, config.Get(ClusterSettings.broadcast_timeout).toMillis()).timeout(LearnerMessage.learnTimedout, config.Get(ClusterSettings.learn_timeout).toMillis()).timeout(ProposerMessage.phase1Timeout, config.Get(ClusterSettings.phase1_timeout).toMillis()).timeout(ProposerMessage.phase2Timeout, config.Get(ClusterSettings.phase2_timeout).toMillis()).timeout(ClusterMessage.joiningTimeout, config.Get(ClusterSettings.join_timeout).toMillis()).timeout(ClusterMessage.configurationTimeout, config.Get(ClusterSettings.configuration_timeout).toMillis()).timeout(ClusterMessage.leaveTimedout, config.Get(ClusterSettings.leave_timeout).toMillis()).timeout(ElectionMessage.electionTimeout, config.Get(ClusterSettings.election_timeout).toMillis()); MultiPaxosServerFactory protocolServerFactory = new MultiPaxosServerFactory(new ClusterConfiguration(config.Get(ClusterSettings.cluster_name), logging), logging, monitors.NewMonitor(typeof(StateMachines.Monitor))); NetworkReceiver receiver = dependencies.satisfyDependency(new NetworkReceiver(monitors.NewMonitor(typeof(NetworkReceiver.Monitor)), new ConfigurationAnonymousInnerClass(this, config) , logging)); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.cluster.protocol.atomicbroadcast.ObjectInputStreamFactory objectInputStreamFactory = new org.neo4j.cluster.protocol.atomicbroadcast.ObjectStreamFactory(); ObjectInputStreamFactory objectInputStreamFactory = new ObjectStreamFactory(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.cluster.protocol.atomicbroadcast.ObjectOutputStreamFactory objectOutputStreamFactory = new org.neo4j.cluster.protocol.atomicbroadcast.ObjectStreamFactory(); ObjectOutputStreamFactory objectOutputStreamFactory = new ObjectStreamFactory(); receiver.AddNetworkChannelsListener(new NetworkChannelsListenerAnonymousInnerClass(this, logging, objectInputStreamFactory, objectOutputStreamFactory)); NetworkSender sender = dependencies.satisfyDependency(new NetworkSender(monitors.NewMonitor(typeof(NetworkSender.Monitor)), new ConfigurationAnonymousInnerClass(this, config) , receiver, logging)); ExecutorLifecycleAdapter stateMachineExecutor = new ExecutorLifecycleAdapter(() => Executors.newSingleThreadExecutor(new NamedThreadFactory("State machine", monitors.NewMonitor(typeof(NamedThreadFactory.Monitor))))); AcceptorInstanceStore acceptorInstanceStore = new InMemoryAcceptorInstanceStore(); _server = protocolServerFactory.NewProtocolServer(config.Get(ClusterSettings.server_id), timeoutStrategy, receiver, sender, acceptorInstanceStore, electionCredentialsProvider, stateMachineExecutor, objectInputStreamFactory, objectOutputStreamFactory, config); life.Add(sender); life.Add(stateMachineExecutor); life.Add(receiver); // Timeout timer - triggers every 10 ms life.Add(new TimeoutTrigger(_server, monitors)); life.add(new ClusterJoin(new ConfigurationAnonymousInnerClass(this, config) , _server, logService)); ClusterClient = dependencies.SatisfyDependency(new ClusterClient(life, _server)); }
/// <summary> /// Returns a factory which reads format named <param>formatName</param> and /// instantiates streams producing objects of <param>sampleClass</param> class. /// </summary> /// <param name="sampleClass"> class of the objects, produced by the streams instantiated by the factory </param> /// <param name="formatName"> name of the format, if null, assumes OpenNLP format </param> /// <returns> factory instance </returns> public static ObjectStreamFactory getFactory(Type sampleClass, string formatName) { if (null == formatName) { formatName = DEFAULT_FORMAT; } ObjectStreamFactory factory = registry.ContainsKey(sampleClass) ? registry[sampleClass][formatName] : null; if (factory != null) { return(factory); } else { try { Type factoryClazz = Type.GetType(formatName); // TODO: Need to check if it can produce the desired output // Otherwise there will be class cast exceptions later in the flow try { if (factoryClazz != null) { return((ObjectStreamFactory)Activator.CreateInstance(factoryClazz)); } } catch (InstantiationException) { return(null); } catch (IllegalAccessException) { return(null); } } catch (ClassNotFoundException) { return(null); } } }
/// <summary> /// Registers <param>factory</param> which reads format named <param>formatName</param> and /// instantiates streams producing objects of <param>sampleClass</param> class. /// </summary> /// <param name="sampleClass"> class of the objects, produced by the streams instantiated by the factory </param> /// <param name="formatName"> name of the format </param> /// <param name="factory"> instance of the factory </param> /// <returns> true if the factory was successfully registered </returns> public static bool registerFactory(Type sampleClass, string formatName, ObjectStreamFactory factory) { bool result; IDictionary <string, ObjectStreamFactory> formats = registry[sampleClass]; if (null == formats) { formats = new Dictionary <string, ObjectStreamFactory>(); } if (!formats.ContainsKey(formatName)) { formats[formatName] = factory; registry[sampleClass] = formats; result = true; } else { result = false; } return(result); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDeepClone() public virtual void ShouldDeepClone() { // Given ObjectStreamFactory objStream = new ObjectStreamFactory(); AcceptorInstanceStore acceptorInstances = mock(typeof(AcceptorInstanceStore)); Executor executor = mock(typeof(Executor)); Timeouts timeouts = mock(typeof(Timeouts)); ClusterConfiguration clusterConfig = new ClusterConfiguration("myCluster", NullLogProvider.Instance); ElectionCredentialsProvider electionCredentials = mock(typeof(ElectionCredentialsProvider)); Config config = mock(typeof(Config)); when(config.Get(ClusterSettings.max_acceptors)).thenReturn(10); MultiPaxosContext ctx = new MultiPaxosContext(new InstanceId(1), Collections.emptyList(), clusterConfig, executor, NullLogProvider.Instance, objStream, objStream, acceptorInstances, timeouts, electionCredentials, config); // When MultiPaxosContext snapshot = ctx.Snapshot(NullLogProvider.Instance, timeouts, executor, acceptorInstances, objStream, objStream, electionCredentials); // Then assertEquals(ctx, snapshot); }
public sealed override void run(string format, string[] args) { ModelUpdaterParams @params = validateAndParseParams <ModelUpdaterParams>(ArgumentParser.filter(args, typeof(ModelUpdaterParams)), typeof(ModelUpdaterParams)); // Load model to be updated Jfile modelFile = @params.Model; ParserModel originalParserModel = (new ParserModelLoader()).load(modelFile); ObjectStreamFactory factory = getStreamFactory(format); string[] fargs = ArgumentParser.filter(args, factory.Parameters); validateFactoryArgs(factory, fargs); ObjectStream <Parse> sampleStream = factory.create <Parse>(fargs); ParserModel updatedParserModel; try { updatedParserModel = trainAndUpdate(originalParserModel, sampleStream, @params); } catch (IOException e) { throw new TerminateToolException(-1, "IO error while reading training data or indexing data: " + e.Message, e); } finally { try { sampleStream.close(); } catch (IOException) { // sorry that this can fail } } CmdLineUtil.writeModel("parser", modelFile, updatedParserModel); }