public TwoPhaseCommitParticipantEvent(ParticipantEnlistment participant) : base(participant) { MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders; this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion); this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders); this.messageID = incomingMessageHeaders.MessageId; }
public WsrmAcknowledgmentHeader(ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceID, SequenceRangeCollection ranges, bool final, int bufferRemaining) : base(reliableMessagingVersion) { this.sequenceID = sequenceID; this.ranges = ranges; this.final = final; this.bufferRemaining = bufferRemaining; }
public ServerReliableDuplexSessionChannel(ReliableChannelListenerBase<IDuplexSessionChannel> listener, IReliableChannelBinder binder, FaultHelper faultHelper, UniqueId inputID, UniqueId outputID) : base(listener, listener, binder) { this.listener = listener; DuplexServerReliableSession session = new DuplexServerReliableSession(this, listener, faultHelper, inputID, outputID); base.SetSession(session); session.Open(TimeSpan.Zero); base.SetConnections(); if (PerformanceCounters.PerformanceCountersEnabled) { this.perfCounterId = this.listener.Uri.ToString().ToUpperInvariant(); } if (binder.HasSession) { try { base.StartReceiving(false); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } base.ReliableSession.OnUnknownException(exception); } } }
protected WsrmHeaderFault(bool isSenderFault, string subcode, string faultReason, string exceptionMessage, UniqueId sequenceID, bool faultsInput, bool faultsOutput) : base(isSenderFault, subcode, faultReason, exceptionMessage) { this.subcode = subcode; this.sequenceID = sequenceID; this.faultsInput = faultsInput; this.faultsOutput = faultsOutput; }
internal static void WriteAckRanges(XmlDictionaryWriter writer, ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceId, SequenceRangeCollection ranges) { WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary; XmlDictionaryString namespaceUri = WsrmIndex.GetNamespace(reliableMessagingVersion); writer.WriteStartElement(dictionary.Identifier, namespaceUri); writer.WriteValue(sequenceId); writer.WriteEndElement(); if (ranges.Count == 0) { if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005) { ranges = ranges.MergeWith((long) 0L); } else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) { writer.WriteStartElement(DXD.Wsrm11Dictionary.None, namespaceUri); writer.WriteEndElement(); } } for (int i = 0; i < ranges.Count; i++) { writer.WriteStartElement(dictionary.AcknowledgementRange, namespaceUri); writer.WriteStartAttribute(dictionary.Lower, null); SequenceRange range = ranges[i]; writer.WriteValue(range.Lower); writer.WriteEndAttribute(); writer.WriteStartAttribute(dictionary.Upper, null); SequenceRange range2 = ranges[i]; writer.WriteValue(range2.Upper); writer.WriteEndAttribute(); writer.WriteEndElement(); } }
public VolatileTwoPhaseCommitCoordinatorEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator) { MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders; this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion); this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders); this.messageID = incomingMessageHeaders.MessageId; }
public AddressingProperty(MessageHeaders headers) { this.action = headers.Action; this.to = headers.To; this.replyTo = headers.ReplyTo; this.messageId = headers.MessageId; }
public CompletionParticipantEvent(CompletionEnlistment completion) : base(completion) { MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders; this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion); this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders); this.messageID = incomingMessageHeaders.MessageId; }
private WsrmAcknowledgmentInfo(UniqueId sequenceID, SequenceRangeCollection ranges, bool final, int bufferRemaining, MessageHeaderInfo header) : base(header) { this.sequenceID = sequenceID; this.ranges = ranges; this.final = final; this.bufferRemaining = bufferRemaining; }
public TerminateSequence(ReliableMessagingVersion reliableMessagingVersion, UniqueId identifier, Int64 last) : base(true) { this.reliableMessagingVersion = reliableMessagingVersion; this.identifier = identifier; this.lastMsgNumber = last; }
public bool IsNotSeenBefore(Message message, out byte[] id, out int cacheHit) { cacheHit = -1; id = PeerNodeImplementation.DefaultId; if (message is SecurityVerifiedMessage) { id = (message as SecurityVerifiedMessage).PrimarySignatureValue; } else { System.Xml.UniqueId messageId = PeerMessageHelpers.GetHeaderUniqueId(message.Headers, PeerStrings.MessageId, PeerStrings.Namespace); if (messageId == null) { return(false); } if (messageId.IsGuid) { id = new byte[16]; messageId.TryGetGuid(id, 0); } else { return(false); } } cacheHit = messageIds.AddForLookup(id); if (cacheHit == -1) { return(true); } return(false); }
public TransmissionStrategy(ReliableMessagingVersion reliableMessagingVersion, TimeSpan initRtt, int maxWindowSize, bool requestAcks, UniqueId id) { if (initRtt < TimeSpan.Zero) { if (DiagnosticUtility.ShouldTrace(TraceEventType.Warning)) { TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WsrmNegativeElapsedTimeDetected, SR.GetString(SR.TraceCodeWsrmNegativeElapsedTimeDetected), this); } initRtt = ReliableMessagingConstants.UnknownInitiationTime; } if (maxWindowSize <= 0) { throw Fx.AssertAndThrow("Argument maxWindow size must be positive."); } this.id = id; this.maxWindowSize = this.lossWindowSize = maxWindowSize; this.meanRtt = Math.Min((long)initRtt.TotalMilliseconds, Constants.MaxMeanRtt >> Constants.TimeMultiplier) << Constants.TimeMultiplier; this.serrRtt = this.meanRtt >> 1; this.window = new SlidingWindow(maxWindowSize); this.slowStartThreshold = maxWindowSize; this.timeout = Math.Max(((200 << Constants.TimeMultiplier) * 2) + this.meanRtt, this.meanRtt + (this.serrRtt << Constants.ChebychevFactor)); this.quotaRemaining = Int32.MaxValue; this.retryTimer = new IOThreadTimer(new Action<object>(OnRetryElapsed), null, true); this.requestAcks = requestAcks; this.reliableMessagingVersion = reliableMessagingVersion; }
public static void ReadHeaderValue(XmlDictionaryReader reader, AddressingVersion version, out Uri relationshipType, out System.Xml.UniqueId messageId) { AddressingDictionary addressingDictionary = XD.AddressingDictionary; relationshipType = ReplyRelationshipType; messageId = reader.ReadElementContentAsUniqueId(); }
public void MatchesKeyIdentifierClause () { UniqueId id = new UniqueId (); X509SecurityToken t = new X509SecurityToken (cert, id.ToString ()); LocalIdKeyIdentifierClause l = new LocalIdKeyIdentifierClause (id.ToString ()); Assert.IsTrue (t.MatchesKeyIdentifierClause (l), "#1-1"); l = new LocalIdKeyIdentifierClause ("#" + id.ToString ()); Assert.IsFalse (t.MatchesKeyIdentifierClause (l), "#1-2"); X509ThumbprintKeyIdentifierClause h = new X509ThumbprintKeyIdentifierClause (cert); Assert.IsTrue (t.MatchesKeyIdentifierClause (h), "#2-1"); h = new X509ThumbprintKeyIdentifierClause (cert2); Assert.IsFalse (t.MatchesKeyIdentifierClause (h), "#2-2"); X509IssuerSerialKeyIdentifierClause i = new X509IssuerSerialKeyIdentifierClause (cert); Assert.IsTrue (t.MatchesKeyIdentifierClause (i), "#3-1"); i = new X509IssuerSerialKeyIdentifierClause (cert2); Assert.IsFalse (t.MatchesKeyIdentifierClause (i), "#3-2"); X509RawDataKeyIdentifierClause s = new X509RawDataKeyIdentifierClause (cert); Assert.IsTrue (t.MatchesKeyIdentifierClause (s), "#4-1"); s = new X509RawDataKeyIdentifierClause (cert2); Assert.IsFalse (t.MatchesKeyIdentifierClause (s), "#4-2"); }
protected void SetMessageId(MessageVersion messageVersion, MessageHeaders headers) { this.messageId = headers.MessageId; if (this.messageId == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingMessageIdOnWsrmRequest", new object[] { this.RequestName }), messageVersion.Addressing.Namespace, "MessageID", false)); } }
public CreateSequence(AddressingVersion addressingVersion, ReliableMessagingVersion reliableMessagingVersion, bool ordered, IClientReliableChannelBinder binder, UniqueId offerIdentifier) : base(true) { this.addressingVersion = addressingVersion; this.reliableMessagingVersion = reliableMessagingVersion; this.ordered = ordered; this.binder = binder; this.offerIdentifier = offerIdentifier; }
internal SecurityContextSecurityToken(SecurityContextSecurityToken sourceToken, string id, byte[] key, UniqueId keyGeneration, DateTime keyEffectiveTime, DateTime keyExpirationTime, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies) : base() { _id = id; this.Initialize(sourceToken._contextId, key, sourceToken.ValidFrom, sourceToken.ValidTo, authorizationPolicies, sourceToken._isCookieMode, keyGeneration, keyEffectiveTime, keyExpirationTime); _cookieBlob = sourceToken._cookieBlob; _bootstrapMessageProperty = (sourceToken._bootstrapMessageProperty == null) ? null : (SecurityMessageProperty)sourceToken.BootstrapMessageProperty.CreateCopy(); }
protected MakeConnectionMessageFault(Message message, FaultCode code, string subcode, FaultReason reason) { this.code = code; this.subcode = subcode; this.reason = reason; this.isRemote = true; this.originalMessageId = message.Headers.MessageId; }
internal SecurityContextSecurityToken(UniqueId contextId, string id, byte[] key, DateTime validFrom, DateTime validTo, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies, bool isCookieMode, byte[] cookieBlob, UniqueId keyGeneration, DateTime keyEffectiveTime, DateTime keyExpirationTime) : base() { _id = id; this.Initialize(contextId, key, validFrom, validTo, authorizationPolicies, isCookieMode, keyGeneration, keyEffectiveTime, keyExpirationTime); _cookieBlob = cookieBlob; }
public SecurityContextSecurityToken GetContext (UniqueId contextId, UniqueId generation) { Table table; if (!cache.TryGetValue (contextId, out table)) return null; SecurityContextSecurityToken ret; return table.TryGetValue (generation, out ret) ? ret : null; }
public AddressingProperty(MessageHeaders headers) { Fx.Assert(null != headers, ""); this.action = headers.Action; this.to = headers.To; this.replyTo = headers.ReplyTo; this.messageId = headers.MessageId; }
protected MakeConnectionMessageFault(Message message, string subcode, string faultReason, string exceptionMessage) { this.code = new FaultCode("Receiver", ""); this.subcode = subcode; this.reason = new FaultReason(faultReason); this.exceptionMessage = exceptionMessage; this.isRemote = false; this.originalMessageId = message.Headers.MessageId; }
public ReliableOutputConnection(UniqueId id, int maxTransferWindowSize, System.ServiceModel.Channels.MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, TimeSpan initialRtt, bool requestAcks, TimeSpan sendTimeout) { this.id = id; this.messageVersion = messageVersion; this.reliableMessagingVersion = reliableMessagingVersion; this.sendTimeout = sendTimeout; this.strategy = new TransmissionStrategy(reliableMessagingVersion, initialRtt, maxTransferWindowSize, requestAcks, id); this.strategy.RetryTimeoutElapsed = new RetryHandler(this.OnRetryTimeoutElapsed); this.strategy.OnException = new ComponentExceptionHandler(this.RaiseOnException); }
public void DefaultValues () { UniqueId id = new UniqueId (); X509SecurityToken t = new X509SecurityToken (cert, id.ToString ()); Assert.AreEqual (id.ToString (), t.Id, "#1"); Assert.AreEqual (cert, t.Certificate, "#2"); Assert.AreEqual (cert.NotBefore.ToUniversalTime (), t.ValidFrom, "#3"); Assert.AreEqual (cert.NotAfter.ToUniversalTime (), t.ValidTo, "#4"); Assert.AreEqual (1, t.SecurityKeys.Count, "#5"); }
public Collection<SecurityContextSecurityToken> GetAllContexts (UniqueId contextId) { Table table; if (!cache.TryGetValue (contextId, out table)) return new Collection<SecurityContextSecurityToken> (); SecurityContextSecurityToken [] arr = new SecurityContextSecurityToken [table.Count]; table.Values.CopyTo (arr, 0); return new Collection<SecurityContextSecurityToken> (arr); }
public SecurityContextKeyIdentifierClause(UniqueId contextId, UniqueId generation, byte[] derivationNonce, int derivationLength) : base(null, derivationNonce, derivationLength) { if (contextId == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextId"); } _contextId = contextId; _generation = generation; }
private Guid ProvideUrnFromHeaderFields(UniqueId headerField) { var urn = new Guid(); if (headerField != null) { var possibleUrnAsString = StripFormattingFromHeaderFields(headerField.ToString()); Guid.TryParseExact(possibleUrnAsString, "D", out urn); } return urn; }
public static Message CreateFaultMessage(UniqueId messageID, MessageVersion messageVersion, Fault fault) { MessageFault fault2 = MessageFault.CreateFault(FaultCode.CreateSenderFaultCode(fault.Code), fault.Reason); Message message = Message.CreateMessage(messageVersion, fault2, messageVersion.Addressing.FaultAction); message.Headers.Action = fault.Action; if (messageID != null) { message.Headers.RelatesTo = messageID; } return message; }
public void DefaultValues () { UniqueId id = new UniqueId (); UserNameSecurityToken t = new UserNameSecurityToken ("mono", "poly", id.ToString ()); Assert.AreEqual (id.ToString (), t.Id, "#1"); Assert.AreEqual ("mono", t.UserName, "#2"); Assert.AreEqual ("poly", t.Password,"#3"); Assert.IsTrue (DateTime.Today.ToUniversalTime () <= t.ValidFrom && DateTime.Now.ToUniversalTime () >= t.ValidFrom, "#4"); Assert.AreEqual (DateTime.MaxValue.AddDays (-1), t.ValidTo, "#5"); Assert.AreEqual (0, t.SecurityKeys.Count, "#6"); }
public static RelatesToHeader Create(System.Xml.UniqueId messageId, AddressingVersion addressingVersion) { if (object.ReferenceEquals(messageId, null)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("messageId")); } if (addressingVersion == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("addressingVersion")); } return(new RelatesToHeader(messageId, addressingVersion)); }
static System.Xml.UniqueId GetAttributeAsUniqueId(XmlDictionaryReader reader, string name, string ns) { if (!reader.MoveToAttribute(name, ns)) { return(null); } System.Xml.UniqueId id = reader.ReadContentAsUniqueId(); reader.MoveToElement(); return(id); }
public static MessageIDHeader Create(UniqueId messageId, AddressingVersion addressingVersion) { if (object.ReferenceEquals(messageId, null)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("messageId")); } if (addressingVersion == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("addressingVersion")); } return new MessageIDHeader(messageId, addressingVersion); }
internal AsyncOperationContext(UniqueId operationId, int maxResults, TimeSpan duration, object userState) { Fx.Assert(operationId != null, "The operation id must be non null."); Fx.Assert(maxResults > 0, "The maxResults parameter must be positive."); Fx.Assert(duration > TimeSpan.Zero, "The duration parameter must be positive."); this.maxResults = maxResults; this.duration = duration; this.userState = userState; this.operationId = operationId; this.syncRoot = new object(); }
public void SetSessionTokenAuthenticator(UniqueId sessionId, SecurityTokenAuthenticator sessionTokenAuthenticator, SecurityTokenResolver sessionTokenResolver) { this.CommunicationObject.ThrowIfDisposedOrImmutable(); this.sessionId = sessionId; this.sessionTokenResolver = sessionTokenResolver; Collection<SecurityTokenResolver> tmp = new Collection<SecurityTokenResolver>(); tmp.Add(this.sessionTokenResolver); this.sessionTokenResolverList = new ReadOnlyCollection<SecurityTokenResolver>(tmp); this.sessionTokenAuthenticator = sessionTokenAuthenticator; SupportingTokenAuthenticatorSpecification spec = new SupportingTokenAuthenticatorSpecification(this.sessionTokenAuthenticator, this.sessionTokenResolver, SecurityTokenAttachmentMode.Endorsing, this.Factory.SecurityTokenParameters); this.sessionTokenAuthenticatorSpecificationList = new Collection<SupportingTokenAuthenticatorSpecification>(); this.sessionTokenAuthenticatorSpecificationList.Add(spec); }
public override SecurityKeyIdentifierClause ReadClause(XmlDictionaryReader reader, byte[] derivationNonce, int derivationLength, string tokenType) { System.Xml.UniqueId uri = XmlHelper.GetAttributeAsUniqueId(reader, XD.SecurityJan2004Dictionary.URI, null); System.Xml.UniqueId generation = ReadGeneration(reader); if (reader.IsEmptyElement) { reader.Read(); } else { reader.ReadStartElement(); while (reader.IsStartElement()) { reader.Skip(); } reader.ReadEndElement(); } return(new SecurityContextKeyIdentifierClause(uri, generation, derivationNonce, derivationLength)); }
/// <summary> /// Retrieves all tokens associated with a given key. /// </summary> /// <param name="endpointId">The endpointId to search for.</param> /// <param name="contextId">The contextId to search for.</param> /// <returns>In the derived class returns, the collection of tokens associated with the key.</returns> public abstract IEnumerable <SessionSecurityToken> GetAll(string endpointId, System.Xml.UniqueId contextId);
/// <summary> /// Reads the SessionSecurityToken from the given reader. /// </summary> /// <param name="reader">XmlReader over the SessionSecurityToken.</param> /// <param name="tokenResolver">SecurityTokenResolver that can used to resolve SessionSecurityToken.</param> /// <returns>An instance of <see cref="SessionSecurityToken"/>.</returns> /// <exception cref="ArgumentNullException">The input argument 'reader' is null.</exception> /// <exception cref="SecurityTokenException">The 'reader' is not positioned at a SessionSecurityToken /// or the SessionSecurityToken cannot be read.</exception> public override SecurityToken ReadToken(XmlReader reader, SecurityTokenResolver tokenResolver) { if (reader == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader"); } if (tokenResolver == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenResolver"); } byte[] encodedCookie = null; SysUniqueId contextId = null; SysUniqueId keyGeneration = null; string ns = null; string identifier = null; string instance = null; SecurityToken securityContextToken = null; SessionDictionary dictionary = SessionDictionary.Instance; XmlDictionaryReader dicReader = XmlDictionaryReader.CreateDictionaryReader(reader); if (dicReader.IsStartElement(WSSecureConversationFeb2005Constants.ElementNames.Name, WSSecureConversationFeb2005Constants.Namespace)) { ns = WSSecureConversationFeb2005Constants.Namespace; identifier = WSSecureConversationFeb2005Constants.ElementNames.Identifier; instance = WSSecureConversationFeb2005Constants.ElementNames.Instance; } else if (dicReader.IsStartElement(WSSecureConversation13Constants.ElementNames.Name, WSSecureConversation13Constants.Namespace)) { ns = WSSecureConversation13Constants.Namespace; identifier = WSSecureConversation13Constants.ElementNames.Identifier; instance = WSSecureConversation13Constants.ElementNames.Instance; } else { // // Something is wrong // throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException( SR.GetString(SR.ID4230, WSSecureConversationFeb2005Constants.ElementNames.Name, dicReader.Name))); } string id = dicReader.GetAttribute(WSUtilityConstants.Attributes.IdAttribute, WSUtilityConstants.NamespaceURI); dicReader.ReadFullStartElement(); if (!dicReader.IsStartElement(identifier, ns)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException( SR.GetString(SR.ID4230, WSSecureConversation13Constants.ElementNames.Identifier, dicReader.Name))); } contextId = dicReader.ReadElementContentAsUniqueId(); if (contextId == null || string.IsNullOrEmpty(contextId.ToString())) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4242))); } // // The token can be a renewed token, in which case we need to know the // instance id, which will be the secondary key to the context id for // cache lookups // if (dicReader.IsStartElement(instance, ns)) { keyGeneration = dicReader.ReadElementContentAsUniqueId(); } if (dicReader.IsStartElement(CookieElementName, CookieNamespace)) { // Get the token from the Cache, which is returned as an SCT SecurityToken cachedToken = null; SecurityContextKeyIdentifierClause sctClause = null; if (keyGeneration == null) { sctClause = new SecurityContextKeyIdentifierClause(contextId); } else { sctClause = new SecurityContextKeyIdentifierClause(contextId, keyGeneration); } tokenResolver.TryResolveToken(sctClause, out cachedToken); if (cachedToken != null) { securityContextToken = cachedToken; dicReader.Skip(); } else { // // CookieMode // encodedCookie = dicReader.ReadElementContentAsBase64(); if (encodedCookie == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4237))); } // // appply transforms // byte[] decodedCookie = ApplyTransforms(encodedCookie, false); using (MemoryStream ms = new MemoryStream(decodedCookie)) { BinaryFormatter formatter = new BinaryFormatter(); securityContextToken = formatter.Deserialize(ms) as SecurityToken; } SessionSecurityToken sessionToken = securityContextToken as SessionSecurityToken; if (sessionToken != null && sessionToken.ContextId != contextId) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4229, sessionToken.ContextId, contextId))); } if (sessionToken != null && sessionToken.Id != id) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4227, sessionToken.Id, id))); } } } else { // // SessionMode // // Get the token from the Cache. SecurityToken cachedToken = null; SecurityContextKeyIdentifierClause sctClause = null; if (keyGeneration == null) { sctClause = new SecurityContextKeyIdentifierClause(contextId); } else { sctClause = new SecurityContextKeyIdentifierClause(contextId, keyGeneration); } tokenResolver.TryResolveToken(sctClause, out cachedToken); if (cachedToken != null) { securityContextToken = cachedToken; } } dicReader.ReadEndElement(); if (securityContextToken == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4243))); } return(securityContextToken); }
static public void WriteAttributeStringAsUniqueId(XmlDictionaryWriter writer, string prefix, XmlDictionaryString localName, XmlDictionaryString ns, System.Xml.UniqueId id) { writer.WriteStartAttribute(prefix, localName, ns); writer.WriteValue(id); writer.WriteEndAttribute(); }
// Process the document set that was received private XmlDocument ProcessReceiveDocumentSet(XmlDocument xmlDocRequest, System.Xml.UniqueId messageID, MessageVersion msgVersion, out StringDictionary atnaParameterValues) { XmlDocument xmlDocResponse = null; Message registryMessage = null; XmlDocument xmlDocRegistryResponse = null; XDSHelper xdsHelper = null; XmlElement eltProvideAndRegDocSet = null; XmlNodeList nodeListExtrinsicObject = null; XmlNodeList nodeListDocument = null; XmlNode nodeSubmissionSet = null; XmlNode nodeExternalIdentifier = null; List <Document> docList = null; StringBuilder sbMetaData = null; string xpathExternalIdentifierDocument = @".//*[local-name()='ExtrinsicObject'][@id='$id$']/*[local-name()='ExternalIdentifier'][@identificationScheme='$identificationScheme$']"; string xpath = null; string entryUUID = null; string uniqueID = null; string eventOutcomeIndicator = "0"; atnaParameterValues = new StringDictionary(); try { xdsHelper = new XDSHelper(); xpathExternalIdentifierDocument = xpathExternalIdentifierDocument.Replace("$identificationScheme$", GlobalValues.XDSDocumentEntry_uniqueIdUUID); // get the root document element of the XML Document which is metadata plus MTOM encoded documents eltProvideAndRegDocSet = xmlDocRequest.DocumentElement; // get the list of nodes from the root document element that are ExtrinsicObject nodes nodeListExtrinsicObject = eltProvideAndRegDocSet.SelectNodes(".//*[local-name()='ExtrinsicObject']"); // get the list of nodes from the root doc element that are Document nodes nodeListDocument = eltProvideAndRegDocSet.SelectNodes(".//*[local-name()='Document']"); // get the Submission Set node from the document element nodeSubmissionSet = eltProvideAndRegDocSet.SelectSingleNode("//*[local-name()='SubmitObjectsRequest']/*[local-name()=\"RegistryObjectList\"]/*[local-name()='RegistryPackage']/*[local-name()='ExternalIdentifier'][@identificationScheme='urn:uuid:96fdda7c-d067-4183-912e-bf5ee74998a8']/@value"); //Proceed further only if any ExtrinsicObject Exists(with attachments) if (nodeListExtrinsicObject == null) { throw new Exception(); } // check each ExtrinsicObject node document Id and match with attached documents to see if anything is missing if (xdsHelper.IsMissingDocumentAttachment(eltProvideAndRegDocSet)) { throw new Exception(GlobalValues.CONST_ERROR_CODE_XDSMissingDocumentAttachment); } //if (repositoryLogic.IsMissingDocumentMetadata(nodeListExtrinsicObject, eltProvideAndRegDocSet)) if (xdsHelper.IsMissingDocumentMetadata(eltProvideAndRegDocSet)) { throw new Exception(GlobalValues.CONST_ERROR_CODE_XDSMissingDocumentMetadata); } // does each document have a unique id? if (xdsHelper.IsDuplicateUniqueID(eltProvideAndRegDocSet)) { throw new Exception(GlobalValues.CONST_ERROR_CODE_XDSRepositoryDuplicateUniqueIdInMessage); } // if we have metadata for each document and actual documents (this seems redundant with the earlier checks - refactor?) if (nodeListExtrinsicObject.Count > 0 && eltProvideAndRegDocSet.SelectNodes(@"//*[local-name()='Document']").Count > 0) { //No document OR Metadata is Missing // DocumentEntry object should be replaced by the new Document/Message object we want to use to carry this info // lstDocumentEntry = new List<DocumentEntry>(); sbMetaData = new StringBuilder(); int loopCount = 0; foreach (XmlNode node in nodeListExtrinsicObject) { // DocumentEntry objDocumentEntry = new DocumentEntry(); if (node.Attributes["mimeType"].Value == string.Empty) { throw new Exception(GlobalValues.CONST_ERROR_CODE_XDSRepositoryMetadataError); } // objDocumentEntry.MimeType = node.Attributes["mimeType"].Value; entryUUID = node.Attributes["id"].Value; xpath = xpathExternalIdentifierDocument.Replace("$id$", node.Attributes["id"].Value); nodeExternalIdentifier = eltProvideAndRegDocSet.SelectSingleNode(xpath); uniqueID = nodeExternalIdentifier.Attributes["value"].Value; if (string.IsNullOrEmpty(uniqueID)) { throw new Exception(GlobalValues.CONST_ERROR_CODE_XDSRepositoryMetadataError); } // objDocumentEntry.EntryUUID = entryUUID; // objDocumentEntry.UniqueID = uniqueID; // objDocumentEntry.Hash = xdsHelper.GetHashCode(xmlDocRequest, entryUUID); // objDocumentEntry.Content = xdsHelper.GetDocumentContentStream(xmlDocRequest, entryUUID); // objDocumentEntry.Size = (int)objDocumentEntry.Content.Length; // CP-ITI-419 string docHash = string.Empty; XmlNode docHashNode = eltProvideAndRegDocSet.SelectNodes("//*[local-name()='SubmitObjectsRequest']/*[local-name()=\"RegistryObjectList\"]/*[local-name()='ExtrinsicObject']/*[local-name()='Slot'][@name='hash']")[loopCount]; if (docHashNode != null) { docHash = docHashNode.InnerText.Trim(); } string docSize = string.Empty; XmlNode docSizeNode = eltProvideAndRegDocSet.SelectNodes("//*[local-name()='SubmitObjectsRequest']/*[local-name()=\"RegistryObjectList\"]/*[local-name()='ExtrinsicObject']/*[local-name()='Slot'][@name='size']")[loopCount]; if (docSizeNode != null) { docSize = docSizeNode.InnerText.Trim(); } // if ((!string.IsNullOrEmpty(docHash) && (docHash.ToLower() != objDocumentEntry.Hash.ToLower())) // || (!string.IsNullOrEmpty(docSize) && (Convert.ToInt32(docSize) != objDocumentEntry.Size))) { xmlDocResponse = CommonUtility.ConstructRegistryErrorResponse(GlobalValues.CONST_RESPONSE_STATUS_TYPE_FAILURE, string.Empty, "Size/hash of document not matching Metadata.", GlobalValues.CONST_ERROR_CODE_XDSRepositoryMetadataError, GlobalValues.CONST_SEVERITY_TYPE_ERROR, string.Empty); eventOutcomeIndicator = "8"; atnaParameterValues.Add("$EventIdentification.EventOutcomeIndicator$", eventOutcomeIndicator); return(xmlDocResponse); } // CP-ITI-419 // lstDocumentEntry.Add(objDocumentEntry); } } else { xmlDocRegistryResponse = new XmlDocument(); xmlDocRegistryResponse.Load(registryMessage.GetReaderAtBodyContents()); XmlNode errorList = xmlDocRegistryResponse.SelectSingleNode(@"//*[local-name()='RegistryError']"); string errorCode = null; if (errorList != null) { errorCode = errorList.Attributes["errorCode"].Value; } //Assign Registry Response to Repository Response xmlDocResponse = xmlDocRegistryResponse; } } catch { throw; } try { return(xmlDocResponse); } catch (Exception ex) { throw ex; } }
static internal PeerDictionaryHeader CreateMessageIdHeader(System.Xml.UniqueId messageId) { return(new PeerDictionaryHeader(XD.AddressingDictionary.MessageId, XD.PeerWireStringsDictionary.Namespace, messageId.ToString())); }
/// <summary> /// Attempts to remove all matching entries from cache. /// </summary> /// <param name="endpointId">The endpoint id for the entry to be removed.</param> /// <param name="contextId">The context Id for the entry to be removed.</param> public abstract void RemoveAll(string endpointId, System.Xml.UniqueId contextId);
public abstract void WriteUniqueIdText(UniqueId value);
public override void WriteValue(UniqueId value) { CheckAsync(); CoreWriter.WriteValue(value); }
public virtual void WriteValue(UniqueId value) { ArgumentNullException.ThrowIfNull(value); WriteString(value.ToString()); }
public override void WriteValue(System.Xml.UniqueId value) { this.effectiveWriter.WriteValue(value); }
private RelatesToHeader(System.Xml.UniqueId messageId, AddressingVersion version) : base(version) { this.messageId = messageId; }
public override void WriteUniqueIdText(UniqueId value) { }
public static string ToString(UniqueId value) { return(value.ToString()); }