Пример #1
0
            public override void WriteByte(byte value)
            {
                try
                {
                    if (_data != null)
                    {
                        // If we can fit the data into the first 254 bytes, write it to _data.
                        if (_pos < _data.Length)
                        {
                            _data[_pos++] = value;
                            return;
                        }

                        // Dummy size, until we know how big the stream really is and can patch the size.
                        _stream.WriteSize(255);
                        if (_pos > 0)
                        {
                            // Write the current contents of _data.
                            _stream.WriteByteSpan(_data.AsSpan(0, _pos));
                        }

                        _data = null;
                    }

                    // Write data passed by caller.
                    _stream.WriteByte(value);
                    _pos += 1;
                }
                catch (Exception ex)
                {
                    throw new IOException("could not write to stream", ex);
                }
            }
Пример #2
0
        /// <summary>Creates a new response frame that represents "success" with a void return value. The returned
        /// frame is complete and no additional data can be included in its payload.</summary>
        /// <param name="current">The current parameter holds decoded header data and other information about the
        /// request currently dispatched.</param>
        /// <returns>An <see cref="Ice.OutputStream"/> that holds the new frame.</returns>
        public static Ice.OutputStream CreateEmptyResponseFrame(Ice.Current current)
        {
            var ostr = new Ice.OutputStream(current.Adapter.Communicator, Ice.Util.CurrentProtocolEncoding);

            ostr.WriteBlob(Protocol.replyHdr);
            ostr.WriteInt(current.RequestId);
            ostr.WriteByte(ReplyStatus.replyOK);
            ostr.WriteEmptyEncapsulation(current.Encoding);
            return(ostr);
        }
Пример #3
0
        /// <summary>Starts a new response frame and the encapsulation in that frame. This frame encodes a "success"
        /// response.</summary>
        /// <param name="current">The current parameter holds decoded header data and other information about the
        /// request currently dispatched.</param>
        /// <param name="format">The Slice format (Compact or Sliced) used by the encapsulation.</param>
        /// <returns>An <see cref="Ice.OutputStream"/> that holds the new frame.</returns>
        public static Ice.OutputStream StartResponseFrame(Ice.Current current, Ice.FormatType?format = null)
        {
            var ostr = new Ice.OutputStream(current.Adapter.Communicator, Ice.Util.CurrentProtocolEncoding);

            ostr.WriteBlob(Protocol.replyHdr);
            ostr.WriteInt(current.RequestId);
            ostr.WriteByte(ReplyStatus.replyOK);
            ostr.StartEncapsulation(current.Encoding, format);
            return(ostr);
        }
Пример #4
0
        /// <summary>Starts a new response frame and the encapsulation in that frame. This frame encodes a "failure"
        /// response.</summary>
        /// <param name="current">The current parameter holds decoded header data and other information about the
        /// request currently dispatched.</param>
        /// <returns>An <see cref="Ice.OutputStream"/> that holds the new frame.</returns>
        public static Ice.OutputStream StartFailureResponseFrame(Ice.Current current)
        {
            var ostr = new Ice.OutputStream(current.Adapter.Communicator, Ice.Util.CurrentProtocolEncoding);

            ostr.WriteBlob(Protocol.replyHdr);
            ostr.WriteInt(current.RequestId);
            ostr.WriteByte(ReplyStatus.replyUserException);
            // Exceptions are always marshaled in the sliced format:
            ostr.StartEncapsulation(current.Encoding, FormatType.SlicedFormat);
            return(ostr);
        }
Пример #5
0
        ///<summary>Creates a response frame that represents "failure" and contains an exception. The returned frame is
        /// complete and no additional data can be included in its payload.</summary>
        /// <param name="exception">The exception to marshal into the frame.</param>
        /// <param name="current">The current parameter holds decoded header data and other information about the
        /// request currently dispatched.</param>
        /// <returns>An <see cref="Ice.OutputStream"/> that holds the new frame.</returns>
        public static Ice.OutputStream CreateFailureResponseFrame(System.Exception exception, Ice.Current current)
        {
            var ostr = new Ice.OutputStream(current.Adapter.Communicator, Ice.Util.CurrentProtocolEncoding);

            ostr.WriteBlob(Protocol.replyHdr);
            ostr.WriteInt(current.RequestId);

            try
            {
                throw exception;
            }
            catch (Ice.RequestFailedException ex)
            {
                if (ex.Id.Name == null || ex.Id.Name.Length == 0)
                {
                    ex.Id = current.Id;
                }

                if (ex.Facet == null || ex.Facet.Length == 0)
                {
                    ex.Facet = current.Facet;
                }

                if (ex.Operation == null || ex.Operation.Length == 0)
                {
                    ex.Operation = current.Operation;
                }

                if (ex is Ice.ObjectNotExistException)
                {
                    ostr.WriteByte(ReplyStatus.replyObjectNotExist);
                }
                else if (ex is Ice.FacetNotExistException)
                {
                    ostr.WriteByte(ReplyStatus.replyFacetNotExist);
                }
                else if (ex is Ice.OperationNotExistException)
                {
                    ostr.WriteByte(ReplyStatus.replyOperationNotExist);
                }
                else
                {
                    Debug.Assert(false);
                }
                ex.Id.IceWrite(ostr);

                // For compatibility with the old FacetPath.
                if (ex.Facet == null || ex.Facet.Length == 0)
                {
                    ostr.WriteStringSeq(Array.Empty <string>());
                }
                else
                {
                    string[] facetPath2 = { ex.Facet };
                    ostr.WriteStringSeq(facetPath2);
                }
                ostr.WriteString(ex.Operation);
            }
            catch (Ice.UnknownLocalException ex)
            {
                ostr.WriteByte(ReplyStatus.replyUnknownLocalException);
                ostr.WriteString(ex.Unknown);
            }
            catch (Ice.UnknownUserException ex)
            {
                ostr.WriteByte(ReplyStatus.replyUnknownUserException);
                ostr.WriteString(ex.Unknown);
            }
            catch (Ice.UnknownException ex)
            {
                ostr.WriteByte(ReplyStatus.replyUnknownException);
                ostr.WriteString(ex.Unknown);
            }
            catch (Ice.UserException ex)
            {
                ostr.WriteByte(ReplyStatus.replyUserException);
                // Exceptions are always marshaled in the sliced format:
                ostr.StartEncapsulation(current.Encoding, FormatType.SlicedFormat);
                ostr.WriteException(ex);
                ostr.EndEncapsulation();
            }
            catch (Ice.Exception ex)
            {
                ostr.WriteByte(ReplyStatus.replyUnknownLocalException);
                ostr.WriteString(ex.ice_id() + "\n" + ex.StackTrace);
            }
            catch (System.Exception ex)
            {
                ostr.WriteByte(ReplyStatus.replyUnknownException);
                ostr.WriteString(ex.ToString());
            }
            return(ostr);
        }
Пример #6
0
 public void ice_writeMembers(OutputStream ostr)
 {
     ostr.WriteByte(this.major);
     ostr.WriteByte(this.minor);
 }