public static Neighborhood NewNeighborList(ShardID myAddr, Int3 extent, bool forceAllLinksPassive) { List <Link> neighbors = new List <Link>(); Int3 at = Int3.Zero; for (at.X = myAddr.X - 1; at.X <= myAddr.X + 1; at.X++) { for (at.Y = myAddr.Y - 1; at.Y <= myAddr.Y + 1; at.Y++) { for (at.Z = myAddr.Z - 1; at.Z <= myAddr.Z + 1; at.Z++) { if (at == myAddr.XYZ) { continue; } if ((at >= Int3.Zero).All && (at < extent).All) { int linear = neighbors.Count; neighbors.Add(new Link(new ShardID(at, myAddr.ReplicaLevel), at.OrthographicCompare(myAddr.XYZ) > 0 && !forceAllLinksPassive, linear, false)); } } } } return(new Neighborhood(neighbors)); }
private static void WriteID(NetworkStream stream, ShardID id) { stream.Write(BitConverter.GetBytes(id.X), 0, 4); stream.Write(BitConverter.GetBytes(id.Y), 0, 4); stream.Write(BitConverter.GetBytes(id.Z), 0, 4); stream.Write(BitConverter.GetBytes(id.ReplicaLevel), 0, 4); }
public Receiver(DataSetReceiverState state, int port, ShardID bindID) { this.state = state; Passive = new Link(new Address("localhost", port), false, 0, false, bindID); Passive.OnData = OnData; Listener = new Listener(h => Passive, port); }
public void AddSector(Address host, ShardID idk, Action <Sector> onCreate) { Sector rs; if (sectors.TryGetValue(host, out rs)) { onCreate?.Invoke(rs); return; } OnCreateObject(idk.ToString(), sec => { sec.transform.parent = transform; Sector s = sec.AddComponent <Sector>(); s.CubePrototype = cubePrototype; s.EntityPrototype = entityPrototype; s.Host = host; s.ExpectedID = idk; sectors.Add(host, s); s.onNewID = id => { }; s.OnNewNeighbor = (id, addr) => { AddSector(addr, id); }; onCreate?.Invoke(s); }); }
static void Main(string[] args) { if (args.Length < 2) { Console.Error.WriteLine("Usage: <program> <db address:port> <shard ID."); Environment.Exit(-1); } try { BaseDB.Connect(new Address(args[0])); ShardID id = ShardID.Decode(args[1]); var rs = BaseDB.TryGetAddress(id); while (rs.IsEmpty) { Thread.Sleep(1000); rs = BaseDB.TryGetAddress(id); } Console.WriteLine(rs.PeerAddress); } catch (Exception ex) { Console.Error.WriteLine(ex); Environment.Exit(-1); } }
public static Link FindLink(ShardID id) { if (id.XYZ == ID.XYZ) { return(siblings?.Find(id)); } return(neighbors?.Find(id)); }
public FullShardAddress(ShardID id, string host, int peerPort, int consensusPort, int observerPort) { ShardID = id; Host = host; PeerPort = peerPort; ConsensusPort = consensusPort; ObserverPort = observerPort; }
public SimulationRun(BaseDB.ConfigContainer config, ShardID localShardID, bool allLinksArePassive = true) { //BaseDB.ConfigContainer config = new BaseDB.ConfigContainer() { extent = Int3.One, r = 1f / 8, m = 1f / 16 }; Simulation.Configure(localShardID, config, allLinksArePassive); ctx = new SimulationContext(config, Simulation.SDToBox(localShardID.XYZ, config.extent), allLinksArePassive); messages = new MessageHistory(0, new MessagePack[] { MessagePack.CompleteBlank }); Notify = new MyNotify(this); }
public SimulationRun(BaseDB.ConfigContainer config, ShardID localShardID, IEnumerable <Entity> entities, bool allLinksArePassive = true) { //BaseDB.ConfigContainer config = new BaseDB.ConfigContainer() { extent = Int3.One, r = 1f / 8, m = 1f / 16 }; Simulation.Configure(localShardID, config, allLinksArePassive); ctx = new SimulationContext(config, Simulation.SDToBox(localShardID.XYZ, config.extent), allLinksArePassive); Notify = new MyNotify(this); FeedEntities(entities); }
public static void GetAddress(ShardID id, Action <FullShardAddress> onGetAddress) { if (OverrideAddressRequestFunction != null) { onGetAddress(OverrideAddressRequestFunction(id)); return; } hostRequests.Get(HostsStore, id, a => onGetAddress(a.GetFullAddress(id))); }
public static Address TryGetConsensusAddress(ShardID id) { var h = hostRequests.TryGet(HostsStore, id); if (h == null) { return(new Address()); } return(h.ConsensusAddress); }
public void AddSector(Address host, ShardID id) { Sector existing; if (shardMap.TryGetValue(id, out existing)) { existing.Host = host; return; } AddSector(host, id, sec => shardMap.Add(id, sec)); }
public Link Find(ShardID id) { foreach (var n in links) { if (n.ID == id) { return(n); } } return(null); }
public static FullShardAddress TryGetAddress(ShardID id) { if (OverrideAddressRequestFunction != null) { return(OverrideAddressRequestFunction(id)); } var h = hostRequests.TryGet(HostsStore, id); if (h == null) { return(new FullShardAddress()); } return(h.GetFullAddress(id)); }
public static Neighborhood NewSiblingList(ShardID myAddr, int replicaLevel, bool forceAllLinksPassive) { int at = 0; Neighborhood n = new Neighborhood(replicaLevel - 1); for (int i = 0; i < replicaLevel; i++) { if (i != myAddr.ReplicaLevel) { n.links[at] = new Link(new ShardID(myAddr.XYZ, i), i > myAddr.ReplicaLevel && !forceAllLinksPassive, at, true); at++; } } return(n); }
/// <summary> /// Creates a new link to a sibling shard /// </summary> /// <param name="remoteHost">Address of the remote shard</param> /// <param name="isActive">Actively establish the connection. If false, wait for inbound connection</param> /// <param name="linearIndex">Linear index in the neighborhood</param> /// <param name="isSibling">True if this is a link to a sibling shard (not a neighbor)</param> public Link(Address remoteHost, bool isActive, int linearIndex, bool isSibling, ShardID bindID) { ID = bindID; IsSibling = isSibling; LinearIndex = linearIndex; UpdateAddress(remoteHost); IsActive = isActive; if (isActive) { StartConnectionThread(); } writeThread = new Thread(new ThreadStart(WriteMain)); writeThread.Start(); Log.Message(Name + ": Created"); }
public static void Configure(ShardID addr, BaseDB.ConfigContainer config, bool forceAllLinksPassive) { CSLogicProvider.AsyncFactory = DB.GetLogicProviderAsync; ID = addr; gridExt = config.extent; Ranges = ToRanges(config); MySpace = SDToBox(addr.XYZ, config.extent); InconsistencyCoverage.CommonResolution = (int)Math.Ceiling(1f / Ranges.R); if (Extent.ReplicaLevel > 1) { siblings = Neighborhood.NewSiblingList(addr, Extent.ReplicaLevel, forceAllLinksPassive); } neighbors = Neighborhood.NewNeighborList(addr, Extent.XYZ, forceAllLinksPassive); }
public Interface(Configuration.Member self, Address selfAddress, Int3 myCoords, ThreadOperations threadOps, INotifiable notify, Action <Address> onAddressBound = null) : base(self) { Notify = notify; ThreadOps = threadOps; var cfg = BuildConfig(); if (!cfg.ContainsIdentifier(self)) { throw new ArgumentOutOfRangeException("Given self address is not contained by current SD configuration"); } Log.Message("Starting consensus with configuration " + cfg); actualPort = Start(cfg, selfAddress, onAddressBound); MyID = new ShardID(myCoords, self.Identifier); if (threadOps != ThreadOperations.Nothing) { gecThread = new Thread(new ThreadStart(GECThreadMain)); gecThread.Start(); } }
static void Main(string[] args) { if (args.Length < 2) { throw new ArgumentException("Missing arguments. Usage: Executable <DBHost> <ShardID>"); } int at = 0; var dbHost = new Address(args[at++]); BaseDB.Connect(dbHost); //,"admin","1234"); ShardID addr = ShardID.Decode(args[at++]); BaseDB.BeginPullConfig(addr.XYZ); iface = new Consensus.Interface(addr, -1, 0, true, Consensus.Interface.ThreadOperations.CheckConfiguration, new Notify(error => { Log.Error(error); iface.Dispose(); Log.Message("Shutting down"); }, () => iface)); iface.Notify.OnConsensusChange(Consensus.Status.NotEstablished, null); iface.AwaitClosure(); }
public void ConnectTo(Address dbHost, ShardID id) { BaseDB.Connect(dbHost); BaseDB.GetAddress(id, addr => AddSector(addr.ObserverAddress, addr.ShardID)); }
private void ThreadMain() { if (lastHost.IsEmpty) { return; } Debug.Log("Sector: Thread active"); try { while (!stop) { try { Debug.Log("Attempting to connect to " + lastHost); client = new TcpClient(lastHost.Host, lastHost.Port); var stream = new LZ4.LZ4Stream(client.GetStream(), LZ4.LZ4StreamMode.Decompress); var f = new BinaryFormatter(); CSLogicProvider.AsyncFactory = ResolveProvider; Debug.Log("Sector: Connected to " + lastHost); while (client.Connected) { Debug.Log("Sector: Deserializing next object"); var obj = f.UnsafeDeserialize(stream, null); Debug.Log("Sector: Deserialized object " + obj); if (obj is ShardID) { privateID = (ShardID)obj; Debug.Log("Sector: ID updated to " + privateID); OnNewNeighbor(privateID, lastHost); } else if (obj is ObserverTimingInfo) { secondsPerTLG = (float)((ObserverTimingInfo)obj).msPerTLG / 1000f; } else if (obj is CSLogicProvider) { var prov = (CSLogicProvider)obj; TaskCompletionSource <CSLogicProvider> entry; while (!providerMap.TryGetValue(prov.AssemblyName, out entry)) { providerMap.TryAdd(prov.AssemblyName, new TaskCompletionSource <CSLogicProvider>()); } if (!entry.Task.IsCompleted) { entry.SetResult(prov); } Debug.Log("Sector: Added new provider " + prov.AssemblyName); } else if (obj is FullShardAddress) { var h = (FullShardAddress)obj; newNeighbors.Add(h); } else if (obj is SDS) { SDS sds = (SDS)obj; //Debug.Log("Sector: Got new SDS. Deserializing entities..."); foreach (var e in sds.FinalEntities) { var logic = e.MyLogic as DynamicCSLogic; if (logic != null) { try { logic.FinishLoading(e.ID, TimeSpan.FromSeconds(1)); } catch (ExecutionException ex) { Debug.LogException(ex); } } } //Debug.Log("Sector: SDS processed. Signalling change"); SDS = sds; sdsChanged = true; } } } catch (SocketException ex) { Debug.LogException(ex); } catch (IOException ex) { Debug.LogException(ex); } catch (Exception ex) { Debug.LogException(ex); Debug.Log("Weird type: " + ex.GetType()); } try { client.Close(); } catch { }; { var naddr = BaseDB.TryGetAddress(ExpectedID); if (!naddr.IsEmpty) { lastHost = naddr.ObserverAddress; } } Debug.Log("Waiting, then retrying"); Thread.Sleep(2000); } } catch (Exception ex) { Debug.LogError("Encountered terminal exception"); Debug.LogException(ex); } }
private void ThreadMain() { Message("Starting Read"); BinaryReader reader = new BinaryReader(netStream); try { var f = new BinaryFormatter(); byte[] header = new byte[8]; while (!closed) { reader.RemainingBytes = 8; uint channel = reader.NextUInt(); reader.RemainingBytes = reader.NextInt(); try { switch (channel) { case (uint)ChannelID.RegisterLink: ShardID remoteID = reader.NextShardID(); ShardID localID = reader.NextShardID(); if (localID != Simulation.ID) { throw new IntegrityViolation("Remote shard expected this shard to be " + localID + ", not " + Simulation.ID); } var lnk = linkLookup?.Invoke(remoteID); if (lnk == null) { throw new IntegrityViolation("Remote shard identifies as " + remoteID + ", but this is not a known neighbor of this shard " + Simulation.ID); } lnk.SetPassiveClient(client); Abandon(); break; case (uint)ChannelID.RegisterReceiver: Guid guid = reader.NextGuid(); if (!guids.Contains(guid)) { Message("Authenticating as " + guid); guids.Add(guid); while (!guidMap.TryAdd(guid, this)) { InteractionLink link; if (guidMap.TryRemove(guid, out link)) { Message("Was already registered by " + link + ". Replacing..."); } } Message("Authenticated as " + guid); OnRegisterReceiver?.Invoke(guid); } break; case (uint)ChannelID.ShardLookup: { ShardID id = reader.NextShardID(); var addr = BaseDB.TryGetAddress(id); using (MemoryStream ms = new MemoryStream()) { var str = Encoding.ASCII.GetBytes(addr.Host); ms.Write(id.AsBytes, 0, 16); ms.Write(BitConverter.GetBytes(str.Length), 0, 4); ms.Write(str, 0, str.Length); ms.Write(BitConverter.GetBytes((ushort)addr.PeerPort), 0, 2); Send(new OutPackage((uint)ChannelID.ShardLookupResponse, ms.ToArray())); } } break; case (uint)ChannelID.UnregisterReceiver: { guid = reader.NextGuid(); if (guids.Contains(guid)) { Message("De-Authenticating as " + guid); guids.Remove(guid); guidMap.TryRemove(guid); OnUnregisterReceiver?.Invoke(guid); } } break; case (uint)ChannelID.SendMessage: { Guid from = reader.NextGuid(); Guid to = reader.NextGuid(); Guid id = reader.NextGuid(); int msgChannel = reader.NextInt(); byte[] data = reader.NextBytes(); //int targetGen = Simulation.EstimateNextSuitableMessageTargetGeneration(); if (!guids.Contains(from)) { Error("Not registered as " + from + ". Ignoring message"); } else { //int gen = Simulation.Stack.NewestFinishedSDSGeneration; ClientMessage msg = new ClientMessage(new ClientMessageID(from, to, id, msgChannel, orderIndex), data); var sender = new Address(this.endPoint); Simulation.Consensus?.Dispatch(msg, sender); OnMessage?.Invoke(msg, sender); } } break; } } catch (SerializationException ex) { Error(ex); } reader.SkipRemaining(); } } catch (SocketException) {} catch (Exception ex) { Error(ex); } Close(); }
public static void Run(ShardID myID) { //Host.Domain = ; listener = new Listener(h => FindLink(h)); observationListener = new ObservationLink.Listener(0); Consensus = new Consensus.Interface( new FullShardAddress(myID, null, listener.Port, 0, observationListener.Port), true, Interface.ThreadOperations.Everything, new DefaultNotify()); Configure(myID, BaseDB.Config, false); AdvertiseOldestGeneration(0); Log.Message("Polling SDS state..."); DB.Begin(myID.XYZ, s => FetchIncoming(null, s), s => FetchIncoming(null, s)); SimulationContext ctx = new SimulationContext(false); while (true) { CheckIncoming(TimingInfo.Current.TopLevelGeneration, ctx); if (stack.HasEntries) { break; } Thread.Sleep(1000); Console.Write('.'); Console.Out.Flush(); } var sds = stack.NewestConsistentSDS; Messages.TrimGenerations(sds.Generation - 1); Consensus.ForwardMessageGeneration(sds.Generation); Log.Message(" done. Waiting for logic assemblies to finish loading..."); foreach (var e in sds.FinalEntities) { var logic = e.MyLogic as DynamicCSLogic; if (logic != null) { logic.FinishLoading(e.ID, TimeSpan.FromMinutes(5)); } } Log.Message(" done"); Log.Message("Start Date=" + BaseDB.Timing.startTime); //{ // foreach (var link in neighbors) // DB.BeginFetch(link.InboundRCSStackID); //} // Log.Message("Catching up to g"+ TimingInfo.Current.TopLevelGeneration); while (stack.NewestFinishedSDSGeneration < TimingInfo.Current.TopLevelGeneration) { UpdateTitle("Catching up g" + stack.NewestFinishedSDSGeneration + "/" + TimingInfo.Current.TopLevelGeneration); //Log.Message("Catching up to g" + TimingInfo.Current.TopLevelGeneration); Console.Write("."); Console.Out.Flush(); int currentGen = stack.NewestFinishedSDSGeneration; int nextGen = currentGen + 1; ctx.SetGeneration(nextGen); stack.Append(new SDS(nextGen)); Debug.Assert(!stack.NewestRegisteredEntry.IsFinished); stack.Insert(new SDSComputation(Clock.Now, Messages.GetMessages(currentGen), TimingInfo.Current.EntityEvaluationTimeWindow, ctx).Complete()); Debug.Assert(stack.NewestRegisteredEntry.IsFinished); CheckIncoming(TimingInfo.Current.TopLevelGeneration, ctx); } Log.Message("done. Starting main loop..."); SDSComputation mainComputation = null, recoveryComputation = null; //main computation plus one recovery computation max int lastRecoveryIndex = -1; while (true) { var timing = TimingInfo.Current; CheckIncoming(timing.TopLevelGeneration, ctx); Log.Minor("TLG " + stack.NewestFinishedSDSGeneration + "/" + timing.TopLevelGeneration + " @recoveryStepIndex " + timing.LatestRecoveryStepIndex); { var newest = stack.NewestFinishedSDS; string title = ID + " g" + newest.Generation + " " + (float)(newest.IC.Size.Product - newest.IC.OneCount) * 100 / newest.IC.Size.Product + "% consistent"; var con = stack.NewestConsistentSDS; if (con != newest) { title += ", newest consistent at g" + con.Generation; } title += ", rec " + timing.LatestRecoveryStepIndex; UpdateTitle(title); } int newestSDSGeneration = stack.NewestFinishedSDSGeneration; if (mainComputation == null) { Debug.Assert(stack.NewestRegisteredEntry.IsFinished); Debug.Assert(newestSDSGeneration == stack.NewestRegisteredSDSGeneration); Debug.Assert(stack.NewestConsistentSDSIndex != -1); } if (recoveryComputation != null && Complete(recoveryComputation, timing, timing.TopLevelGeneration != newestSDSGeneration)) { recoveryComputation = null; } if (mainComputation != null && Complete(mainComputation, timing, timing.TopLevelGeneration != newestSDSGeneration && timing.TopLevelGeneration > mainComputation.Generation)) { newestSDSGeneration = stack.NewestFinishedSDSGeneration; Debug.Assert(stack.NewestRegisteredEntry.IsFinished); Debug.Assert(newestSDSGeneration == stack.NewestRegisteredSDSGeneration); Debug.Assert(stack.NewestConsistentSDSIndex != -1); mainComputation = null; } if (recoveryComputation != null && mainComputation != null) { Clock.SleepUntil(Helper.Min(recoveryComputation.Deadline, mainComputation.Deadline)); } else if (recoveryComputation != null) { Clock.SleepUntil(recoveryComputation.Deadline); } else if (mainComputation != null) { Clock.SleepUntil(mainComputation.Deadline); } if (recoveryComputation != null) //recovery computations are analogue to main computation, so main computation will not be done. but recovery must be { continue; } if (mainComputation == null && timing.TopLevelGeneration > newestSDSGeneration) { //fast forward: process now. don't care if we're at the beginning Debug.Assert(stack.NewestRegisteredEntry.IsFinished); Debug.Assert(newestSDSGeneration == stack.NewestRegisteredSDSGeneration); Debug.Assert(stack.NewestConsistentSDSIndex != -1); int nextGen = newestSDSGeneration + 1; Log.Message("Processing next TLG g" + nextGen); stack.Insert(new SDS(nextGen)); ctx.SetGeneration(nextGen); Debug.Assert(mainComputation == null); Consensus.ForceCommitGECIfLeader(newestSDSGeneration); mainComputation = new SDSComputation(timing.NextMainApplicationDeadline, Messages.GetMessages(newestSDSGeneration), timing.EntityEvaluationTimeWindow, ctx); } if (timing.ShouldStartRecovery(ref lastRecoveryIndex)) { //see if we can recover something int oldestInconsistentSDSIndex = stack.NewestConsistentSDSIndex + 1; //must be > 0 int top = Math.Min(stack.Size - 1, stack.ToIndex(timing.TopLevelGeneration)); if (oldestInconsistentSDSIndex <= top) { int end = mainComputation == null ? top + 1 : top; int recoverAtIndex = oldestInconsistentSDSIndex; int currentGen = stack[recoverAtIndex].Generation; for (; recoverAtIndex < end; recoverAtIndex++) { var current = stack[recoverAtIndex]; if (current.SignificantInboundChange) { break; } var check = CheckMissingRCS(current); if (check.ShouldRecoverThis) { break; } } if (recoverAtIndex < end) { var deadline = timing.GetRecoveryStepApplicationDeadline(lastRecoveryIndex); Log.Message("Recovering #" + recoverAtIndex + "/" + top + ", g" + stack[recoverAtIndex].Generation + ", deadline=" + deadline); //precompute: ctx.SetGeneration(stack[recoverAtIndex].Generation); recoveryComputation = new SDSComputation(deadline, Messages.GetMessages(ctx.GenerationNumber - 1), timing.EntityEvaluationTimeWindow, ctx); //now wait for remote RCS... } } } } }
// Update is called once per frame public void Update() { { FullShardAddress t; while (newNeighbors.TryTake(out t)) { Debug.Log(name + ": received neighbor update: " + t); OnNewNeighbor(t.ShardID, t.ObserverAddress); } } if (sdsChanged) { sdsChanged = false; { var id = privateID; if (id != publicID) { Debug.Log("ID change detected: " + id); publicID = id; name = publicID.ToString(); transform.name = publicID.ToString(); onNewID?.Invoke(id); if (cube != null) { cube.transform.position = Convert(publicID.XYZ) * Scale; } } } //Debug.Log("Sector: processing change"); updateNo++; SDS source = SDS; //Debug.Log("Sector: got "+transform.childCount+" children"); LazyList <GameObject> toDestroy = new LazyList <GameObject>(); foreach (Transform child in transform) { var obj = child.gameObject; if (obj.name == "cube") { //Debug.Log("Sector: got cube"); continue; } if (obj.hideFlags == HideFlags.HideAndDontSave) { continue; } obj.hideFlags = HideFlags.HideAndDontSave; obj.GetComponent <Renderer>().enabled = false; if (!availableEntityObjects.ContainsKey(obj.name)) { availableEntityObjects.Add(obj.name, obj); } else { toDestroy.Add(obj); } } foreach (var obj in toDestroy) { if (availableEntityObjects.ContainsValue(obj)) { Debug.LogError("Object " + obj.name + " still in use"); } else { Destroy(obj); } } //Debug.Log("Sector: recovered " + availableEntityObjects.Count + " objects"); int reused = 0; foreach (var e in source.FinalEntities) { GameObject obj; var next = Convert(e.ID.Position) * Scale; Vector3 prev = next; string key = e.ID.Guid.ToString(); if (!availableEntityObjects.ContainsKey(key)) { obj = entityPrototype != null?Instantiate(entityPrototype, transform) : new GameObject(); obj.GetComponent <Renderer>().material.color = myColor; obj.transform.parent = transform; obj.name = key; } else { obj = availableEntityObjects[key]; availableEntityObjects.Remove(key); if (obj == null) { Debug.LogError("Object " + key + " is null. Bad shit will happen"); } obj.hideFlags = HideFlags.None; obj.GetComponent <Renderer>().enabled = true; prev = obj.transform.position; reused++; } var c = obj.GetComponent <EntityComponent>(); if (c == null) { c = obj.AddComponent <EntityComponent>(); } c.SetState(next - Convert(e.Velocity) * Scale, next, secondsPerTLG); obj.transform.position = next; } //Debug.Log("Sector: got " + transform.childCount + " children, reusing "+reused); } }
public static Box ShardIDToBox(ShardID addr, ShardID ext) { return(Box.OffsetSize(new Vec3(addr.XYZ), new Vec3(1), addr.XYZ + 1 >= ext.XYZ)); }
/// <summary> /// Creates a new link to a sibling shard /// </summary> /// <param name="id">Remote shard ID</param> /// <param name="isActive">Actively establish the connection. If false, wait for inbound connection</param> /// <param name="linearIndex">Linear index in the neighborhood</param> /// <param name="isSibling">True if this is a link to a sibling shard (not a neighbor)</param> public Link(ShardID id, bool isActive, int linearIndex, bool isSibling) : this(BaseDB.TryGetPeerAddress(id), isActive, linearIndex, isSibling, id) { }
internal FullShardAddress GetFullAddress(ShardID id) { return(new FullShardAddress(id, host, peerPort, consensusPort, observerPort)); }
static void Main(string[] args) { //RunStupidModel(); //return; if (args.Length < 2) { Console.Error.WriteLine("Usage: shard <db url> <my addr> | shard <db url> --setup"); return; } try { int at = 0; var dbHost = new Address(args[at++]); BaseDB.Connect(dbHost); //,"admin","1234"); ShardID addr = ShardID.Decode(args[at++]); bool haveConfig = BaseDB.BeginPullConfig(addr.XYZ); if (!haveConfig) { Log.Error("Failed to establish connection to database"); Environment.Exit(-1); } Log.Message("Setting up clock"); Clock.NTPHost = BaseDB.Config.ntp; while (Clock.NumQueries < 1) { Thread.Sleep(100); } Log.Message("Starting up"); #if DRY_RUN if (addr == new ShardID()) //root { Log.Message("Resetting timer"); while (true) { Thread.Sleep(100); var t = BaseDB.Timing; if (t == null) { continue; } var n = Clock.Now + TimeSpan.FromSeconds(10); t.startTime = n.ToShortDateString() + " " + n.ToLongTimeString(); t.msGenerationBudget = 3000; //make sure we compute slowly BaseDB.Timing = t; break; } } #endif if ((addr.XYZ >= BaseDB.Config.extent).Any) { throw new ArgumentOutOfRangeException("addr", addr, "Exceeds extent: " + BaseDB.Config.extent); } if ((addr < ShardID.Zero).Any) { throw new ArgumentOutOfRangeException("addr", addr, "Is (partially) negative"); } Simulation.Run(addr); } catch (Exception ex) { Log.Error(ex); } }
public static void BeginFetch(ShardID id) { hostRequests.BeginFetch(HostsStore, id); }