private Exception ReadException() { switch (ReplyStatus) { case ReplyStatus.UserException: { var istr = new InputStream(_communicator, Payload, 1); istr.StartEncapsulation(); RemoteException ex = istr.ReadException(); istr.EndEncapsulation(); return(ex); } case ReplyStatus.ObjectNotExistException: case ReplyStatus.FacetNotExistException: case ReplyStatus.OperationNotExistException: { return(ReadDispatchException()); } default: { Debug.Assert(ReplyStatus == ReplyStatus.UnknownException || ReplyStatus == ReplyStatus.UnknownLocalException || ReplyStatus == ReplyStatus.UnknownUserException); return(ReadUnhandledException()); } } }
/// <summary>Writes a remote exception to the stream.</summary> /// <param name="v">The remote exception to write.</param> public void WriteException(RemoteException v) { Debug.Assert(InEncapsulation && _current == null); Debug.Assert(_format == FormatType.Sliced); Debug.Assert(!(v is ObjectNotExistException)); // temporary Debug.Assert(!(v is OperationNotExistException)); // temporary Debug.Assert(!(v is UnhandledException)); // temporary Push(InstanceType.Exception); v.Write(this); Pop(null); }
/// <summary>Reads a remote exception from the stream.</summary> /// <returns>The remote exception.</returns> public RemoteException ReadException() { Push(InstanceType.Exception); Debug.Assert(_current != null); // Read the first slice header, and exception's type ID cannot be null. string typeId = ReadSliceHeaderIntoCurrent() !; ReadIndirectionTableIntoCurrent(); // we read the indirection table immediately while (true) { RemoteException?remoteEx = null; Type? type = Communicator.ResolveClass(typeId); if (type != null) { try { remoteEx = (RemoteException?)Activator.CreateInstance(type); } catch (Exception ex) { throw new InvalidDataException( @$ "failed to create an instance of type `{type.Name }' while reading a remote exception with type ID `{typeId}'", ex); } } // We found the exception. if (remoteEx != null) { remoteEx.ConvertToUnhandled = true; remoteEx.Read(this); Pop(null); return(remoteEx); } // Slice off what we don't understand. SkipSlice(); if ((_current.SliceFlags & EncodingDefinitions.SliceFlags.IsLastSlice) != 0) { // Create and throw a plain RemoteException with the SlicedData. Debug.Assert(SlicedData != null); remoteEx = new RemoteException(SlicedData.Value); remoteEx.ConvertToUnhandled = true; return(remoteEx); } typeId = ReadSliceHeaderIntoCurrent() !; ReadIndirectionTableIntoCurrent(); }
/// <summary>Creates a response frame that represents "failure" and contains an exception.</summary> /// <param name="current">The current parameter holds decoded header data and other information about the /// request for which this constructor creates a response.</param> /// <param name="exception">The exception to store into the frame's payload.</param> public OutgoingResponseFrame(Current current, RemoteException exception) : this(current) { if (exception is RequestFailedException requestFailedException) { if (requestFailedException is DispatchException dispatchException) { // TODO: the null checks are necessary due to the way we unmarshal the exception through reflection. if (dispatchException.Id.Name == null || dispatchException.Id.Name.Length == 0) { dispatchException.Id = current.Id; } if (dispatchException.Facet == null || dispatchException.Facet.Length == 0) { dispatchException.Facet = current.Facet; } if (dispatchException.Operation == null || dispatchException.Operation.Length == 0) { dispatchException.Operation = current.Operation; } ReplyStatus replyStatus = default; if (dispatchException is ObjectNotExistException) { replyStatus = ReplyStatus.ObjectNotExistException; } else if (dispatchException is OperationNotExistException) { replyStatus = ReplyStatus.OperationNotExistException; } else { Debug.Assert(false); } WriteByte((byte)replyStatus); dispatchException.Id.IceWrite(this); // For compatibility with the old FacetPath. if (dispatchException.Facet == null || dispatchException.Facet.Length == 0) { WriteStringSeq(Array.Empty <string>()); } else { WriteStringSeq(new string[] { dispatchException.Facet }); } WriteString(dispatchException.Operation); } else { WriteByte((byte)ReplyStatus.UnknownLocalException); if (requestFailedException.IceMessage.Length > 0) { WriteString(requestFailedException.IceMessage); } else { WriteString(requestFailedException.ToString()); } } } else { WriteByte((byte)ReplyStatus.UserException); StartEncapsulation(current.Encoding, FormatType.SlicedFormat); WriteException(exception); EndEncapsulation(); } }