/// <summary>
/// Reads the given stream up to the end, returning the data as a byte
/// array, using the given buffer for transferring data. Note that the
/// current contents of the buffer is ignored, so the buffer needn't
/// be cleared beforehand.
/// </summary>
public static byte[] ReadFully(this Stream input, byte[] buffer)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (buffer.Length == 0)
{
throw new ArgumentException("Buffer has length of 0");
}
// We could do all our own work here, but using MemoryStream is easier
// and likely to be just as efficient.
using (var tempStream = MemoryStreamManager.GetStream())
{
CopyTo(input, tempStream, buffer);
// No need to copy the buffer if it's the right size
if (tempStream.Length == tempStream.GetBuffer().Length)
{
return(tempStream.GetBuffer());
}
// Okay, make a copy that's the right size
return(tempStream.ToArray());
}
}
public void LibraryNoIonsTest()
{
var streamManager = new MemoryStreamManager();
var loader = new LibraryLoadTest.TestLibraryLoader {
StreamManager = streamManager
};
// Create X! Hunter library with 20 lowest intensity peaks in NIST library
LibraryLoadTest.CreateHunterFile(streamManager, loader, LibraryLoadTest.TEXT_LIB_YEAST_NIST, true);
var hunterSpec = new XHunterLibSpec("Yeast (X!)", LibraryLoadTest.PATH_HUNTER_LIB);
// For serialization, add the library spec to the settings
TestLibraryList = new SpectralLibraryList {
hunterSpec
};
var libraryManager = new LibraryManager {
StreamManager = streamManager
};
var docContainer = new TestDocumentContainer();
SrmSettings settings = SrmSettingsList.GetDefault();
settings = settings.ChangePeptideLibraries(l => l.ChangeLibrarySpecs(new LibrarySpec[] { hunterSpec }));
int startRev;
SrmDocument docLoaded = CreateLibraryDocument(settings, ExampleText.TEXT_FASTA_YEAST_LIB, false,
docContainer, libraryManager, out startRev);
// Peptides should have been chosen, but no transitions, since the spectra are garbage
AssertEx.IsDocumentState(docLoaded, startRev, 2, 4, 0);
}
public HybridStreamManager(string path, int maxMemoryStreamSize, int maxStreamSize)
{
if (maxMemoryStreamSize >= maxStreamSize)
throw new ArgumentException("Max memory stream size must be less than the max stream size");
_diskStreamManager = new DiskStreamManager(path, maxStreamSize);
_memoryStreamManager = new MemoryStreamManager(maxMemoryStreamSize);
}
public static Assembly GetLoadedAssemblyFromDefinition(AssemblyDefinition assemblyDefinition)
{
using (var ms = MemoryStreamManager.GetStream())
{
assemblyDefinition.Write(ms);
return(Assembly.Load(ms.GetBuffer()));
}
}
public static MemoryStream CopyToNewMemoryStream(this Stream stream)
{
var ms = MemoryStreamManager.GetStream();
stream.CopyTo(ms);
ms.Position = 0;
return(ms);
}
public static async Task <MemoryStream> CopyToNewMemoryStreamAsync(this Stream stream)
{
var ms = MemoryStreamManager.GetStream();
await stream.CopyToAsync(ms);
ms.Position = 0;
return(ms);
}
public byte[] RecyclableMemoryStream()
{
using (var ms = MemoryStreamManager.GetStream())
{
_formatter.WriteToStream(_persionData, ms);
return(ms.ToArray());
}
}
public static byte[] Compress <TXmlDto>(TXmlDto from)
{
using (var ms = MemoryStreamManager.GetStream())
{
CompressToStream(from, ms);
return(ms.ToArray());
}
}
protected override Block ReadBlock(int index, [NotNull] PipelineInfo pipelineInfo)
{
var uncompressedStream = MemoryStreamManager.GetStream("Uncompressed");
SourceStream.CopyBlockTo(uncompressedStream, pipelineInfo.BlockSize);
uncompressedStream.Position = 0;
return(new Block(index, uncompressedStream));
}
public override async Task <object> DeserializeAsync(Stream input)
{
using var buffer = MemoryStreamManager.GetStream();
await input.CopyToAsync(buffer).ConfigureAwait(false);
return(await this.deserializer
.DeserializeAsync(
new ReadOnlyMemory <byte>(buffer.GetBuffer(), 0, (int)buffer.Length),
false,
Confluent.Kafka.SerializationContext.Empty)
.ConfigureAwait(false));
}
public override async Task <object> DeserializeAsync(Stream input, ISerializerContext context)
{
using var buffer = MemoryStreamManager.GetStream();
await input.CopyToAsync(buffer).ConfigureAwait(false);
return(await this.deserializer
.DeserializeAsync(
new ReadOnlyMemory <byte>(buffer.GetBuffer(), 0, (int)buffer.Length),
false,
new SerializationContext(MessageComponentType.Value, context.Topic))
.ConfigureAwait(false));
}
public void LibraryMultipleTest()
{
var streamManager = new MemoryStreamManager();
var loader = new LibraryLoadTest.TestLibraryLoader { StreamManager = streamManager };
// Create library files
const string hunterText = LibraryLoadTest.TEXT_LIB_YEAST_NIST1 + "\n" + LibraryLoadTest.TEXT_LIB_YEAST_NIST2;
LibraryLoadTest.CreateHunterFile(streamManager, loader, hunterText);
const string biblioText = LibraryLoadTest.TEXT_LIB_YEAST_NIST2 + "\n" + LibraryLoadTest.TEXT_LIB_YEAST_NIST3;
LibraryLoadTest.CreateBiblioFile(streamManager, loader, biblioText);
const string nistText = LibraryLoadTest.TEXT_LIB_YEAST_NIST3 + "\n" + LibraryLoadTest.TEXT_LIB_YEAST_NIST4;
streamManager.TextFiles.Add(LibraryLoadTest.PATH_NIST_LIB, nistText);
var hunterSpec = new XHunterLibSpec("Yeast (X!)", LibraryLoadTest.PATH_HUNTER_LIB);
var bilbioSpec = new BiblioSpecLibSpec("Yeast (BS)", LibraryLoadTest.PATH_BIBLIOSPEC_LIB);
var nistSpec = new NistLibSpec("Yeast (NIST)", LibraryLoadTest.PATH_NIST_LIB);
// For serialization, add the library spec to the settings
TestLibraryList = new SpectralLibraryList { hunterSpec, bilbioSpec, nistSpec };
var libraryManager = new LibraryManager { StreamManager = streamManager };
var docContainer = new TestDocumentContainer();
SrmSettings settings = SrmSettingsList.GetDefault();
settings = settings.ChangePeptideLibraries(l => l.ChangeLibrarySpecs(new LibrarySpec[] { hunterSpec, bilbioSpec, nistSpec }));
int startRev;
SrmDocument docLoaded = CreateLibraryDocument(settings, ExampleText.TEXT_FASTA_YEAST_LIB, false,
docContainer, libraryManager, out startRev);
AssertEx.IsDocumentState(docLoaded, startRev, 2, 4, 12);
Assert.IsTrue(HasLibraryInfo(docLoaded, typeof(XHunterSpectrumHeaderInfo)));
Assert.IsTrue(HasLibraryInfo(docLoaded, typeof(BiblioSpecSpectrumHeaderInfo)));
Assert.IsTrue(HasLibraryInfo(docLoaded, typeof(NistSpectrumHeaderInfo)));
// Remove the rank 1 transition from each transition group
TransitionDocNode[] transitionNodes = docLoaded.PeptideTransitions.ToArray();
for (int i = 0; i < transitionNodes.Length; i++)
{
var nodeTran = transitionNodes[i];
if (nodeTran.LibInfo.Rank != 1)
continue;
var path = docLoaded.GetPathTo((int) SrmDocument.Level.TransitionGroups, i/3);
docLoaded = (SrmDocument) docLoaded.RemoveChild(path, nodeTran);
++startRev;
}
AssertEx.IsDocumentState(docLoaded, startRev, 2, 4, 8);
// Make sure this can be serialized and deserialized without causing
// a recalculation of the nodes in the tree.
AssertEx.Serializable(docLoaded, (doc1, doc2) => ValidateLibraryDocs(doc1, doc2, libraryManager));
}
/// <inheritdoc />
public sealed override object DeepCopyObject(object source)
{
if (null == source)
{
return(null);
}
var formatter = new BinaryFormatter();
using (var ms = MemoryStreamManager.GetStream())
{
formatter.Serialize(ms, source);
ms.Seek(0, System.IO.SeekOrigin.Begin);
return(formatter.Deserialize(ms));
}
}
/// <inheritdoc />
public sealed override object DeepCopyObject(object source)
{
if (source == null)
{
return(null);
}
var type = source.GetType();
using (var ms = MemoryStreamManager.GetStream())
{
_copier.Serialize(source, ms);
ms.Seek(0, System.IO.SeekOrigin.Begin);
return(_copier.Deserialize(ms));
}
}
/// <summary>Tries to create a copy of source.</summary>
/// <param name="source">The item to create a copy of</param>
/// <returns>The copy</returns>
public virtual object DeepCopyObject(object source)
{
if (source == null)
{
return(null);
}
var type = source.GetType();
using (var ms = MemoryStreamManager.GetStream())
{
WriteToStream(type, source, ms, Encoding.UTF8);
ms.Seek(0, System.IO.SeekOrigin.Begin);
return(ReadFromStream(type, ms, Encoding.UTF8));
}
}
private static Library CreateLibraryFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, Action <IStreamManager, Library> write)
{
streamManager.TextFiles[PATH_NIST_LIB] = nistText;
var librarySpec = new NistLibSpec("Temporary (NIST)", PATH_NIST_LIB);
Library libNist = librarySpec.LoadLibrary(loader);
Assert.IsNotNull(libNist);
write(streamManager, libNist);
streamManager.TextFiles.Remove(PATH_NIST_LIB);
streamManager.Delete(PATH_NIST_LIB_CACHE);
return(libNist);
}
public void NistLoadLibrary()
{
var streamManager = new MemoryStreamManager();
streamManager.TextFiles.Add(PATH_NIST_LIB, TEXT_LIB_YEAST_NIST + TEXT_LIB_BICINE_NIST);
var loader = new TestLibraryLoader {
StreamManager = streamManager
};
var expectedFragmentAnnotations = new Dictionary <int, List <SpectrumPeakAnnotation> >
{
{ 3, MakeTestPeakAnnotation(Adduct.M_PLUS, 41.027f, "testfrag3", "85/86") },
{ 44, MakeTestPeakAnnotation(Adduct.M_PLUS, 128.070f, "testfrag_next_to_last", "83/86") },
{ 45, MakeTestPeakAnnotation(Adduct.M_PLUS, 146.081f, "testfrag_last", "85/86 note") },
};
var librarySpec = new NistLibSpec("Yeast (NIST)", PATH_NIST_LIB);
Library lib1 = librarySpec.LoadLibrary(loader);
CheckLibrary(lib1, 100);
CheckLibrary(lib1, 46, KEYS_LIB_BICENE_NIST);
Assert.AreEqual(streamManager.BinaryFiles.Count, 1);
Assert.IsTrue(streamManager.IsCached(PATH_NIST_LIB, PATH_NIST_LIB_CACHE));
// Corrupt the cache, and make sure it still possible to get
// a valid library.
byte[] cacheBytes = streamManager.BinaryFiles[PATH_NIST_LIB_CACHE];
int len = cacheBytes.Length;
byte[] corruptedBytes = new byte[len / 2];
Array.Copy(cacheBytes, corruptedBytes, corruptedBytes.Length);
streamManager.BinaryFiles[PATH_NIST_LIB_CACHE] = corruptedBytes;
// Check small molecule library with spectrum attributes
TestSpectrumPeakAnnotations(); // First, a quick low-level unit test of annotations handler class
Library lib2 = librarySpec.LoadLibrary(loader);
CheckLibrary(lib2, 100);
CheckLibrary(lib2, 46, KEYS_LIB_BICENE_NIST, expectedFragmentAnnotations);
Assert.AreEqual(len, streamManager.BinaryFiles[PATH_NIST_LIB_CACHE].Length);
Assert.IsTrue(lib1.IsSameLibrary(lib2));
Assert.AreEqual(0, lib1.CompareRevisions(lib2));
}
public static SrmDocument CreateNISTLibraryDocument(string textFasta, bool peptideList, string textLib,
out LibraryManager libraryManager, out TestDocumentContainer docContainer, out int startRev)
{
var streamManager = new MemoryStreamManager();
streamManager.TextFiles.Add(LibraryLoadTest.PATH_NIST_LIB, textLib);
var librarySpec = new NistLibSpec("Yeast (NIST)", LibraryLoadTest.PATH_NIST_LIB);
// For serialization, add the library spec to the settings
TestLibraryList = new SpectralLibraryList { librarySpec };
libraryManager = new LibraryManager { StreamManager = streamManager };
docContainer = new TestDocumentContainer();
SrmSettings settings = SrmSettingsList.GetDefault0_6();
settings = settings.ChangePeptideLibraries(l => l.ChangeLibrarySpecs(new[] { librarySpec }));
return CreateLibraryDocument(settings, textFasta, peptideList, docContainer, libraryManager, out startRev);
}
public void HunterLoadLibrary()
{
var streamManager = new MemoryStreamManager();
var loader = new TestLibraryLoader {
StreamManager = streamManager
};
Library libNist = CreateHunterFile(streamManager, loader, TEXT_LIB_YEAST_NIST);
Assert.AreEqual(1, streamManager.BinaryFiles.Count);
var librarySpecHunter = new XHunterLibSpec("Yeast (X!)", PATH_HUNTER_LIB);
Library libHunter = librarySpecHunter.LoadLibrary(loader);
CheckLibrary(libHunter, 20);
Assert.IsFalse(libNist.IsSameLibrary(libHunter));
}
public void BiblioSpecLoadLibrary()
{
var streamManager = new MemoryStreamManager();
var loader = new TestLibraryLoader {
StreamManager = streamManager
};
Library libNist = CreateBiblioFile(streamManager, loader, TEXT_LIB_YEAST_NIST);
Assert.AreEqual(1, streamManager.BinaryFiles.Count);
var librarySpecBiblio = new BiblioSpecLibSpec("Yeast (BS)", PATH_BIBLIOSPEC_LIB);
Library libBiblioSpec = librarySpecBiblio.LoadLibrary(loader);
CheckLibrary(libBiblioSpec, 100);
Assert.IsFalse(libNist.IsSameLibrary(libBiblioSpec));
}
public static string SerializeToString <T>(T from)
{
try
{
using (var ms = MemoryStreamManager.GetStream())
{
using (var xw = XmlWriter.Create(ms, XmlWriterSettings))
{
var serializer = new DataContractSerializer(from.GetType());
serializer.WriteObject(xw, from);
xw.Flush();
return(ms.ReadToEnd());
}
}
}
catch (Exception ex)
{
throw new SerializationException($"Error serializing object of type {@from.GetType().FullName}", ex);
}
}
protected override Block ReadBlock(int index, PipelineInfo pipelineInfo)
{
var position = ReadInt32();
if (position < 0 || position >= pipelineInfo.BlockCount)
{
throw new PipelineException("Source file corrupted.");
}
var compressedLength = ReadInt32();
if (compressedLength <= 0)
{
throw new PipelineException("Source file corrupted.");
}
var compressedStream = MemoryStreamManager.GetStream("Compressed");
SourceStream.CopyBlockTo(compressedStream, compressedLength);
compressedStream.Position = 0;
return(new Block(position, compressedStream));
}
public static SrmDocument CreateNISTLibraryDocument(string textFasta, bool peptideList, string textLib,
out LibraryManager libraryManager, out TestDocumentContainer docContainer, out int startRev)
{
var streamManager = new MemoryStreamManager();
streamManager.TextFiles.Add(LibraryLoadTest.PATH_NIST_LIB, textLib);
var librarySpec = new NistLibSpec("Yeast (NIST)", LibraryLoadTest.PATH_NIST_LIB);
// For serialization, add the library spec to the settings
TestLibraryList = new SpectralLibraryList {
librarySpec
};
libraryManager = new LibraryManager {
StreamManager = streamManager
};
docContainer = new TestDocumentContainer();
SrmSettings settings = SrmSettingsList.GetDefault0_6();
settings = settings.ChangePeptideLibraries(l => l.ChangeLibrarySpecs(new[] { librarySpec }));
return(CreateLibraryDocument(settings, textFasta, peptideList, docContainer, libraryManager, out startRev));
}
public void LibraryMultipleTest()
{
var streamManager = new MemoryStreamManager();
var loader = new LibraryLoadTest.TestLibraryLoader {
StreamManager = streamManager
};
// Create library files
const string hunterText = LibraryLoadTest.TEXT_LIB_YEAST_NIST1 + "\n" + LibraryLoadTest.TEXT_LIB_YEAST_NIST2;
LibraryLoadTest.CreateHunterFile(streamManager, loader, hunterText);
const string biblioText = LibraryLoadTest.TEXT_LIB_YEAST_NIST2 + "\n" + LibraryLoadTest.TEXT_LIB_YEAST_NIST3;
LibraryLoadTest.CreateBiblioFile(streamManager, loader, biblioText);
const string nistText = LibraryLoadTest.TEXT_LIB_YEAST_NIST3 + "\n" + LibraryLoadTest.TEXT_LIB_YEAST_NIST4;
streamManager.TextFiles.Add(LibraryLoadTest.PATH_NIST_LIB, nistText);
var hunterSpec = new XHunterLibSpec("Yeast (X!)", LibraryLoadTest.PATH_HUNTER_LIB);
var bilbioSpec = new BiblioSpecLibSpec("Yeast (BS)", LibraryLoadTest.PATH_BIBLIOSPEC_LIB);
var nistSpec = new NistLibSpec("Yeast (NIST)", LibraryLoadTest.PATH_NIST_LIB);
// For serialization, add the library spec to the settings
TestLibraryList = new SpectralLibraryList {
hunterSpec, bilbioSpec, nistSpec
};
var libraryManager = new LibraryManager {
StreamManager = streamManager
};
var docContainer = new TestDocumentContainer();
SrmSettings settings = SrmSettingsList.GetDefault();
settings = settings.ChangePeptideLibraries(l => l.ChangeLibrarySpecs(new LibrarySpec[] { hunterSpec, bilbioSpec, nistSpec }));
int startRev;
SrmDocument docLoaded = CreateLibraryDocument(settings, ExampleText.TEXT_FASTA_YEAST_LIB, false,
docContainer, libraryManager, out startRev);
AssertEx.IsDocumentState(docLoaded, startRev, 2, 4, 12);
Assert.IsTrue(HasLibraryInfo(docLoaded, typeof(XHunterSpectrumHeaderInfo)));
Assert.IsTrue(HasLibraryInfo(docLoaded, typeof(BiblioSpecSpectrumHeaderInfo)));
Assert.IsTrue(HasLibraryInfo(docLoaded, typeof(NistSpectrumHeaderInfo)));
// Remove the rank 1 transition from each transition group
TransitionDocNode[] transitionNodes = docLoaded.PeptideTransitions.ToArray();
for (int i = 0; i < transitionNodes.Length; i++)
{
var nodeTran = transitionNodes[i];
if (nodeTran.LibInfo.Rank != 1)
{
continue;
}
var path = docLoaded.GetPathTo((int)SrmDocument.Level.TransitionGroups, i / 3);
docLoaded = (SrmDocument)docLoaded.RemoveChild(path, nodeTran);
++startRev;
}
AssertEx.IsDocumentState(docLoaded, startRev, 2, 4, 8);
// Make sure this can be serialized and deserialized without causing
// a recalculation of the nodes in the tree.
AssertEx.Serializable(docLoaded, (doc1, doc2) => ValidateLibraryDocs(doc1, doc2, libraryManager));
}
public SwappingStream(Stream existing)
{
Stream = existing ?? MemoryStreamManager.GetStream();
Swapped = Stream is not MemoryStream;
}
public SwappingStream(byte[] bytes)
{
Stream = MemoryStreamManager.GetStream(bytes);
Swapped = false;
}
public void NistLoadLibrary()
{
var streamManager = new MemoryStreamManager();
streamManager.TextFiles.Add(PATH_NIST_LIB, TEXT_LIB_YEAST_NIST);
var loader = new TestLibraryLoader {StreamManager = streamManager};
var librarySpec = new NistLibSpec("Yeast (NIST)", PATH_NIST_LIB);
Library lib1 = librarySpec.LoadLibrary(loader);
CheckLibrary(lib1, 100);
Assert.AreEqual(streamManager.BinaryFiles.Count, 1);
Assert.IsTrue(streamManager.IsCached(PATH_NIST_LIB, PATH_NIST_LIB_CACHE));
// Corrupt the cache, and make sure it still possible to get
// a valid library.
byte[] cacheBytes = streamManager.BinaryFiles[PATH_NIST_LIB_CACHE];
int len = cacheBytes.Length;
byte[] corruptedBytes = new byte[len/2];
Array.Copy(cacheBytes, corruptedBytes, corruptedBytes.Length);
streamManager.BinaryFiles[PATH_NIST_LIB_CACHE] = corruptedBytes;
Library lib2 = librarySpec.LoadLibrary(loader);
CheckLibrary(lib2, 100);
Assert.AreEqual(len, streamManager.BinaryFiles[PATH_NIST_LIB_CACHE].Length);
Assert.IsTrue(lib1.IsSameLibrary(lib2));
Assert.AreEqual(0, lib1.CompareRevisions(lib2));
}
public void HunterLoadLibrary()
{
var streamManager = new MemoryStreamManager();
var loader = new TestLibraryLoader { StreamManager = streamManager };
Library libNist = CreateHunterFile(streamManager, loader, TEXT_LIB_YEAST_NIST);
Assert.AreEqual(1, streamManager.BinaryFiles.Count);
var librarySpecHunter = new XHunterLibSpec("Yeast (X!)", PATH_HUNTER_LIB);
Library libHunter = librarySpecHunter.LoadLibrary(loader);
CheckLibrary(libHunter, 20);
Assert.IsFalse(libNist.IsSameLibrary(libHunter));
}
private static Library CreateLibraryFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, Action<IStreamManager, Library> write)
{
streamManager.TextFiles[PATH_NIST_LIB] = nistText;
var librarySpec = new NistLibSpec("Temporary (NIST)", PATH_NIST_LIB);
Library libNist = librarySpec.LoadLibrary(loader);
Assert.IsNotNull(libNist);
write(streamManager, libNist);
streamManager.TextFiles.Remove(PATH_NIST_LIB);
streamManager.Delete(PATH_NIST_LIB_CACHE);
return libNist;
}
public static Library CreateBiblioFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return(CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => BiblioSpecLibrary.Write(sm, PATH_BIBLIOSPEC_LIB, lib)));
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return(CreateHunterFile(streamManager, loader, nistText, false));
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, bool lowIntensity)
{
return(CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => XHunterLibrary.Write(sm, PATH_HUNTER_LIB, lib, lowIntensity)));
}
private void HandleSplitMessage(PlayerNetworkSession playerSession, SplitPartPackage splitMessage)
{
int spId = splitMessage.SplitId;
int spIdx = splitMessage.SplitIdx;
int spCount = splitMessage.SplitCount;
Int24 sequenceNumber = splitMessage.DatagramSequenceNumber;
Reliability reliability = splitMessage.Reliability;
Int24 reliableMessageNumber = splitMessage.ReliableMessageNumber;
Int24 orderingIndex = splitMessage.OrderingIndex;
byte orderingChannel = splitMessage.OrderingChannel;
SplitPartPackage[] spPackets;
bool haveEmpty = false;
// Need sync for this part since they come very fast, and very close in time.
// If no synk, will often detect complete message two times (or more).
lock (playerSession.Splits)
{
if (!playerSession.Splits.ContainsKey(spId))
{
playerSession.Splits.TryAdd(spId, new SplitPartPackage[spCount]);
}
spPackets = playerSession.Splits[spId];
if (spPackets[spIdx] != null)
{
Log.Debug("Already had splitpart (resent). Ignore this part.");
return;
}
spPackets[spIdx] = splitMessage;
for (int i = 0; i < spPackets.Length; i++)
{
haveEmpty = haveEmpty || spPackets[i] == null;
}
}
if (!haveEmpty)
{
Log.DebugFormat("Got all {0} split packages for split ID: {1}", spCount, spId);
SplitPartPackage[] waste;
playerSession.Splits.TryRemove(spId, out waste);
using (MemoryStream stream = MemoryStreamManager.GetStream())
{
for (int i = 0; i < spPackets.Length; i++)
{
SplitPartPackage splitPartPackage = spPackets[i];
byte[] buf = splitPartPackage.Message;
if (buf == null)
{
Log.Error("Expected bytes in splitpart, but got none");
continue;
}
stream.Write(buf, 0, buf.Length);
splitPartPackage.PutPool();
}
byte[] buffer = stream.ToArray();
try
{
ConnectedPackage newPackage = ConnectedPackage.CreateObject();
newPackage._datagramSequenceNumber = sequenceNumber;
newPackage._reliability = reliability;
newPackage._reliableMessageNumber = reliableMessageNumber;
newPackage._orderingIndex = orderingIndex;
newPackage._orderingChannel = (byte)orderingChannel;
newPackage._hasSplit = false;
Package fullMessage = PackageFactory.CreatePackage(buffer[0], buffer, "raknet") ??
new UnknownPackage(buffer[0], buffer);
fullMessage.DatagramSequenceNumber = sequenceNumber;
fullMessage.Reliability = reliability;
fullMessage.ReliableMessageNumber = reliableMessageNumber;
fullMessage.OrderingIndex = orderingIndex;
fullMessage.OrderingChannel = orderingChannel;
newPackage.Messages = new List <Package>();
newPackage.Messages.Add(fullMessage);
Log.Debug(
$"Assembled split package {newPackage._reliability} message #{newPackage._reliableMessageNumber}, Chan: #{newPackage._orderingChannel}, OrdIdx: #{newPackage._orderingIndex}");
HandleConnectedPackage(playerSession, newPackage);
newPackage.PutPool();
}
catch (Exception e)
{
Log.Error("Error during split message parsing", e);
if (Log.IsDebugEnabled)
{
Log.Debug($"0x{buffer[0]:x2}\n{Package.HexDump(buffer)}");
}
playerSession.Disconnect("Bad package received from client.", false);
}
}
}
}
public void BiblioSpecLoadLibrary()
{
var streamManager = new MemoryStreamManager();
var loader = new TestLibraryLoader { StreamManager = streamManager };
Library libNist = CreateBiblioFile(streamManager, loader, TEXT_LIB_YEAST_NIST);
Assert.AreEqual(1, streamManager.BinaryFiles.Count);
var librarySpecBiblio = new BiblioSpecLibSpec("Yeast (BS)", PATH_BIBLIOSPEC_LIB);
Library libBiblioSpec = librarySpecBiblio.LoadLibrary(loader);
CheckLibrary(libBiblioSpec, 100);
Assert.IsFalse(libNist.IsSameLibrary(libBiblioSpec));
}
public void LibraryNoIonsTest()
{
var streamManager = new MemoryStreamManager();
var loader = new LibraryLoadTest.TestLibraryLoader { StreamManager = streamManager };
// Create X! Hunter library with 20 lowest intensity peaks in NIST library
LibraryLoadTest.CreateHunterFile(streamManager, loader, LibraryLoadTest.TEXT_LIB_YEAST_NIST, true);
var hunterSpec = new XHunterLibSpec("Yeast (X!)", LibraryLoadTest.PATH_HUNTER_LIB);
// For serialization, add the library spec to the settings
TestLibraryList = new SpectralLibraryList { hunterSpec };
var libraryManager = new LibraryManager { StreamManager = streamManager };
var docContainer = new TestDocumentContainer();
SrmSettings settings = SrmSettingsList.GetDefault();
settings = settings.ChangePeptideLibraries(l => l.ChangeLibrarySpecs(new LibrarySpec[] { hunterSpec }));
int startRev;
SrmDocument docLoaded = CreateLibraryDocument(settings, ExampleText.TEXT_FASTA_YEAST_LIB, false,
docContainer, libraryManager, out startRev);
// Peptides should have been chosen, but no transitions, since the spectra are garbage
AssertEx.IsDocumentState(docLoaded, startRev, 2, 4, 0);
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return CreateHunterFile(streamManager, loader, nistText, false);
}
public static Library CreateBiblioFile(MemoryStreamManager streamManager, ILoadMonitor loader, string nistText)
{
return CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => BiblioSpecLibrary.Write(sm, PATH_BIBLIOSPEC_LIB, lib));
}
public static void WriteQueryString(TextWriter writer, object instance)
{
try
{
JsState.QueryStringMode = true;
var i = 0;
var typedInstance = (T)instance;
foreach (var propertyWriter in PropertyWriters)
{
var propertyValue = propertyWriter.GetterFn(typedInstance);
if (propertyValue == null)
{
continue;
}
if (i++ > 0)
{
writer.Write('&');
}
var propertyType = propertyValue.GetType();
var strValue = propertyValue as string;
var isEnumerable = strValue == null &&
!propertyType.IsValueType &&
propertyType.HasInterface(typeof(IEnumerable));
if (QueryStringSerializer.ComplexTypeStrategy != null)
{
var nonEnumerableUserType = !isEnumerable && (propertyType.IsUserType() || propertyType.IsInterface);
if (nonEnumerableUserType || propertyType.IsOrHasGenericInterfaceTypeOf(typeof(IDictionary <,>)))
{
if (QueryStringSerializer.ComplexTypeStrategy(writer, propertyWriter.PropertyName, propertyValue))
{
continue;
}
}
}
Serializer.WritePropertyName(writer, propertyWriter.PropertyName);
writer.Write('=');
if (strValue != null)
{
writer.Write(strValue.UrlEncode());
}
else if (!isEnumerable)
{
propertyWriter.WriteFn(writer, propertyValue);
}
else
{
//Trim brackets in top-level lists in QueryStrings, e.g: ?a=[1,2,3] => ?a=1,2,3
using (var ms = MemoryStreamManager.GetStream())
{
var enumerableWriter = new StreamWriter(ms); //ms disposed in using
propertyWriter.WriteFn(enumerableWriter, propertyValue);
enumerableWriter.Flush();
var output = ms.ReadToEnd();
output = output.Trim(ArrayBrackets);
writer.Write(output);
}
}
}
}
finally
{
JsState.QueryStringMode = false;
}
}
public static Library CreateHunterFile(MemoryStreamManager streamManager, ILoadMonitor loader,
string nistText, bool lowIntensity)
{
return CreateLibraryFile(streamManager, loader, nistText,
(sm, lib) => XHunterLibrary.Write(sm, PATH_HUNTER_LIB, lib, lowIntensity));
}
private void HandleQuery(byte[] receiveBytes, IPEndPoint senderEndpoint)
{
if (!Config.GetProperty("EnableQuery", false))
{
return;
}
if (receiveBytes[0] != 0xFE || receiveBytes[1] != 0xFD)
{
return;
}
byte packetId = receiveBytes[2];
switch (packetId)
{
case 0x09:
{
byte[] buffer = new byte[17];
// ID
buffer[0] = 0x09;
// Sequence number
buffer[1] = receiveBytes[3];
buffer[2] = receiveBytes[4];
buffer[3] = receiveBytes[5];
buffer[4] = receiveBytes[6];
// Textual representation of int32 (token) with null terminator
string str = new Random().Next().ToString(CultureInfo.InvariantCulture) + "\x00";
Buffer.BlockCopy(str.ToCharArray(), 0, buffer, 5, 11);
_listener.Send(buffer, buffer.Length, senderEndpoint);
break;
}
case 0x00:
{
using (var stream = MemoryStreamManager.GetStream())
{
bool isFullStatRequest = receiveBytes.Length == 15;
if (Log.IsInfoEnabled)
{
Log.InfoFormat("Full request: {0}", isFullStatRequest);
}
// ID
stream.WriteByte(0x00);
// Sequence number
stream.WriteByte(receiveBytes[3]);
stream.WriteByte(receiveBytes[4]);
stream.WriteByte(receiveBytes[5]);
stream.WriteByte(receiveBytes[6]);
//{
// string str = "splitnum\0";
// byte[] bytes = Encoding.ASCII.GetBytes(str.ToCharArray());
// stream.Write(bytes, 0, bytes.Length);
//}
MotdProvider.GetMotd(ServerInfo, senderEndpoint); // Force update the player counts :-)
var data = new Dictionary <string, string>
{
{ "splitnum", "" + (char)128 },
{ "hostname", "Minecraft PE Server" },
{ "gametype", "SMP" },
{ "game_id", "MINECRAFTPE" },
{ "version", "0.15.0" },
{ "server_engine", "MiNET v1.0.0" },
{ "plugins", "MiNET v1.0.0" },
{ "map", "world" },
{ "numplayers", MotdProvider.NumberOfPlayers.ToString() },
{ "maxplayers", MotdProvider.MaxNumberOfPlayers.ToString() },
{ "whitelist", "off" },
//{"hostip", "192.168.0.1"},
//{"hostport", "19132"}
};
foreach (KeyValuePair <string, string> valuePair in data)
{
string key = valuePair.Key + "\x00" + valuePair.Value + "\x00";
byte[] bytes = Encoding.ASCII.GetBytes(key.ToCharArray());
stream.Write(bytes, 0, bytes.Length);
}
{
string str = "\x00\x01player_\x00\x00";
byte[] bytes = Encoding.ASCII.GetBytes(str.ToCharArray());
stream.Write(bytes, 0, bytes.Length);
}
// End the stream with 0 byte
stream.WriteByte(0);
var buffer = stream.ToArray();
_listener.Send(buffer, buffer.Length, senderEndpoint);
}
break;
}
default:
return;
}
}
public void TestLibraryRankedSpectrumInfoSpeed()
{
var testFilesDir = new TestFilesDir(TestContext, @"Test\LibraryRankedSpectrumInfoSpeedTest.zip");
SrmDocument srmDocument;
using (var stream = File.OpenRead(testFilesDir.GetTestPath("LibraryRankedSpectrumInfoSpeedTest.sky")))
{
srmDocument = (SrmDocument) new XmlSerializer(typeof(SrmDocument)).Deserialize(stream);
}
var unloadedLibrary = srmDocument.Settings.PeptideSettings.Libraries.Libraries.FirstOrDefault();
Assert.IsNotNull(unloadedLibrary);
var streamManager = new MemoryStreamManager();
var loader = new LibraryLoadTest.TestLibraryLoader {
StreamManager = streamManager
};
var librarySpec = unloadedLibrary.CreateSpec(testFilesDir.GetTestPath("LibraryRankedSpectrumInfoSpeedTest.blib"));
var library = librarySpec.LoadLibrary(loader);
Assert.IsTrue(library.IsLoaded);
var peptideLibraries = srmDocument.Settings.PeptideSettings.Libraries.ChangeLibraries(new[] { library });
var settingsWithLibraries =
srmDocument.Settings.ChangePeptideSettings(
srmDocument.Settings.PeptideSettings.ChangeLibraries(peptideLibraries));
// List of peptides to test with: <peptide sequence, description, expected # of matched ions, expected ranked ions>
Tuple <string, string, int, double[]>[] testPeptides = new[]
{
// ReSharper disable StringLiteralTypo
Tuple.Create("MEIVK", "Short Peptide",
20, new[] { 131.1, 147.1, 187.1 }),
Tuple.Create("EIYYTPDPSELAAKEEPAKEEAPAPTPAASAPAPAAAAPAPVAAAAPAAAAAEIADEPVK", "Long Peptide",
55, new[] { 587.4, 771.4, 900.5 }),
Tuple.Create("LVGFT[+80]FR", "Short Peptide with 1 Neutral Loss",
24, new[] { 305.1334, 322.0948, 325.2004 }),
Tuple.Create("DLKEILSGFHNAGPVAGAGAASGAAAAGGDAAAEEEKEEEAAEES[+80]DDDMGFGLFD",
"Long peptide with 1 Neutral Loss",
43, new[] { 790.1161, 825.5901, 889.6103 }),
Tuple.Create("MLPTS[+80]VS[+80]R", "Short peptide with 2 neutral losses",
36, new[] { 305.6439, 340.5001, 343.2071 }),
Tuple.Create("RNPDFEDDDFLGGDFDEDEIDEESS[+80]EEEEEEKT[+80]QKK", "Long peptide with 2 neutral losses",
65, new[] { 483.2214, 552.9168, 626.2743 })
// ReSharper restore StringLiteralTypo
};
Console.Out.WriteLine();
foreach (var tuple in testPeptides)
{
var peptideDocNode = srmDocument.Molecules.FirstOrDefault(pep => pep.ModifiedSequenceDisplay == tuple.Item1);
Assert.IsNotNull(peptideDocNode, "Could not find peptide {0}", tuple.Item1);
var transitionGroup = peptideDocNode.TransitionGroups.FirstOrDefault();
Assert.IsNotNull(transitionGroup);
var spectrum = library
.GetSpectra(new LibKey(peptideDocNode.ModifiedTarget, transitionGroup.PrecursorAdduct),
transitionGroup.LabelType, LibraryRedundancy.all).FirstOrDefault();
Assert.IsNotNull(spectrum);
var startTime = DateTime.UtcNow;
LibraryRankedSpectrumInfo libraryRankedSpectrum = null;
int repeatCount = 50;
for (int i = 0; i < repeatCount; i++)
{
libraryRankedSpectrum = LibraryRankedSpectrumInfo.NewLibraryRankedSpectrumInfo(spectrum.SpectrumPeaksInfo,
transitionGroup.LabelType, transitionGroup, settingsWithLibraries, peptideDocNode.ExplicitMods,
false, TransitionGroup.MAX_MATCHED_MSMS_PEAKS);
Assert.IsNotNull(libraryRankedSpectrum);
}
var endTime = DateTime.UtcNow;
Console.Out.WriteLine("Time to get LibraryRankedSpectrumInfo for {0} {1} times: {2}", tuple.Item2, repeatCount, endTime.Subtract(startTime));
Assert.IsNotNull(libraryRankedSpectrum);
var rankedMzs = libraryRankedSpectrum.PeaksRanked.Select(peak => Math.Round(peak.ObservedMz, 4)).Take(3).ToArray();
Console.Out.WriteLine("{0} matched peaks. First {1}/{2} ranked peaks: {{ {3} }}",
libraryRankedSpectrum.PeaksMatched.Count(), rankedMzs.Length,
libraryRankedSpectrum.PeaksRanked.Count(), string.Join(",", rankedMzs));
if (!IsRecording)
{
CollectionAssert.AreEqual(tuple.Item4, rankedMzs);
Assert.AreEqual(tuple.Item3, libraryRankedSpectrum.PeaksMatched.Count());
}
}
}
