internal static RefState ReadReferenceForObject(
BinaryConverter binaryConverter,
ref ReadStack state,
ref BinaryReader reader,
out object value)
{
if (reader.TokenType == BinaryTokenType.StartObject)
{
uint refSeq = BitConverter.ToUInt32(reader.ValueSpan);
state.ReferenceResolver.AddReference(refSeq);
value = default;
state.Current.RefId = refSeq;
return(RefState.None);
}
else if (reader.TokenType == BinaryTokenType.ObjectRef)
{
uint refSeq = BitConverter.ToUInt32(reader.ValueSpan);
state.Current.RefId = refSeq;
var refState = state.ReferenceResolver.TryGetReference(refSeq, out value);
if (refState == RefState.Start)
{
value = new ReferenceID()
{
RefSeq = refSeq
};
}
return(refState);
}
else
{
ThrowHelper.ThrowBinaryReaderException(ref reader, ExceptionResource.InvalidByte);
}
value = default;
return(RefState.None);
}
private int GetPartitionIndex(ReferenceID id)
{
int partitionID = id.PartitionID;
Global.Tracer.Assert(partitionID >= 0, "Invalid tree partition id: {0}", partitionID);
Global.Tracer.Assert(this.m_treePartitionOffsets != null && partitionID < this.m_treePartitionOffsets.Count, "Cannot update Tree partition: {0} without first allocating it", partitionID);
return(partitionID);
}
public void RebuildReferences(GenericCollection in_Root)
{
if (!ReferenceID.Equals(Guid.Empty))
{
Reference = in_Root.FindMember(ReferenceID);
}
FamilyTree.RebuildReferences(in_Root);
}
public override bool Equals(object obj)
{
if (obj is ReferenceID)
{
ReferenceID rhs = (ReferenceID)obj;
return(serverID == rhs.serverID && clientID == rhs.clientID);
}
return(false);
}
public bool Equals(DiscrepancyResponse other)
{
if (string.IsNullOrEmpty(ReferenceID))
{
return(false);
}
return(ReferenceID.Equals(other.ReferenceID));
}
public void UpdateTreePartitionOffset(ReferenceID id, long offset)
{
int partitionIndex = this.GetPartitionIndex(id);
Global.Tracer.Assert(offset >= 0, "Invalid offset for Tree partition. ID: {0} Offset: {1}", id, offset);
Global.Tracer.Assert(this.m_treePartitionOffsets[partitionIndex] == TreePartitionManager.EmptyTreePartitionOffset, "Cannot update offset for already persisted tree partition");
this.m_treeChanged = true;
this.m_treePartitionOffsets[partitionIndex] = offset;
}
public void HandleConnect(string serverID, int clientID, string remoteAddress, int remotePort)
{
ReferenceID thisReference = new ReferenceID(serverID, clientID);
lock (connectedClients)
{
connectedClients.Add(thisReference, null);
}
}
public override int GetHashCode()
{
if (string.IsNullOrEmpty(ReferenceID))
{
return(base.GetHashCode());
}
return(ReferenceID.GetHashCode());
}
public void HandleReport(string serverID, int clientID, ReportingMessage reportMessage)
{
ReferenceID thisReference = new ReferenceID(serverID, clientID);
int trackNumber = trackID[thisReference];
lock (connectedClients)
{
connectedClients[thisReference] = reportMessage;
}
SQLReport(trackNumber, reportMessage);
}
public void HandleConnect(string serverID, int clientID, string remoteAddress, int remotePort)
{
ReferenceID thisReference = new ReferenceID(serverID, clientID);
trackID.Add(thisReference, Interlocked.Increment(ref freeID));
int trackNumber = trackID[thisReference];
lock (connectedClients)
{
connectedClients.Add(thisReference, null);
}
SQLConnect(trackNumber, remoteAddress);
}
public void TransferToLookupCache(OnDemandProcessingContext odpContext)
{
Global.Tracer.Assert(this.m_lookupTable != null, "Can't transfer a missing LookupTable");
Global.Tracer.Assert(!this.HasBeenTransferred, "Can't transfer a LookupTable twice");
OnDemandMetadata odpMetadata = odpContext.OdpMetadata;
odpMetadata.EnsureLookupScalabilitySetup(odpContext.ChunkFactory, odpContext.GetActiveCompatibilityVersion(), odpContext.ProhibitSerializableValues);
LookupScalabilityCache lookupScalabilityCache = odpMetadata.LookupScalabilityCache;
IReference <LookupTable> reference = lookupScalabilityCache.AllocateEmptyTreePartition <LookupTable>(AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.LookupTableReference);
this.m_lookupTable.TransferTo(lookupScalabilityCache);
lookupScalabilityCache.SetTreePartitionContentsAndPin(reference, this.m_lookupTable);
this.m_lookupTablePartitionId = reference.Id;
reference.UnPinValue();
}
public void HandleDisconnect(string serverID, int clientID)
{
ReferenceID thisReference = new ReferenceID(serverID, clientID);
int trackNumber = trackID[thisReference];
lock (connectedClients)
{
if (connectedClients.ContainsKey(thisReference))
{
connectedClients.Remove(thisReference);
}
}
SQLDisconnect(trackNumber);
trackID.Remove(thisReference);
}
public ReferenceID AllocateNewTreePartition()
{
this.m_treeChanged = true;
if (this.m_treePartitionOffsets == null)
{
this.m_treePartitionOffsets = new List <long>();
}
int count = this.m_treePartitionOffsets.Count;
this.m_treePartitionOffsets.Add(TreePartitionManager.EmptyTreePartitionOffset);
ReferenceID result = default(ReferenceID);
result.HasMultiPart = true;
result.IsTemporary = false;
result.PartitionID = count;
return(result);
}
internal ReferenceID AllocateNewTreePartition()
{
m_treeChanged = true;
if (m_treePartitionOffsets == null)
{
m_treePartitionOffsets = new List <long>();
}
int count = m_treePartitionOffsets.Count;
m_treePartitionOffsets.Add(EmptyTreePartitionOffset);
ReferenceID result = default(ReferenceID);
result.HasMultiPart = true;
result.IsTemporary = false;
result.PartitionID = count;
return(result);
}
public void HandleDisconnect(string serverID, int clientID)
{
ReferenceID thisReference = new ReferenceID(serverID, clientID);
lock (connectedClients)
{
connectedClients.Remove(thisReference);
}
if (pairMatch.ContainsKey(thisReference))
{
string serverHash = pairMatch[thisReference];
TrackingObject trackingObject = trackingObjects[serverHash];
trackingObject.referenceCount--;
Console.WriteLine(serverHash + " references: " + trackingObject.referenceCount);
if (trackingObject.referenceCount == 0)
{
SQLDisconnect(serverHash, trackingObject);
trackingObjects.Remove(serverHash);
}
pairMatch.Remove(thisReference);
}
}
public void HandleReport(string serverID, int clientID, ReportingMessage reportMessage)
{
ReferenceID thisReference = new ReferenceID(serverID, clientID);
lock (connectedClients)
{
connectedClients[thisReference] = reportMessage;
}
if (!pairMatch.ContainsKey(thisReference))
{
pairMatch.Add(thisReference, reportMessage.serverHash);
if (!trackingObjects.ContainsKey(reportMessage.serverHash))
{
trackingObjects.Add(reportMessage.serverHash, new TrackingObject());
SQLConnect(reportMessage, trackingObjects[reportMessage.serverHash]);
}
TrackingObject trackingObject = trackingObjects[reportMessage.serverHash];
trackingObject.referenceCount++;
Console.WriteLine(reportMessage.serverHash + " references: " + trackingObject.referenceCount);
}
SQLReport(reportMessage, trackingObjects[reportMessage.serverHash]);
}
public void Deserialize(IntermediateFormatReader reader)
{
reader.RegisterDeclaration(LookupObjResult.m_Declaration);
while (reader.NextMember())
{
switch (reader.CurrentMember.MemberName)
{
case MemberName.LookupTablePartitionID:
this.m_lookupTablePartitionId = new ReferenceID(reader.ReadInt64());
break;
case MemberName.HasCode:
this.m_hasErrorCode = reader.ReadBoolean();
break;
case MemberName.Code:
this.m_errorCode = (ProcessingErrorCode)reader.ReadEnum();
break;
case MemberName.Severity:
this.m_errorSeverity = (Severity)reader.ReadEnum();
break;
case MemberName.FieldStatus:
this.m_dataFieldStatus = (DataFieldStatus)reader.ReadEnum();
break;
case MemberName.Arguments:
this.m_errorMessageArgs = reader.ReadStringArray();
break;
default:
Global.Tracer.Assert(false);
break;
}
}
}
public long GetTreePartitionOffset(ReferenceID id)
{
int partitionIndex = this.GetPartitionIndex(id);
return(this.m_treePartitionOffsets[partitionIndex]);
}
// Converts the object to string
public override string ToString()
{
string str;
str = "Leap Indicator: ";
switch (LeapIndicator)
{
case _LeapIndicator.NoWarning:
str += "No warning";
break;
case _LeapIndicator.LastMinute61:
str += "Last minute has 61 seconds";
break;
case _LeapIndicator.LastMinute59:
str += "Last minute has 59 seconds";
break;
case _LeapIndicator.Alarm:
str += "Alarm Condition (clock not synchronized)";
break;
}
str += "\r\nVersion number: " + VersionNumber.ToString() + "\r\n";
str += "Mode: ";
switch (Mode)
{
case _Mode.Unknown:
str += "Unknown";
break;
case _Mode.SymmetricActive:
str += "Symmetric Active";
break;
case _Mode.SymmetricPassive:
str += "Symmetric Pasive";
break;
case _Mode.Client:
str += "Client";
break;
case _Mode.Server:
str += "Server";
break;
case _Mode.Broadcast:
str += "Broadcast";
break;
}
str += "\r\nStratum: ";
switch (Stratum)
{
case _Stratum.Unspecified:
case _Stratum.Reserved:
str += "Unspecified";
break;
case _Stratum.PrimaryReference:
str += "Primary Reference";
break;
case _Stratum.SecondaryReference:
str += "Secondary Reference";
break;
}
str += "\r\nLocal time: " + TransmitTimestamp.ToString();
str += "\r\nPrecision: " + Precision.ToString() + " ms";
str += "\r\nPoll Interval: " + PollInterval.ToString() + " s";
str += "\r\nReference ID: " + ReferenceID.ToString();
str += "\r\nRoot Dispersion: " + RootDispersion.ToString() + " ms";
str += "\r\nRound Trip Delay: " + RoundTripDelay.ToString() + " ms";
str += "\r\nLocal Clock Offset: " + LocalClockOffset.ToString() + " ms";
str += "\r\n";
return(str);
}
internal long GetTreePartitionOffset(ReferenceID id)
{
int partitionIndex = GetPartitionIndex(id);
return(m_treePartitionOffsets[partitionIndex]);
}
/// <summary>
/// Returns a <see cref="System.String"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String"/> that represents this instance.
/// </returns>
public override string ToString()
{
string str;
str = "Leap Indicator: ";
switch (LeapIndicator)
{
case LeapIndicator.NoWarning:
str += "No warning";
break;
case LeapIndicator.LastMinute61:
str += "Last minute has 61 seconds";
break;
case LeapIndicator.LastMinute59:
str += "Last minute has 59 seconds";
break;
case LeapIndicator.Alarm:
str += "Alarm Condition (clock not synchronized)";
break;
}
str += "\r\nVersion number: " + VersionNumber.ToString() + "\r\n";
str += "Mode: ";
switch (Mode)
{
case NtpMode.Unknown:
str += "Unknown";
break;
case NtpMode.SymmetricActive:
str += "Symmetric Active";
break;
case NtpMode.SymmetricPassive:
str += "Symmetric Pasive";
break;
case NtpMode.Client:
str += "Client";
break;
case NtpMode.Server:
str += "Server";
break;
case NtpMode.Broadcast:
str += "Broadcast";
break;
}
str += "\r\nStratum: ";
switch (Stratum)
{
case NtpStratum.Unspecified:
case NtpStratum.Reserved:
str += "Unspecified";
break;
case NtpStratum.PrimaryReference:
str += "Primary Reference";
break;
case NtpStratum.SecondaryReference:
str += "Secondary Reference";
break;
}
str += "\r\nOriginate (Send request): " + OriginateTimestamp.ToString("dd/MM/yyyy HH:mm:ss.fff");
str += "\r\nRecieve (Server recieved): " + ReceiveTimestamp.ToString("dd/MM/yyyy HH:mm:ss.fff");
str += "\r\nTransmit (Server reply): " + TransmitTimestamp.ToString("dd/MM/yyyy HH:mm:ss.fff");
str += "\r\nReception (Request recieved): " + ReceptionTimestamp.ToString("dd/MM/yyyy HH:mm:ss.fff");
str += "\r\nServer transmit time (Local zone): " + TransmitTimestamp.ToString("dd/MM/yyyy HH:mm:ss.fff");
str += "\r\nPrecision: " + Precision.ToString() + " ms";
str += "\r\nPoll Interval: " + PollInterval.ToString() + " s";
str += "\r\nReference ID: " + ReferenceID.ToString();
str += "\r\nRoot Dispersion: " + RootDispersion.ToString() + " ms";
str += "\r\nRound Trip Delay: " + RoundTripDelay.TotalMilliseconds.ToString() + " ms";
str += "\r\nLocal Clock Offset: " + LocalClockOffset.TotalMilliseconds.ToString() + " ms";
str += "\r\n";
return(str);
}
