/// <summary>
/// Create new instance of PeerConnectionFailedEventArgs for peer from given torrent.
/// </summary>
/// <param name="manager"></param>
/// <param name="peer"></param>
/// <param name="direction">Which direction the connection attempt was</param>
/// <param name="message">Message associated with the failure</param>
public PeerConnectionFailedEventArgs(TorrentManager manager, Peer peer, Direction direction, string message)
: base(manager)
{
Peer = peer;
ConnectionDirection = direction;
Message = message;
}
/// <summary>
/// Gets the peer metadata engine.
/// </summary>
/// <param name="engine">The engine.</param>
/// <param name="peer">The peer.</param>
/// <returns></returns>
private IPersistenceEngine GetPeerMetadataEngine(SyncEngine engine, Peer peer)
{
if (engine.SecondaryMetadataEngine == null || peer == Peer.Client)
return engine.MetadataEngine;
return engine.SecondaryMetadataEngine;
}
private void UpdatePeerSubscription(Peer peer, BindingKey subscription, UpdateAction action)
{
if (subscription.IsEmpty)
UpdatePeersMatchingAllMessages(peer, action);
else
_rootNode.Update(peer, subscription, action);
}
public void should_resolve_peer_using_basic_round_robin_for_different_commands()
{
// Arrange
var resolver = new RoundRobinPeerSelector();
var command1 = new FakeCommand(42);
var command1Peer1 = new Peer(new PeerId("command1peer1"), "endpoint1");
var command1Peer2 = new Peer(new PeerId("command1peer2"), "endpoint2");
var command1HandlingPeer = new[] { command1Peer1, command1Peer2 };
var command2 = new FakeInfrastructureCommand();
var command2Peer1 = new Peer(new PeerId("command2peer1"), "endpoint1");
var command2Peer2 = new Peer(new PeerId("command2peer2"), "endpoint2");
var command2HandlingPeer = new[] { command2Peer1, command2Peer2 };
// Act - Assert
var resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer1);
resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer2);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer1);
resolvedPeer = resolver.GetTargetPeer(command1, command1HandlingPeer);
resolvedPeer.ShouldEqual(command1Peer1);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer2);
resolvedPeer = resolver.GetTargetPeer(command2, command2HandlingPeer);
resolvedPeer.ShouldEqual(command2Peer1);
}
public Task SendGetHeaders(Peer peer)
{
if (!IsStarted)
return Task.CompletedTask;
var targetChainLocal = this.coreDaemon.TargetChain;
if (targetChainLocal == null)
return Task.CompletedTask;
var blockLocatorHashes = CalculateBlockLocatorHashes(targetChainLocal.Blocks);
// remove an existing request for this peer if it's stale
var now = DateTimeOffset.Now;
DateTimeOffset requestTime;
if (this.headersRequestsByPeer.TryGetValue(peer, out requestTime)
&& (now - requestTime) > STALE_REQUEST_TIME)
{
this.headersRequestsByPeer.TryRemove(peer, out requestTime);
}
// determine if a new request can be made
if (this.headersRequestsByPeer.TryAdd(peer, now))
// send out the request for headers
return peer.Sender.SendGetHeaders(blockLocatorHashes, hashStop: UInt256.Zero);
else
return Task.CompletedTask;
}
public void should_not_block_when_hitting_high_water_mark()
{
var senderTransport = CreateAndStartZmqTransport();
senderTransport.SocketOptions.SendHighWaterMark = 3;
senderTransport.SocketOptions.SendTimeout = 50.Milliseconds();
senderTransport.SocketOptions.SendRetriesBeforeSwitchingToClosedState = 2;
var receviedMessages = new List<TransportMessage>();
var upReceiverTransport = CreateAndStartZmqTransport(onMessageReceived: receviedMessages.Add);
var upReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Up"), upReceiverTransport.InboundEndPoint);
var downReceiverTransport = CreateAndStartZmqTransport();
var downReceiver = new Peer(new PeerId("Abc.Testing.Receiver.Down"), downReceiverTransport.InboundEndPoint);
downReceiverTransport.Stop();
for (var i = 1; i <= 10; ++i)
{
var message = new FakeCommand(i).ToTransportMessage();
senderTransport.Send(message, new[] { upReceiver, downReceiver });
var expectedMessageCount = i;
Wait.Until(() => receviedMessages.Count == expectedMessageCount, 500.Milliseconds(), "Failed to send message after " + i + " successful sent");
}
}
/// <summary>
/// Constructor
/// </summary>
public ChooseServiceProviderForm(Peer peerObject, ConnectWizard connectionWizard)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
peer = peerObject;
this.connectionWizard = connectionWizard;
this.Text = connectionWizard.SampleName + " - " + this.Text;
// Fill up our listbox with the service providers
ServiceProviderInformation[] serviceProviders = peer.GetServiceProviders(false);
foreach (ServiceProviderInformation info in serviceProviders)
lstSP.Items.Add(info);
txtUser.Text = null;
//Get the default username from the registry if it exists
Microsoft.Win32.RegistryKey regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\DirectX\\SDK\\csDPlay");
if (regKey != null) {
try {
txtUser.Text = (string)regKey.GetValue("DirectPlayUserName", null);
lstSP.SelectedIndex = (int)regKey.GetValue("DirectPlaySPIndex", 0);
regKey.Close();
}
catch {
txtUser.Text = null;
lstSP.SelectedIndex = 0;
}
}
else
lstSP.SelectedIndex = 0;
if ((txtUser.Text == null) || (txtUser.Text == "")) {
txtUser.Text = SystemInformation.UserName;
}
}
public FlowStream(ulong id, string signature, Peer peer, BaseRtmfpProtocol handler, Session band,FlowWriter localFlow)
: base(id, signature, _Name, peer, handler, band, localFlow)
{
if (handler.StreamsManager?.StreamsByType.ContainsKey(StreamTypes.ST_IN_NET_RTMFP)??false)
_publisher = handler.StreamsManager.StreamsByType[StreamTypes.ST_IN_NET_RTMFP].Select(x => x.Value as InNetRtmfpStream).SingleOrDefault(x=>x.PublisherId==StreamId);
//_publication = handler.Publications.Values.SingleOrDefault(x => x.PublisherId == _index);
}
internal ConnectionPool(Peer peer, int preAllocateAmount)
{
#if DEBUG
if (peer == null)
{
throw new ArgumentNullException("peer");
}
#endif
this.peer = peer;
Connection connection;
for (var i = 0; i < preAllocateAmount; ++i)
{
if (TryAllocate(out connection))
{
if (!TryPush(connection))
{
//TODO: Error
}
}
else
{
//TODO: Error
break;
}
}
}
public void Start(Peer peer, uint publisherId, FlowWriter controller)
{
if (PublisherId != 0)
{
if (controller != null)
{
controller.WriteStatusResponse("Publish.BadName", Name + "is already published");
}
}
PublisherId = publisherId;
string error;
if (!peer.OnPublish(this, out error))
{
if (String.IsNullOrEmpty(error)) error = "Not allowed to publish " + Name;
}
_publisher = peer;
_controller = controller;
_firstKeyFrame = false;
foreach (var listener in Listeners)
{
listener.Value.StartPublishing(Name);
}
Flush();
if (controller != null)
{
controller.WriteStatusResponse("Publish.Start", Name + "is now published");
}
}
private void UpdateCore(Peer peer, Subscription subscription, bool isAddOrUpdate)
{
if (subscription.IsMatchingAllMessages)
{
var list = _peersHandlingAllMessages
.Where(i => i.Id != peer.Id)
.ToList();
if (isAddOrUpdate)
list.Add(peer);
_peersHandlingAllMessages = list;
}
else
{
var list = _dynamicPeerSubscriptions
.Where(item => item.Peer.Id != peer.Id || !Equals(item.Subscription, subscription))
.ToList();
if (isAddOrUpdate)
list.Add(new PeerSubscription(peer, subscription));
Interlocked.Exchange(ref _dynamicPeerSubscriptions, list);
}
}
public DiscoverBuilder(Peer peer)
{
_peer = peer;
PortUdp = Ports.DefaultPort;
PortTcp = Ports.DefaultPort;
DiscoverTimeoutSec = 5;
}
/// <summary>
/// Constructor
/// </summary>
public CreateJoinForm(Peer peerObject, Address addressObject, ConnectWizard connectionWizard)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
peer = peerObject;
this.connectionWizard = connectionWizard;
this.Text = connectionWizard.SampleName + " - " + this.Text;
deviceAddress = addressObject;
//Set up the event handlers
peer.FindHostResponse += new FindHostResponseEventHandler(FindHostResponseMessage);
peer.ConnectComplete += new ConnectCompleteEventHandler(ConnectResult);
peer.AsyncOperationComplete += new AsyncOperationCompleteEventHandler(CancelAsync);
//Set up our timer
updateListTimer = new System.Timers.Timer(300); // A 300 ms interval
updateListTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.UpdateTimer);
updateListTimer.SynchronizingObject = this;
updateListTimer.Start();
//Set up our connect timer
connectTimer = new System.Timers.Timer(100); // A 100ms interval
connectTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.ConnectTimer);
connectTimer.SynchronizingObject = this;
// Set up our connect event
connectEvent = new ManualResetEvent(false);
}
/**
* Get the results from browsing and put it into the sharedFileList folder of the peer.
* Should maybe change the key to a Peer , but since implementation is unknown
* no assurance that hashcode will be the same ...
* */
public void BrowsingTerminated(Peer peer, SearchResult Results, List<G2PacketQH2> resultPackets)
{
if (resultPackets.Count == 0)
{
RegroupResults(Results); // if no results from browsing directly sends results
return;
}
Results.PeerCollection.Add(peer);
Peer p = Results.PeerCollection.Find(peer);
int fileCount = 0;
// add results !!
foreach(G2PacketQH2 qh2 in resultPackets)
{
foreach(G2Packet child in qh2.children)
{
if (!child.type.Equals(G2PacketType.H))
continue;
G2PacketH hit = child as G2PacketH;
G2File file = G2File.ParseHit(hit,FileLocationFound.SharedLocalComputer);
if (file == null) continue;
p.SharedLocalfilesList.Add(file);
file.PeerDiffusedFiles.Add(p);
SharedTotalFiles++;
fileCount++;
}
}
G2Log.Write("SearchResults : New Browsing Result from " + p.Ip + ":" + p.Port + " ==> " + p.Files.Count + " files && " + p.SharedLocalfilesList.Count + " shared files ...");
RegroupResults(Results);
}
public PeerDescriptor(PeerId id, string endPoint, bool isPersistent, bool isUp, bool isResponding, DateTime timestampUtc, params Subscription[] subscriptions)
{
Peer = new Peer(id, endPoint, isUp, isResponding);
Subscriptions = subscriptions;
IsPersistent = isPersistent;
TimestampUtc = timestampUtc;
}
internal PeerDescriptor(PeerDescriptor other)
{
Peer = new Peer(other.Peer);
Subscriptions = ArrayUtil.Copy(other.Subscriptions) ?? ArrayUtil.Empty<Subscription>();
IsPersistent = other.IsPersistent;
TimestampUtc = other.TimestampUtc;
HasDebuggerAttached = other.HasDebuggerAttached;
}
public NewConnectionEventArgs(Peer peer, IConnection connection, TorrentManager manager)
: base(manager)
{
if (!connection.IsIncoming && manager == null)
throw new InvalidOperationException("An outgoing connection must specify the torrent manager it belongs to");
this.connection = connection;
this.peer = peer;
}
public void Setup()
{
_configurationMock = new Mock<IDirectoryConfiguration>();
_bus = new TestBus();
var peer = new Peer(new PeerId("Abc.Testing.0"), "tcp://abctest:12300");
var peerDescriptor = peer.ToPeerDescriptor(true);
_entry = new DeadPeerDetectorEntry(peerDescriptor, _configurationMock.Object, _bus, new CurrentThreadTaskScheduler());
}
public static TransportMessage ToTransportMessage(this IMessage message, Peer sender = null)
{
sender = sender ?? new Peer(new PeerId("Abc.Testing.Peer"), "tcp://abctest:159");
var serializer = new MessageSerializer();
var messageBytes = serializer.Serialize(message);
return new TransportMessage(message.TypeId(), messageBytes, sender);
}
public PeerEntry(PeerDescriptor descriptor, ConcurrentDictionary<MessageTypeId, PeerSubscriptionTree> globalSubscriptionsIndex)
{
Peer = new Peer(descriptor.Peer);
IsPersistent = descriptor.IsPersistent;
TimestampUtc = descriptor.TimestampUtc ?? DateTime.UtcNow;
HasDebuggerAttached = descriptor.HasDebuggerAttached;
_globalSubscriptionsIndex = globalSubscriptionsIndex;
}
public void simple_subscription_key_should_simple_routing_key()
{
var peerSubscriptionTree = new PeerSubscriptionTree();
var peer = new Peer(new PeerId("Abc.Testing.0"), "tcp://test:123");
peerSubscriptionTree.Add(peer, new BindingKey("a"));
var matchingPeer = peerSubscriptionTree.GetPeers(new BindingKey("a")).ExpectedSingle();
matchingPeer.Id.ShouldEqual(peer.Id);
}
void Start()
{
InputFieldAddress.text = "127.0.0.1";
peer = new Peer(PORT);
peer.onConnectionReceived += new Peer.ConnectionHandler(onPeerConnected);
Debug.Log ("Socket alive: " + peer.socketAlive.ToString());
}
private Networking()
{
peer = new Peer();
//peer.ApplicationDescription.SessionName = "Turbo Gravity Lemming Raketty Force";
peer.PlayerCreated += new PlayerCreatedEventHandler(peer_PlayerCreated);
peer.PlayerDestroyed += new PlayerDestroyedEventHandler(peer_PlayerDestroyed);
peer.PeerInformation += new PeerInformationEventHandler(peer_PeerInformation);
peer.Receive += new ReceiveEventHandler(peer_Receive);
}
public void empty_subscription_key_should_match_empty_routing_key()
{
var peerSubscriptionTree = new PeerSubscriptionTree();
var peer = new Peer(new PeerId("Abc.Testing.0"), "tcp://test:123");
peerSubscriptionTree.Add(peer, BindingKey.Empty);
var matchingPeer = peerSubscriptionTree.GetPeers(BindingKey.Empty).ExpectedSingle();
matchingPeer.Id.ShouldEqual(peer.Id);
}
private static void UpdateList(ref List<Peer> peers, Peer peer, UpdateAction action)
{
var newPeers = new List<Peer>(peers.Capacity);
newPeers.AddRange(peers.Where(x => x.Id != peer.Id));
if (action == UpdateAction.Add)
newPeers.Add(peer);
peers = newPeers;
}
public static InputPeer PeerToInputPeer(Peer peer) {
switch(peer.Constructor) {
case Constructor.peerUser: // TODO: foreign and self cases
return TL.inputPeerContact(((PeerUserConstructor) peer).user_id);
case Constructor.peerChat:
return TL.inputPeerChat(((PeerChatConstructor) peer).chat_id);
default:
throw new Exception("invalid constructor");
}
}
/// <summary>
/// Received handler for listener.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="peerFrom">The peer.</param>
private void OnReceiveHandler(byte[] data, Peer peerFrom)
{
Assert.AreEqual(
CommonHelper.ByteToString(this.lastData),
CommonHelper.ByteToString(data));
Assert.AreEqual(this.lastPeerFrom.IP, peerFrom.IP);
this.received = true;
}
public void Setup()
{
_listener = new TcpListener(9999);
_connectedEvent = new ManualResetEvent(false);
_communicationManager = new CommunicationManager(_listener);
_communicationManager.PeerConnected += (sender, args) => {
_peer = args.Peer;
_connectedEvent.Set();
};
_listener.Start();
}
public void should_throw_exception_if_several_peers_can_handle_a_command()
{
var command = new FakeCommand(456);
var peer1 = new Peer(new PeerId("Abc.Testing.Peer1"), "Peer1Endpoint");
var peer2 = new Peer(new PeerId("Abc.Testing.Peer2"), "Peer2Endpoint");
SetupPeersHandlingMessage<FakeCommand>(peer1, peer2);
_bus.Start();
Assert.Throws<InvalidOperationException>(() => _bus.Send(command));
}
public void RemoveListener(Peer peer,uint id)
{
if (Listeners.ContainsKey(id))
{
peer.OnUnsubscribe(Listeners[id]);
Listeners[id].Dispose();
Listeners.Remove(id);
}
else
{
Logger.WARN("Listener {0} is already unsubscribed of publication {1}",id,PublisherId);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="peer"></param>
/// <param name="applicationGuid"></param>
/// <param name="sampleName"></param>
public ConnectWizard(Peer peer, Guid application, string sampleName)
{
peerObject = peer;
applicationGuid = application;
samplename = sampleName;
}
public static Message Parse(
NetMQMessage raw,
bool reply,
AppProtocolVersion localVersion,
IImmutableSet <PublicKey> trustedAppProtocolVersionSigners,
DifferentAppProtocolVersionEncountered differentAppProtocolVersionEncountered)
{
if (raw.FrameCount == 0)
{
throw new ArgumentException("Can't parse empty NetMQMessage.");
}
// (reply == true) [version, type, peer, sign, frames...]
// (reply == false) [identity, version, type, peer, sign, frames...]
NetMQFrame[] remains = reply ? raw.ToArray() : raw.Skip(1).ToArray();
var versionToken = remains[(int)MessageFrame.Version].ConvertToString();
AppProtocolVersion remoteVersion = AppProtocolVersion.FromToken(versionToken);
Peer remotePeer = null;
try
{
remotePeer = DeserializePeer(remains[(int)MessageFrame.Peer].ToByteArray());
}
catch (Exception)
{
// If failed to find out remotePeer, leave it null.
}
if (!IsAppProtocolVersionValid(
remotePeer,
localVersion,
remoteVersion,
trustedAppProtocolVersionSigners,
differentAppProtocolVersionEncountered))
{
throw new DifferentAppProtocolVersionException(
"Received message's version is not valid.",
reply ? null : raw[0].Buffer.ToArray(),
localVersion,
remoteVersion);
}
var rawType = (MessageType)remains[(int)MessageFrame.Type].ConvertToInt32();
var peer = remains[(int)MessageFrame.Peer].ToByteArray();
byte[] signature = remains[(int)MessageFrame.Sign].ToByteArray();
NetMQFrame[] body = remains.Skip(CommonFrames).ToArray();
// FIXME: The below code is too repetitive and prone to miss to add, which means,
// when you add a new message type, you adds an enum member to MessageType and
// a corresponding subclass of Message, but misses to add that correspondence here,
// you may take a long time to be aware you've missed here, because the code is still
// built well and it looks like just Swarm<T> silently ignore new messages.
// At least this correspondence map should not be here.
var types = new Dictionary <MessageType, Type>
{
{ MessageType.Ping, typeof(Ping) },
{ MessageType.Pong, typeof(Pong) },
{ MessageType.GetBlockHashes, typeof(GetBlockHashes) },
{ MessageType.BlockHashes, typeof(BlockHashes) },
{ MessageType.TxIds, typeof(TxIds) },
{ MessageType.GetBlocks, typeof(GetBlocks) },
{ MessageType.GetTxs, typeof(GetTxs) },
{ MessageType.Blocks, typeof(Blocks) },
{ MessageType.Tx, typeof(Tx) },
{ MessageType.FindNeighbors, typeof(FindNeighbors) },
{ MessageType.Neighbors, typeof(Neighbors) },
{ MessageType.GetRecentStates, typeof(GetRecentStates) },
{ MessageType.RecentStates, typeof(RecentStates) },
{ MessageType.BlockHeaderMessage, typeof(BlockHeaderMessage) },
{ MessageType.GetChainStatus, typeof(GetChainStatus) },
{ MessageType.ChainStatus, typeof(ChainStatus) },
{ MessageType.GetBlockStates, typeof(GetBlockStates) },
{ MessageType.BlockStates, typeof(BlockStates) },
{ MessageType.DifferentVersion, typeof(DifferentVersion) },
};
if (!types.TryGetValue(rawType, out Type type))
{
throw new InvalidMessageException(
$"Can't determine NetMQMessage. [type: {rawType}]");
}
var message = (Message)Activator.CreateInstance(
type, new[] { body });
message.Version = remoteVersion;
message.Remote = remotePeer;
if (!message.Remote.PublicKey.Verify(body.ToByteArray(), signature))
{
throw new InvalidMessageException(
"The message signature is invalid"
);
}
if (!reply)
{
message.Identity = raw[0].Buffer.ToArray();
}
return(message);
}
public override void Read(BinaryReader reader)
{
this.peer = Tl.Parse <Peer>(reader);
this.top_message = reader.ReadInt32();
this.unread_count = reader.ReadInt32();
}
/// <summary>
/// Creates a new instance of the <see cref="IpfsEngine"/> class.
/// </summary>
public IpfsEngine(char[] passphrase)
{
this.passphrase = passphrase;
// Init the core api inteface.
Bitswap = new BitswapApi(this);
Block = new BlockApi(this);
Bootstrap = new BootstrapApi(this);
Config = new ConfigApi(this);
Dag = new DagApi(this);
Dht = new DhtApi(this);
Dns = new DnsApi(this);
FileSystem = new FileSystemApi(this);
Generic = new GenericApi(this);
Key = new KeyApi(this);
Name = new NameApi(this);
Object = new ObjectApi(this);
Pin = new PinApi(this);
PubSub = new PubSubApi(this);
Stats = new StatsApi(this);
Swarm = new SwarmApi(this);
// Async properties
LocalPeer = new AsyncLazy <Peer>(async() =>
{
log.Debug("Building local peer");
var keyChain = await KeyChain();
log.Debug("Getting key info about self");
var self = await keyChain.FindKeyByNameAsync("self");
var localPeer = new Peer();
localPeer.Id = self.Id;
localPeer.PublicKey = await keyChain.GetPublicKeyAsync("self");
localPeer.ProtocolVersion = "ipfs/0.1.0";
var version = typeof(IpfsEngine).GetTypeInfo().Assembly.GetName().Version;
localPeer.AgentVersion = $"net-ipfs/{version.Major}.{version.Minor}.{version.Revision}";
log.Debug("Built local peer");
return(localPeer);
});
SwarmService = new AsyncLazy <Swarm>(async() =>
{
log.Debug("Building swarm service");
var peer = await LocalPeer;
var keyChain = await KeyChain();
var self = await keyChain.GetPrivateKeyAsync("self");
var swarm = new Swarm
{
LocalPeer = peer,
LocalPeerKey = PeerTalk.Cryptography.Key.CreatePrivateKey(self)
};
log.Debug("Built swarm service");
return(swarm);
});
BitswapService = new AsyncLazy <BlockExchange.Bitswap>(async() =>
{
log.Debug("Building bitswap service");
var bitswap = new BlockExchange.Bitswap
{
Swarm = await SwarmService,
BlockService = Block
};
log.Debug("Built bitswap service");
return(bitswap);
});
DhtService = new AsyncLazy <PeerTalk.Routing.Dht1>(async() =>
{
log.Debug("Building DHT service");
var dht = new PeerTalk.Routing.Dht1
{
Swarm = await SwarmService
};
dht.Swarm.Router = dht;
log.Debug("Built DHT service");
return(dht);
});
}
public void Add(TorrentManager manager, IConnection connection)
{
var peer = new Peer(string.Empty, new Uri("tcp://12.123.123.1:2342"));
base.RaiseConnectionReceived(peer, connection, manager);
}
public void Server_OnPeerConnected(Peer obj)
{
Debug.Log("Peer connected!");
DataController.Instance.applicationState = DataController.ApplicationState.ServerSynchronising;
}
private void ThreadWorker(Object parameters)
{
if (Verbosity > 0)
{
Debug.Log("Ignorance Server: Initializing. Please stand by...");
}
// Thread cache items
ThreadParamInfo setupInfo;
Address serverAddress = new Address();
Host serverENetHost;
Event serverENetEvent;
Peer[] serverPeerArray;
IgnoranceClientStats peerStats = default;
// Grab the setup information.
if (parameters.GetType() == typeof(ThreadParamInfo))
{
setupInfo = (ThreadParamInfo)parameters;
}
else
{
Debug.LogError("Ignorance Server: Startup failure; Invalid thread parameters. Aborting.");
return;
}
// Attempt to initialize ENet inside the thread.
if (Library.Initialize())
{
Debug.Log("Ignorance Server: ENet Native successfully initialized.");
}
else
{
Debug.LogError("Ignorance Server: Failed to initialize ENet Native. Aborting.");
return;
}
// Configure the server address.
serverAddress.SetHost(setupInfo.Address);
serverAddress.Port = (ushort)setupInfo.Port;
serverPeerArray = new Peer[setupInfo.Peers];
using (serverENetHost = new Host())
{
// Create the server object.
try
{
serverENetHost.Create(serverAddress, setupInfo.Peers, setupInfo.Channels);
}
catch (Exception ex)
{
Debug.LogError($"Ignorance Server: While attempting to create server host object, we caught an exception:\n{ex.Message}");
Debug.LogError($"If you are getting a \"Host creation call failed\" exception, please ensure you don't have a server already running on the same IP and Port.\n" +
$"Multiple server instances running on the same port are not supported. Also check to see if ports are not in-use by another application. In the worse case scenario, " +
$"restart your device to ensure no random background ENet threads are active that haven't been cleaned up correctly. If problems persist, please file a support ticket.");
Library.Deinitialize();
return;
}
// Loop until we're told to cease operations.
while (!CeaseOperation)
{
// Intermission: Command Handling
while (Commands.TryDequeue(out IgnoranceCommandPacket commandPacket))
{
switch (commandPacket.Type)
{
default:
break;
// Boot a Peer off the Server.
case IgnoranceCommandType.ServerKickPeer:
uint targetPeer = commandPacket.PeerId;
if (!serverPeerArray[targetPeer].IsSet)
{
continue;
}
if (setupInfo.Verbosity > 0)
{
Debug.Log($"Ignorance Server: Booting Peer {targetPeer} off");
}
IgnoranceConnectionEvent iced = new IgnoranceConnectionEvent
{
EventType = 0x01,
NativePeerId = targetPeer
};
DisconnectionEvents.Enqueue(iced);
// Disconnect and reset the peer array's entry for that peer.
serverPeerArray[targetPeer].DisconnectNow(0);
serverPeerArray[targetPeer] = default;
break;
case IgnoranceCommandType.ServerStatusRequest:
IgnoranceServerStats serverStats;
if (!RecycledServerStatBlocks.TryDequeue(out serverStats))
{
serverStats.PeerStats = new Dictionary <int, IgnoranceClientStats>(setupInfo.Peers);
}
serverStats.PeerStats.Clear();
serverStats.BytesReceived = serverENetHost.BytesReceived;
serverStats.BytesSent = serverENetHost.BytesSent;
serverStats.PacketsReceived = serverENetHost.PacketsReceived;
serverStats.PacketsSent = serverENetHost.PacketsSent;
serverStats.PeersCount = serverENetHost.PeersCount;
for (int i = 0; i < serverPeerArray.Length; i++)
{
if (!serverPeerArray[i].IsSet)
{
continue;
}
peerStats.RTT = serverPeerArray[i].RoundTripTime;
peerStats.BytesReceived = serverPeerArray[i].BytesReceived;
peerStats.BytesSent = serverPeerArray[i].BytesSent;
peerStats.PacketsSent = serverPeerArray[i].PacketsSent;
peerStats.PacketsLost = serverPeerArray[i].PacketsLost;
serverStats.PeerStats.Add(i, peerStats);
}
StatusUpdates.Enqueue(serverStats);
break;
}
}
// Step One:
// ---> Sending to peers
while (Outgoing.TryDequeue(out IgnoranceOutgoingPacket outgoingPacket))
{
// Only create a packet if the server knows the peer.
if (serverPeerArray[outgoingPacket.NativePeerId].IsSet)
{
int ret = serverPeerArray[outgoingPacket.NativePeerId].Send(outgoingPacket.Channel, ref outgoingPacket.Payload);
if (ret < 0 && setupInfo.Verbosity > 0)
{
Debug.LogWarning($"Ignorance Server: ENet error {ret} while sending packet to Peer {outgoingPacket.NativePeerId}.");
}
}
else
{
// A peer might have disconnected, this is OK - just log the packet if set to paranoid.
if (setupInfo.Verbosity > 1)
{
Debug.LogWarning("Ignorance Server: Can't send packet, a native peer object is not set. This may be normal if the Peer has disconnected before this send cycle.");
}
}
}
// Step 2
// <--- Receiving from peers
bool pollComplete = false;
while (!pollComplete)
{
Packet incomingPacket;
Peer incomingPeer;
int incomingPacketLength;
// Any events happening?
if (serverENetHost.CheckEvents(out serverENetEvent) <= 0)
{
// If service time is met, break out of it.
if (serverENetHost.Service(setupInfo.PollTime, out serverENetEvent) <= 0)
{
break;
}
pollComplete = true;
}
// Setup the packet references.
incomingPeer = serverENetEvent.Peer;
// What type are you?
switch (serverENetEvent.Type)
{
// Idle.
case EventType.None:
default:
break;
// Connection Event.
case EventType.Connect:
if (setupInfo.Verbosity > 1)
{
Debug.Log($"Ignorance Server: Peer ID {incomingPeer.ID} says Hi.");
}
IgnoranceConnectionEvent ice = new IgnoranceConnectionEvent()
{
NativePeerId = incomingPeer.ID,
IP = incomingPeer.IP,
Port = incomingPeer.Port
};
ConnectionEvents.Enqueue(ice);
// Assign a reference to the Peer.
serverPeerArray[incomingPeer.ID] = incomingPeer;
break;
// Disconnect/Timeout. Mirror doesn't care if it's either, so we lump them together.
case EventType.Disconnect:
case EventType.Timeout:
if (!serverPeerArray[incomingPeer.ID].IsSet)
{
break;
}
if (setupInfo.Verbosity > 1)
{
Debug.Log($"Ignorance Server: Peer {incomingPeer.ID} has disconnected.");
}
IgnoranceConnectionEvent iced = new IgnoranceConnectionEvent
{
EventType = 0x01,
NativePeerId = incomingPeer.ID
};
DisconnectionEvents.Enqueue(iced);
// Reset the peer array's entry for that peer.
serverPeerArray[incomingPeer.ID] = default;
break;
case EventType.Receive:
// Receive event type usually includes a packet; so cache its reference.
incomingPacket = serverENetEvent.Packet;
if (!incomingPacket.IsSet)
{
if (setupInfo.Verbosity > 0)
{
Debug.LogWarning($"Ignorance Server: A receive event did not supply us with a packet to work with. This should never happen.");
}
break;
}
incomingPacketLength = incomingPacket.Length;
// Firstly check if the packet is too big. If it is, do not process it - drop it.
if (incomingPacketLength > setupInfo.PacketSizeLimit)
{
if (setupInfo.Verbosity > 0)
{
Debug.LogWarning($"Ignorance Server: Incoming packet is too big. My limit is {setupInfo.PacketSizeLimit} byte(s) whilest this packet is {incomingPacketLength} bytes.");
}
incomingPacket.Dispose();
break;
}
IgnoranceIncomingPacket incomingQueuePacket = new IgnoranceIncomingPacket
{
Channel = serverENetEvent.ChannelID,
NativePeerId = incomingPeer.ID,
Payload = incomingPacket,
};
// Enqueue.
Incoming.Enqueue(incomingQueuePacket);
break;
}
}
}
if (Verbosity > 0)
{
Debug.Log("Ignorance Server: Thread shutdown commencing. Flushing connections.");
}
// Cleanup and flush everything.
serverENetHost.Flush();
// Kick everyone.
for (int i = 0; i < serverPeerArray.Length; i++)
{
if (!serverPeerArray[i].IsSet)
{
continue;
}
serverPeerArray[i].DisconnectNow(0);
}
}
if (setupInfo.Verbosity > 0)
{
Debug.Log("Ignorance Server: Shutdown complete.");
}
Library.Deinitialize();
}
public override void SendNextPackets()
{
//check sending acks
if (_mustSendAcks)
{
_mustSendAcks = false;
NetDebug.Write("[RR]SendAcks");
Monitor.Enter(_outgoingAcks);
Peer.SendUserData(_outgoingAcks);
Monitor.Exit(_outgoingAcks);
}
long currentTime = DateTime.UtcNow.Ticks;
Monitor.Enter(_pendingPackets);
//get packets from queue
Monitor.Enter(OutgoingQueue);
while (OutgoingQueue.Count > 0)
{
int relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart);
if (relate < _windowSize)
{
PendingPacket pendingPacket = _pendingPackets[_localSeqence % _windowSize];
pendingPacket.Sended = false;
pendingPacket.Packet = OutgoingQueue.Dequeue();
pendingPacket.Packet.Sequence = (ushort)_localSeqence;
_localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence;
}
else //Queue filled
{
break;
}
}
Monitor.Exit(OutgoingQueue);
//send
double resendDelay = Peer.ResendDelay;
for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence)
{
PendingPacket currentPacket = _pendingPackets[pendingSeq % _windowSize];
if (currentPacket.Packet == null)
{
continue;
}
if (currentPacket.Sended) //check send time
{
double packetHoldTime = currentTime - currentPacket.TimeStamp;
if (packetHoldTime < resendDelay * TimeSpan.TicksPerMillisecond)
{
continue;
}
NetDebug.Write("[RC]Resend: {0} > {1}", (int)packetHoldTime, resendDelay);
}
currentPacket.TimeStamp = currentTime;
currentPacket.Sended = true;
Peer.SendUserData(currentPacket.Packet);
}
Monitor.Exit(_pendingPackets);
}
//Process incoming packet
public override void ProcessPacket(NetPacket packet)
{
int seq = packet.Sequence;
if (seq >= NetConstants.MaxSequence)
{
NetDebug.Write("[RR]Bad sequence");
return;
}
int relate = NetUtils.RelativeSequenceNumber(seq, _remoteWindowStart);
int relateSeq = NetUtils.RelativeSequenceNumber(seq, _remoteSequence);
if (relateSeq > _windowSize)
{
NetDebug.Write("[RR]Bad sequence");
return;
}
//Drop bad packets
if (relate < 0)
{
//Too old packet doesn't ack
NetDebug.Write("[RR]ReliableInOrder too old");
return;
}
if (relate >= _windowSize * 2)
{
//Some very new packet
NetDebug.Write("[RR]ReliableInOrder too new");
return;
}
//If very new - move window
int ackIdx;
int ackByte;
int ackBit;
Monitor.Enter(_outgoingAcks);
if (relate >= _windowSize)
{
//New window position
int newWindowStart = (_remoteWindowStart + relate - _windowSize + 1) % NetConstants.MaxSequence;
_outgoingAcks.Sequence = (ushort)newWindowStart;
//Clean old data
while (_remoteWindowStart != newWindowStart)
{
ackIdx = _remoteWindowStart % _windowSize;
ackByte = NetConstants.SequencedHeaderSize + ackIdx / BitsInByte;
ackBit = ackIdx % BitsInByte;
_outgoingAcks.RawData[ackByte] &= (byte)~(1 << ackBit);
_remoteWindowStart = (_remoteWindowStart + 1) % NetConstants.MaxSequence;
}
}
//Final stage - process valid packet
//trigger acks send
_mustSendAcks = true;
ackIdx = seq % _windowSize;
ackByte = NetConstants.SequencedHeaderSize + ackIdx / BitsInByte;
ackBit = ackIdx % BitsInByte;
if ((_outgoingAcks.RawData[ackByte] & (1 << ackBit)) != 0)
{
NetDebug.Write("[RR]ReliableInOrder duplicate");
Monitor.Exit(_outgoingAcks);
return;
}
//save ack
_outgoingAcks.RawData[ackByte] |= (byte)(1 << ackBit);
Monitor.Exit(_outgoingAcks);
//detailed check
if (seq == _remoteSequence)
{
NetDebug.Write("[RR]ReliableInOrder packet succes");
Peer.AddIncomingPacket(packet);
_remoteSequence = (_remoteSequence + 1) % NetConstants.MaxSequence;
if (_ordered)
{
NetPacket p;
while ((p = _receivedPackets[_remoteSequence % _windowSize]) != null)
{
//process holded packet
_receivedPackets[_remoteSequence % _windowSize] = null;
Peer.AddIncomingPacket(p);
_remoteSequence = (_remoteSequence + 1) % NetConstants.MaxSequence;
}
}
else
{
while (_earlyReceived[_remoteSequence % _windowSize])
{
//process early packet
_earlyReceived[_remoteSequence % _windowSize] = false;
_remoteSequence = (_remoteSequence + 1) % NetConstants.MaxSequence;
}
}
return;
}
//holded packet
if (_ordered)
{
_receivedPackets[ackIdx] = packet;
}
else
{
_earlyReceived[ackIdx] = true;
Peer.AddIncomingPacket(packet);
}
}
//ProcessAck in packet
public void ProcessAck(NetPacket packet)
{
if (packet.Size != _outgoingAcks.Size)
{
NetDebug.Write("[PA]Invalid acks packet size");
return;
}
ushort ackWindowStart = packet.Sequence;
int windowRel = NetUtils.RelativeSequenceNumber(_localWindowStart, ackWindowStart);
if (ackWindowStart >= NetConstants.MaxSequence || windowRel < 0)
{
NetDebug.Write("[PA]Bad window start");
return;
}
//check relevance
if (windowRel >= _windowSize)
{
NetDebug.Write("[PA]Old acks");
return;
}
byte[] acksData = packet.RawData;
Monitor.Enter(_pendingPackets);
for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence)
{
int rel = NetUtils.RelativeSequenceNumber(pendingSeq, ackWindowStart);
if (rel >= _windowSize)
{
NetDebug.Write("[PA]REL: " + rel);
break;
}
int pendingIdx = pendingSeq % _windowSize;
int currentByte = NetConstants.SequencedHeaderSize + pendingIdx / BitsInByte;
int currentBit = pendingIdx % BitsInByte;
if ((acksData[currentByte] & (1 << currentBit)) == 0)
{
#if STATS_ENABLED || DEBUG
Peer.Statistics.PacketLoss++;
#endif
//Skip false ack
NetDebug.Write("[PA]False ack: {0}", pendingSeq);
continue;
}
if (pendingSeq == _localWindowStart)
{
//Move window
_localWindowStart = (_localWindowStart + 1) % NetConstants.MaxSequence;
}
//clear packet
var pendingPacket = _pendingPackets[pendingIdx];
if (pendingPacket.Packet != null)
{
Peer.Recycle(pendingPacket.Packet);
pendingPacket.Packet = null;
NetDebug.Write("[PA]Removing reliableInOrder ack: {0} - true", pendingSeq);
}
}
Monitor.Exit(_pendingPackets);
}
public bool HandlePacket(Peer peer, byte[] data)
{
var response = new QueryStatus();
return(_game.PacketHandlerManager.sendPacket(peer, response, Channel.CHL_S2C));
}
public SendDirectBuilder(Peer peer, PeerConnection peerConnection)
{
_peer = peer;
RecipientAddress = null;
PeerConnection = peerConnection;
}
public SendDirectBuilder(Peer peer, TcsPeerConnection tcsPeerConnection)
{
_peer = peer;
RecipientAddress = null;
TcsRecipientConnection = tcsPeerConnection;
}
private Channel ReconstructChannel(string name, HFClient client, SampleOrg sampleOrg)
{
Util.COut("Reconstructing {0} channel", name);
client.UserContext = sampleOrg.GetUser(TESTUSER_1_NAME);
Channel newChannel;
if (BAR_CHANNEL_NAME.Equals(name))
{
// bar channel was stored in samplestore in End2endIT testcase.
/**
* sampleStore.getChannel uses {@link HFClient#deSerializeChannel(byte[])}
*/
newChannel = sampleStore.GetChannel(client, name);
if (!IS_FABRIC_V10)
{
// Make sure there is one of each type peer at the very least. see End2end for how peers were constructed.
Assert.IsFalse(newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count == 0);
Assert.IsFalse(newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count == 0);
}
Assert.AreEqual(testConfig.IsFabricVersionAtOrAfter("1.3") ? 0 : 2, newChannel.EventHubs.Count);
Util.COut("Retrieved channel {0} from sample store.", name);
}
else
{
newChannel = client.NewChannel(name);
foreach (string ordererName in sampleOrg.GetOrdererNames())
{
newChannel.AddOrderer(client.NewOrderer(ordererName, sampleOrg.GetOrdererLocation(ordererName), testConfig.GetOrdererProperties(ordererName)));
}
bool everyOther = false;
foreach (string peerName in sampleOrg.GetPeerNames())
{
string peerLocation = sampleOrg.GetPeerLocation(peerName);
Properties peerProperties = testConfig.GetPeerProperties(peerName);
Peer peer = client.NewPeer(peerName, peerLocation, peerProperties);
PeerOptions peerEventingOptions = // we have two peers on one use block on other use filtered
everyOther ? PeerOptions.CreatePeerOptions().RegisterEventsForBlocks().SetPeerRoles(PeerRole.ENDORSING_PEER, PeerRole.LEDGER_QUERY, PeerRole.CHAINCODE_QUERY, PeerRole.EVENT_SOURCE) : PeerOptions.CreatePeerOptions().RegisterEventsForFilteredBlocks().SetPeerRoles(PeerRole.ENDORSING_PEER, PeerRole.LEDGER_QUERY, PeerRole.CHAINCODE_QUERY, PeerRole.EVENT_SOURCE);
newChannel.AddPeer(peer, IS_FABRIC_V10 ? PeerOptions.CreatePeerOptions().SetPeerRoles(PeerRole.ENDORSING_PEER, PeerRole.LEDGER_QUERY, PeerRole.CHAINCODE_QUERY) : peerEventingOptions);
everyOther = !everyOther;
}
//For testing mix it up. For v1.1 use just peer eventing service for foo channel.
if (IS_FABRIC_V10)
{
//Should have no peers with event sources.
Assert.IsTrue(newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count == 0);
//Should have two peers with all roles but event source.
Assert.AreEqual(2, newChannel.Peers.Count);
foreach (string eventHubName in sampleOrg.GetEventHubNames())
{
EventHub eventHub = client.NewEventHub(eventHubName, sampleOrg.GetEventHubLocation(eventHubName), testConfig.GetEventHubProperties(eventHubName));
newChannel.AddEventHub(eventHub);
}
}
else
{
//Peers should have all roles. Do some sanity checks that they do.
//Should have two peers with event sources.
Assert.AreEqual(2, newChannel.GetPeers(new[] { PeerRole.EVENT_SOURCE }).Count);
//Check some other roles too..
Assert.AreEqual(2, newChannel.GetPeers(new[] { PeerRole.CHAINCODE_QUERY, PeerRole.LEDGER_QUERY }).Count);
Assert.AreEqual(2, newChannel.GetPeers(PeerRoleExtensions.All()).Count); //really same as newChannel.getPeers()
}
Assert.AreEqual(IS_FABRIC_V10 ? sampleOrg.GetEventHubNames().Count : 0, newChannel.EventHubs.Count);
}
//Just some sanity check tests
Assert.IsTrue(newChannel == client.GetChannel(name));
Assert.IsTrue(client == newChannel.client);
Assert.AreEqual(name, newChannel.Name);
Assert.AreEqual(2, newChannel.Peers.Count);
Assert.AreEqual(1, newChannel.Orderers.Count);
Assert.IsFalse(newChannel.IsShutdown);
Assert.IsFalse(newChannel.IsInitialized);
string serializedChannelBytes = newChannel.Serialize();
//Just checks if channel can be serialized and deserialized .. otherwise this is just a waste :)
// Get channel back.
newChannel.Shutdown(true);
newChannel = client.DeSerializeChannel(serializedChannelBytes);
Assert.AreEqual(2, newChannel.Peers.Count);
Assert.AreEqual(1, newChannel.Orderers.Count);
Assert.IsNotNull(client.GetChannel(name));
Assert.AreEqual(newChannel, client.GetChannel(name));
Assert.IsFalse(newChannel.IsInitialized);
Assert.IsFalse(newChannel.IsShutdown);
Assert.AreEqual(TESTUSER_1_NAME, client.UserContext.Name);
newChannel.Initialize();
Assert.IsTrue(newChannel.IsInitialized);
Assert.IsFalse(newChannel.IsShutdown);
//Begin tests with de-serialized channel.
//Query the actual peer for which channels it belongs to and check it belongs to this channel
foreach (Peer peer in newChannel.Peers)
{
HashSet <string> channels = client.QueryChannels(peer);
if (!channels.Contains(name))
{
Assert.Fail($"Peer {peer.Name} does not appear to belong to channel {name}");
}
}
//Just see if we can get channelConfiguration. Not required for the rest of scenario but should work.
byte[] channelConfigurationBytes = newChannel.GetChannelConfigurationBytes();
Config channelConfig = Config.Parser.ParseFrom(channelConfigurationBytes);
Assert.IsNotNull(channelConfig);
ConfigGroup channelGroup = channelConfig.ChannelGroup;
Assert.IsNotNull(channelGroup);
Dictionary <string, ConfigGroup> groupsMap = channelGroup.Groups.ToDictionary(a => a.Key, a => a.Value);
Assert.IsNotNull(groupsMap.GetOrNull("Orderer"));
Assert.IsNotNull(groupsMap.GetOrNull("Application"));
//Before return lets see if we have the chaincode on the peers that we expect from End2endIT
//And if they were instantiated too. this requires peer admin user
client.UserContext = sampleOrg.PeerAdmin;
foreach (Peer peer in newChannel.Peers)
{
if (!CheckInstalledChaincode(client, peer, CHAIN_CODE_NAME, CHAIN_CODE_PATH, CHAIN_CODE_VERSION))
{
Assert.Fail($"Peer {peer.Name} is missing chaincode name: {CHAIN_CODE_NAME}, path:{CHAIN_CODE_PATH}, version: {CHAIN_CODE_VERSION}");
}
if (!CheckInstantiatedChaincode(newChannel, peer, CHAIN_CODE_NAME, CHAIN_CODE_PATH, CHAIN_CODE_VERSION))
{
Assert.Fail($"Peer {peer.Name} is missing instantiated chaincode name: {CHAIN_CODE_NAME}, path:{CHAIN_CODE_PATH}, version: {CHAIN_CODE_VERSION}");
}
}
client.UserContext = sampleOrg.GetUser(TESTUSER_1_NAME);
Assert.IsTrue(newChannel.IsInitialized);
Assert.IsFalse(newChannel.IsShutdown);
Util.COut("Finished reconstructing channel {0}.", name);
return(newChannel);
}
private static void ClientWorkerThread(ThreadBootstrapStruct startupInfo)
{
// Setup...
uint nextStatsUpdate = 0;
byte[] workerPacketBuffer = new byte[startupInfo.maxPacketSize];
Address cAddress = new Address();
// Drain anything in the queues...
while (MirrorClientIncomingQueue.TryDequeue(out _))
{
;
}
while (MirrorClientOutgoingQueue.TryDequeue(out _))
{
;
}
// This comment was actually left blank, but now it's not. You're welcome.
using (Host cHost = new Host())
{
try
{
cHost.Create(null, 1, startupInfo.maxChannels, 0, 0, startupInfo.maxPacketSize);
ClientStarted = true;
}
catch (Exception e)
{
Debug.LogError("Ignorance encountered a fatal exception. To help debug the issue, use a Debug DLL of ENET and look for a 'enet_log.txt' file in the root of your " +
$"application folder.\nIf you believe you found a bug, please report it on the GitHub issue tracker. The exception returned was: {e}");
return;
}
// Attempt to start connection...
cAddress.SetHost(startupInfo.hostAddress);
cAddress.Port = startupInfo.port;
Peer cPeer = cHost.Connect(cAddress, startupInfo.maxChannels);
while (!clientShouldCeaseOperation)
{
bool clientWasPolled = false;
if (Library.Time >= nextStatsUpdate)
{
statistics.CurrentPing = cPeer.RoundTripTime;
statistics.BytesReceived = cPeer.BytesReceived;
statistics.BytesSent = cPeer.BytesSent;
statistics.PacketsLost = cPeer.PacketsLost;
statistics.PacketsSent = cPeer.PacketsSent;
// Library.Time is milliseconds, so we need to do some quick math.
nextStatsUpdate = Library.Time + (uint)(startupInfo.pingUpdateInterval * 1000);
}
while (!clientWasPolled)
{
if (cHost.CheckEvents(out Event networkEvent) <= 0)
{
if (cHost.Service(startupInfo.threadPumpTimeout, out networkEvent) <= 0)
{
break;
}
clientWasPolled = true;
}
switch (networkEvent.Type)
{
case EventType.Connect:
// Client connected.
IncomingPacket connPkt = default;
connPkt.type = MirrorPacketType.ClientConnected;
MirrorClientIncomingQueue.Enqueue(connPkt);
break;
case EventType.Timeout:
case EventType.Disconnect:
// Client disconnected.
IncomingPacket disconnPkt = default;
disconnPkt.type = MirrorPacketType.ClientDisconnected;
MirrorClientIncomingQueue.Enqueue(disconnPkt);
break;
case EventType.Receive:
// Client recieving some data.
if (!networkEvent.Packet.IsSet)
{
print("Ignorance WARNING: A incoming packet is not set correctly.");
break;
}
if (networkEvent.Packet.Length > workerPacketBuffer.Length)
{
print($"Ignorance: Packet too big to fit in buffer. {networkEvent.Packet.Length} packet bytes vs {workerPacketBuffer.Length} cache bytes {networkEvent.Peer.ID}.");
networkEvent.Packet.Dispose();
break;
}
else
{
// invoke on the client.
try
{
IncomingPacket dataPkt = default;
dataPkt.type = MirrorPacketType.ClientGotData;
dataPkt.channelId = networkEvent.ChannelID;
byte[] rentedBuffer = System.Buffers.ArrayPool <byte> .Shared.Rent(networkEvent.Packet.Length);
networkEvent.Packet.CopyTo(rentedBuffer);
dataPkt.data = rentedBuffer;
MirrorClientIncomingQueue.Enqueue(dataPkt);
}
catch (Exception e)
{
Debug.LogError($"Ignorance caught an exception while trying to copy data from the unmanaged (ENET) world to managed (Mono/IL2CPP) world. Please consider reporting this to the Ignorance developer on GitHub.\n" +
$"Exception returned was: {e.Message}\n" +
$"Debug details: {(workerPacketBuffer == null ? "packet buffer was NULL" : $"{workerPacketBuffer.Length} byte work buffer")}, {networkEvent.Packet.Length} byte(s) network packet length\n" +
$"Stack Trace: {e.StackTrace}");
break;
}
networkEvent.Packet.Dispose();
}
break;
}
}
public UnregisterPeerCommand(Peer peer, DateTime?timestampUtc = null)
: this(peer.Id, peer.EndPoint, timestampUtc)
{
}
private void SendToPeer(TransportMessage transportMessage, CodedOutputStream outputStream, Peer target)
{
var outboundSocket = GetConnectedOutboundSocket(target, transportMessage);
if (!outboundSocket.IsConnected)
{
return;
}
try
{
outboundSocket.Send(outputStream.Buffer, outputStream.Position, transportMessage);
}
catch (Exception ex)
{
_logger.Error($"Failed to send message, PeerId: {target.Id}, EndPoint: {target.EndPoint}, Exception: {ex}");
}
}
/// <summary>
/// Gets the topics that a peer is interested in
/// </summary>
/// <param name="peer">
/// The <see cref="Peer"/>.
/// </param>
/// <returns>
/// A sequence of topics that the <paramref name="peer"/> is
/// interested in.
/// </returns>
public IEnumerable <string> GetTopics(Peer peer)
{
return(_topics
.Where(kp => kp.Value.Contains(peer))
.Select(kp => kp.Key));
}
public override NET_RESULT_DEFINE.PACKET_EXE Execute(PacketBase packet, ref Peer pPlayer)
{
//当前流程是主流程
if (GameProcedure.GetActiveProcedure() == (GameProcedure)GameProcedure.s_ProcMain)
{
GCNewPet_Move pPacket = (GCNewPet_Move)packet;
CObjectManager pObjectManager = CObjectManager.Instance;
//检查位置是否合法
fVector2 pos = new fVector2(pPacket.getWorldPos().m_fX, pPacket.getWorldPos().m_fZ);
if (!WorldManager.Instance.ActiveScene.IsValidPosition(ref pos))
{
LogManager.LogError("Valid Position @GCNewPetHandler.Execute");
return(NET_RESULT_DEFINE.PACKET_EXE.PACKET_EXE_ERROR);
}
fVector2 targetPos = new fVector2(pPacket.getTargetPos().m_fX, pPacket.getTargetPos().m_fZ);
if (!WorldManager.Instance.ActiveScene.IsValidPosition(ref targetPos))
{
LogManager.LogError("Valid Position @GCNewPetHandler.Execute");
return(NET_RESULT_DEFINE.PACKET_EXE.PACKET_EXE_ERROR);
}
//创建宠物
CObject_PlayerNPC pNPC = (CObject_PlayerNPC)pObjectManager.FindServerObject((int)pPacket.getObjID());
if (pNPC == null)
{
pNPC = pObjectManager.NewPlayerNPC((int)pPacket.getObjID());
SObjectInit initPlayerNPC = new SObjectInit();
initPlayerNPC.m_fvPos = new Vector3(pos.x, 0, pos.y);
initPlayerNPC.m_fvRot = new Vector3(0.0f, 0.0f, 0.0f);
pNPC.Initial(initPlayerNPC);
}
else
{
pNPC.SetMapPosition(pos.x, pos.y);
pNPC.Enable((uint)ObjectStatusFlags.OSF_VISIABLE);
pNPC.Disalbe((uint)ObjectStatusFlags.OSF_OUT_VISUAL_FIELD);
}
pNPC.SetNpcType(ENUM_NPC_TYPE.NPC_TYPE_PET);
pNPC.GetCharacterData().Set_MoveSpeed(pPacket.getMoveSpeed());
// move to command
{
WORLD_POS[] posTarget = new WORLD_POS[1];
posTarget[0].m_fX = pPacket.getTargetPos().m_fX;
posTarget[0].m_fZ = pPacket.getTargetPos().m_fZ;
SCommand_Object cmdTemp = new SCommand_Object();
cmdTemp.m_wID = (int)OBJECTCOMMANDDEF.OC_MOVE;
cmdTemp.SetValue <uint>(0, 0);
cmdTemp.SetValue <int>(1, pPacket.getHandleID());
cmdTemp.SetValue <int>(2, 1);
cmdTemp.SetValue <WORLD_POS[]>(3, posTarget);
pNPC.PushCommand(cmdTemp);
}
//放入Ask队列
pObjectManager.LoadQueue.TryAddLoadTask(pNPC.ID);
//同步渲染层
string szTemp = "GCNewPet_Move(" + pos.x.ToString() + "," + pos.y.ToString() + ")";
pNPC.PushDebugString(szTemp);
pNPC.SetMsgTime(GameProcedure.s_pTimeSystem.GetTimeNow());
}
return(NET_RESULT_DEFINE.PACKET_EXE.PACKET_EXE_CONTINUE);;
}
private void OnConnected(Peer eventPeer)
{
ServerConnection = eventPeer;
}
public static void Main(string[] args)
{
var app = new App(new AppProps {
});
// can't rely on (incorrect) CDK implementation, so read these files one by one, values from previous may be overridden by those from next
var ctx = Context.FromJsonFiles(app.Node, $"{OSAgnostic.Home}/cdk.json", $"cdk.json", app.Node.TryGetContext("ctx") as string);
// Mandatory parameters are not a part of the schema
var accountNumber = ctx.Resolve("account", "CDK_DEFAULT_ACCOUNT");//, $"Please provide account number: -c account=<number>");
if (string.IsNullOrWhiteSpace(accountNumber))
{
accountNumber = new AmazonSecurityTokenServiceClient().GetCallerIdentityAsync(new GetCallerIdentityRequest()).Result.Account;
if (string.IsNullOrWhiteSpace(accountNumber))
{
throw new ArgumentException($"No account number returned by AWS STS");
}
}
var regionName = ctx.Resolve("region", "CDK_DEFAULT_REGION", $"Please provide AWS region: -c region=<region>");
var regionInfo = RegionInfo.Get(regionName);
Console.WriteLine($"Account: {accountNumber}/{regionInfo?.Name}, {regionInfo?.DomainSuffix}");
if (string.IsNullOrWhiteSpace(regionInfo?.DomainSuffix))
{
throw new ArgumentException($"Invalid region: '{regionName}'");
}
var schemaFilePath = ctx.Resolve("schema", help: "Schema file path required: -c schema=<path_to_schema_yaml>");
Console.WriteLine($"Schema [{schemaFilePath}]");
IvrSiteSchema schema;
using (var sr = new StreamReader(schemaFilePath))
{
var ext = Path.GetExtension(schemaFilePath).ToLower();
if (".yaml" == ext)
{
schema = IvrSiteSchema.FromString(System.Environment.ExpandEnvironmentVariables(sr.ReadToEnd()));
Console.WriteLine(new YamlDotNet.Serialization.SerializerBuilder().Build().Serialize(schema));
if (string.IsNullOrWhiteSpace(schema.SiteName))
{
var fileName = Path.GetFileNameWithoutExtension(schemaFilePath);
schema.SiteName = fileName;
}
}
else
{
throw new ArgumentException($"Handling of *{ext} format is not implemented (yet)");
}
schema.ResolveUndefinedProperties(ctx).Validate().Preprocess();
}
var rdpIngressRules = schema.RdpProps.Cidrs.Select(x => new IngressRule(Peer.Ipv4(x.Trim()), Port.Tcp(3389), "RDP").WithDescription($"RDP client"));
var sipIngressRules = SipProviders.Select(regionInfo.Name, schema.SipProviders, schema.IngressPorts);
new IvrStack(app, $"IvrStack-{schema.SiteName}".AsCloudFormationId(),
new StackProps
{
Env = new Amazon.CDK.Environment
{
Account = accountNumber,
Region = regionInfo.Name,
},
Tags = schema.Tags,
},
schema,
rdpIngressRules.Concat(sipIngressRules)
);
app.Synth();
}
private void OnDisconnected(Peer eventPeer)
{
ServerConnection = new Peer();
}
public override bool ShouldConnect(Peer peer)
{
return(!(peer.IsSeeder && Manager.HasMetadata && Manager.Complete));
}
public TransferStatusMessage(Peer to) : base(to)
{
this.toIp = to.GetIp();
}
public DialogConstructor(Peer peer, int top_message, int unread_count)
{
this.peer = peer;
this.top_message = top_message;
this.unread_count = unread_count;
}
public bool HandlePacket(Peer peer, byte[] data, Game game)
{
var world = new WorldSendGameNumber(1, game.GetPeerInfo(peer).GetName());
return(game.PacketHandlerManager.sendPacket(peer, world, Channel.CHL_S2C));
}
private void OnGUI()
{
if (MyInfoManager.Instance.isGuiOn && on)
{
VerifyLocalController();
GUI.skin = GUISkinFinder.Instance.GetGUISkin();
GUI.depth = (int)guiDepth;
GUI.enabled = !DialogManager.Instance.IsModal;
GUI.BeginGroup(new Rect(((float)Screen.width - crdFrame.x) / 2f, ((float)Screen.height - crdFrame.y) / 2f, crdFrame.x, crdFrame.y));
GUI.Box(new Rect(0f, 0f, crdFrame.x, crdFrame.y), string.Empty, "BoxResult");
Room room = RoomManager.Instance.GetRoom(RoomManager.Instance.CurrentRoom);
if (room != null)
{
LabelUtil.TextOut(crdRoomTitle, room.GetString(), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.UpperLeft);
}
GUI.Box(crdBoxGreen, string.Empty, "BoxGreen02");
GUI.Box(crdFirstLow, string.Empty, "BoxResultText");
TextureUtil.DrawTexture(crdIndIcon, indIcon, ScaleMode.StretchToFill);
LabelUtil.TextOut(new Vector2(markX, resultY), StringMgr.Instance.Get("MARK"), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(badgeX, resultY), StringMgr.Instance.Get("BADGE"), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(nickX, resultY), StringMgr.Instance.Get("CHARACTER"), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(killX, resultY), StringMgr.Instance.Get("KILL") + "/" + StringMgr.Instance.Get("ASSIST") + "/" + StringMgr.Instance.Get("DEATH"), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(scoreX, resultY), StringMgr.Instance.Get("SCORE"), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
LabelUtil.TextOut(new Vector2(pingX, resultY), StringMgr.Instance.Get("PING"), "MiniLabel", Color.white, GlobalVars.txtEmptyColor, TextAnchor.MiddleCenter);
float num = yy;
GUI.Box(crdSituation, string.Empty, "BoxResult01");
bool flag = false;
List <KeyValuePair <int, BrickManDesc> > list = BrickManManager.Instance.ToSortedList();
for (int i = 0; i < list.Count; i++)
{
BrickManDesc value = list[i].Value;
if (value != null && value.Slot < 16)
{
GameObject gameObject = BrickManManager.Instance.Get(value.Seq);
if (!(null == gameObject))
{
TPController component = gameObject.GetComponent <TPController>();
if (!(null == component))
{
if (!flag && (MyInfoManager.Instance.Score > value.Score || (MyInfoManager.Instance.Score == value.Score && MyInfoManager.Instance.Kill > value.Kill)))
{
flag = true;
float num2 = num;
num = GridOut(MyInfoManager.Instance.ClanMark, MyInfoManager.Instance.Xp, MyInfoManager.Instance.Rank, MyInfoManager.Instance.Nickname, MyInfoManager.Instance.Kill, MyInfoManager.Instance.Assist, MyInfoManager.Instance.Death, MyInfoManager.Instance.Score, MyInfoManager.Instance.PingTime, MyInfoManager.Instance.Status, localController.IsDead, num, MyInfoManager.Instance.Seq == RoomManager.Instance.Master);
GUI.Box(new Rect(myRowX, num2 - myRowSize.y / 2f + 2f, myRowSize.x, myRowSize.y), string.Empty, "BoxMyInfo");
}
Peer peer = P2PManager.Instance.Get(value.Seq);
num = GridOut(value.ClanMark, value.Xp, value.Rank, value.Nickname, value.Kill, value.Assist, value.Death, value.Score, peer?.PingTime ?? float.PositiveInfinity, value.Status, component.IsDead, num, value.Seq == RoomManager.Instance.Master);
}
}
}
}
if (!flag)
{
GridOut(MyInfoManager.Instance.ClanMark, MyInfoManager.Instance.Xp, MyInfoManager.Instance.Rank, MyInfoManager.Instance.Nickname, MyInfoManager.Instance.Kill, MyInfoManager.Instance.Assist, MyInfoManager.Instance.Death, MyInfoManager.Instance.Score, MyInfoManager.Instance.PingTime, MyInfoManager.Instance.Status, localController.IsDead, num, MyInfoManager.Instance.Seq == RoomManager.Instance.Master);
GUI.Box(new Rect(myRowX, num - myRowSize.y / 2f + 2f, myRowSize.x, myRowSize.y), string.Empty, "BoxMyInfo");
}
GUI.EndGroup();
GUI.enabled = true;
}
}
public void SetPeer(Peer peer)
{
_peer = peer;
}
public SendDirectBuilder(Peer peer, PeerAddress peerAddress)
{
_peer = peer;
RecipientAddress = peerAddress;
TcsRecipientConnection = null;
}
private void TestPeerServiceEventingReplay(HFClient client, Channel replayTestChannel, long start, long stop, bool useFilteredBlocks)
{
if (testConfig.IsRunningAgainstFabric10())
{
return; // not supported for v1.0
}
Assert.IsFalse(replayTestChannel.IsInitialized); //not yet initialized
Assert.IsFalse(replayTestChannel.IsShutdown); // not yet shutdown.
//Remove all peers just have one ledger peer and one eventing peer.
List <Peer> savedPeers = new List <Peer>(replayTestChannel.Peers);
foreach (Peer peer in savedPeers)
{
replayTestChannel.RemovePeer(peer);
}
Assert.IsTrue(savedPeers.Count > 1); //need at least two
Peer eventingPeer = savedPeers[0];
eventingPeer = client.NewPeer(eventingPeer.Name, eventingPeer.Url, eventingPeer.Properties);
Peer ledgerPeer = savedPeers[1];
ledgerPeer = client.NewPeer(ledgerPeer.Name, ledgerPeer.Url, ledgerPeer.Properties);
savedPeers.RemoveAt(0);
savedPeers.RemoveAt(0);
Assert.IsTrue(replayTestChannel.Peers.Count == 0); // no more peers.
Assert.IsTrue(replayTestChannel.GetPeers(new[] { PeerRole.CHAINCODE_QUERY, PeerRole.ENDORSING_PEER }).Count == 0); // just checking :)
Assert.IsTrue(replayTestChannel.GetPeers(new[] { PeerRole.LEDGER_QUERY }).Count == 0); // just checking
Assert.IsNotNull(client.GetChannel(replayTestChannel.Name)); // should be known by client.
PeerOptions eventingPeerOptions = PeerOptions.CreatePeerOptions().SetPeerRoles(new List <PeerRole> {
PeerRole.EVENT_SOURCE
});
if (useFilteredBlocks)
{
eventingPeerOptions.RegisterEventsForFilteredBlocks();
}
if (-1L == stop)
{
//the height of the blockchain
replayTestChannel.AddPeer(eventingPeer, eventingPeerOptions.StartEvents(start)); // Eventing peer start getting blocks from block 0
}
else
{
replayTestChannel.AddPeer(eventingPeer, eventingPeerOptions.StartEvents(start).StopEvents(stop)); // Eventing peer start getting blocks from block 0
}
//add a ledger peer
replayTestChannel.AddPeer(ledgerPeer, PeerOptions.CreatePeerOptions().SetPeerRoles(new List <PeerRole> {
PeerRole.LEDGER_QUERY
}));
TaskCompletionSource <long> done = new TaskCompletionSource <long>(); // future to set when done.
// some variable used by the block listener being set up.
long bcount = 0;
long stopValue = stop == -1L ? long.MaxValue : stop;
Channel finalChannel = replayTestChannel;
ConcurrentDictionary <long, BlockEvent> blockEvents = new ConcurrentDictionary <long, BlockEvent>();
string blockListenerHandle = replayTestChannel.RegisterBlockListener((blockEvent) =>
{
try
{
long blockNumber = blockEvent.BlockNumber;
if (blockEvents.ContainsKey(blockNumber))
{
Assert.Fail($"Block number {blockNumber} seen twice");
}
blockEvents[blockNumber] = blockEvent;
Assert.IsTrue(useFilteredBlocks ? blockEvent.IsFiltered : !blockEvent.IsFiltered, $"Wrong type of block seen block number {blockNumber}. expected filtered block {useFilteredBlocks} but got {blockEvent.IsFiltered}");
long count = Interlocked.Increment(ref bcount) - 1;
//out("Block count: %d, block number: %d received from peer: %s", count, blockNumber, blockEvent.getPeer().getName());
if (count == 0 && stop == -1L)
{
BlockchainInfo blockchainInfo = finalChannel.QueryBlockchainInfo();
long lh = blockchainInfo.Height;
stopValue = lh - 1L; // blocks 0L 9L are on chain height 10 .. stop on 9
// out("height: %d", lh);
if (Interlocked.Read(ref bcount) + start > stopValue)
{
// test with latest count.
done.SetResult(Interlocked.Read(ref bcount));
}
}
else
{
if (Interlocked.Read(ref bcount) + start > stopValue)
{
done.SetResult(count);
}
}
}
catch (System.Exception e)
{
done.SetException(e);
}
});
try
{
replayTestChannel.Initialize(); // start it all up.
done.Task.Wait(30 * 1000);
Thread.Sleep(1000); // sleep a little to see if more blocks trickle in .. they should not
replayTestChannel.UnregisterBlockListener(blockListenerHandle);
long expectNumber = stopValue - start + 1L; // Start 2 and stop is 3 expect 2
Assert.AreEqual(expectNumber, blockEvents.Count, $"Didn't get number we expected {expectNumber} but got {blockEvents.Count} block events. Start: {start}, end: {stop}, height: {stopValue}");
for (long i = stopValue; i >= start; i--)
{
//make sure all are there.
BlockEvent blockEvent = blockEvents[i];
Assert.IsNotNull(blockEvent, $"Missing block event for block number {i}. Start= {start}", blockEvent);
}
//light weight test just see if we get reasonable values for traversing the block. Test just whats common between
// Block and FilteredBlock.
int transactionEventCounts = 0;
int chaincodeEventsCounts = 0;
for (long i = stopValue; i >= start; i--)
{
BlockEvent blockEvent = blockEvents[i];
// out("blockwalker %b, start: %d, stop: %d, i: %d, block %d", useFilteredBlocks, start, stopValue.longValue(), i, blockEvent.getBlockNumber());
Assert.AreEqual(useFilteredBlocks, blockEvent.IsFiltered); // check again
if (useFilteredBlocks)
{
Assert.IsNull(blockEvent.Block); // should not have raw block event.
Assert.IsNotNull(blockEvent.FilteredBlock); // should have raw filtered block.
}
else
{
Assert.IsNotNull(blockEvent.Block); // should not have raw block event.
Assert.IsNull(blockEvent.FilteredBlock); // should have raw filtered block.
}
Assert.AreEqual(replayTestChannel.Name, blockEvent.ChannelId);
foreach (EnvelopeInfo envelopeInfo in blockEvent.EnvelopeInfos)
{
if (envelopeInfo.EnvelopeType == EnvelopeType.TRANSACTION_ENVELOPE)
{
TransactionEnvelopeInfo transactionEnvelopeInfo = (TransactionEnvelopeInfo)envelopeInfo;
Assert.IsTrue(envelopeInfo.IsValid); // only have valid blocks.
Assert.AreEqual(envelopeInfo.ValidationCode, 0);
++transactionEventCounts;
foreach (TransactionActionInfo ta in transactionEnvelopeInfo.TransactionActionInfos)
{
// out("\nTA:", ta + "\n\n");
ChaincodeEventDeserializer evnt = ta.Event;
if (evnt != null)
{
Assert.IsNotNull(evnt.ChaincodeId);
Assert.IsNotNull(evnt.EventName);
chaincodeEventsCounts++;
}
}
}
else
{
Assert.AreEqual(blockEvent.BlockNumber, 0, "Only non transaction block should be block 0.");
}
}
}
Assert.IsTrue(transactionEventCounts > 0);
if (expectNumber > 4)
{
// this should be enough blocks with CC events.
Assert.IsTrue(chaincodeEventsCounts > 0);
}
replayTestChannel.Shutdown(true); //all done.
}
catch (System.Exception e)
{
Assert.Fail(e.Message);
}
}
