コード例 #1
0
        /// <summary>
        /// Deserializes an XML-RPC response from a <see cref="System.Xml.XmlReader"/>.
        /// </summary>
        /// <param name="reader">the <see cref="System.Xml.XmlReader"/> to read</param>
        /// <param name="config">the context configuration</param>
        /// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
        /// <returns>a <see cref="LX.EasyWeb.XmlRpc.IXmlRpcResponse"/> read from the reader</returns>
        /// <exception cref="System.Xml.XmlException">failed parsing the response XML</exception>
        public IXmlRpcResponse ReadResponse(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            IXmlRpcResponse response = null;

            do
            {
                reader.Read();
                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (!String.IsNullOrEmpty(reader.NamespaceURI) || !XmlRpcSpec.METHOD_RESPONSE_TAG.Equals(reader.LocalName))
                    {
                        throw new XmlException("Expected root element methodResponse, got " + new XmlQualifiedName(reader.LocalName, reader.NamespaceURI));
                    }

                    RecursiveTypeSerializer.ReadToElement(reader);
                    if (String.IsNullOrEmpty(reader.NamespaceURI) && XmlRpcSpec.FAULT_TAG.Equals(reader.LocalName))
                    {
                        response = ReadFaultResponse(reader, config, typeSerializerFactory);
                    }
                    else if (String.IsNullOrEmpty(reader.NamespaceURI) && XmlRpcSpec.PARAMS_TAG.Equals(reader.LocalName))
                    {
                        response = ReadParamReponse(reader, config, typeSerializerFactory);
                    }
                }
            } while (!reader.EOF && (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.METHOD_RESPONSE_TAG.Equals(reader.LocalName)));

            if (response == null)
            {
                throw new XmlRpcException("Invalid XML-RPC response.");
            }

            return(response);
        }
コード例 #2
0
        private static IXmlRpcResponse ReadParamReponse(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            IList          list     = RecursiveTypeSerializer.ReadParams(reader, config, typeSerializerFactory);
            XmlRpcResponse response = new XmlRpcResponse(list.Count > 0 ? list[0] : null);

            return(response);
        }
コード例 #3
0
        /// <summary>
        /// Serializes an XML-RPC request to a <see cref="System.Xml.XmlWriter"/>.
        /// </summary>
        /// <param name="writer">the <see cref="System.Xml.XmlWriter"/> to write</param>
        /// <param name="request">the <see cref="LX.EasyWeb.XmlRpc.IXmlRpcRequest"/> to serialize</param>
        /// <param name="config">the context configuration</param>
        /// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
        /// <exception cref="System.Xml.XmlException">failed writing the request XML</exception>
        public void WriteRequest(XmlWriter writer, IXmlRpcRequest request, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            writer.WriteStartDocument();
            writer.WriteStartElement(XmlRpcSpec.METHOD_CALL_TAG);

            writer.WriteElementString(XmlRpcSpec.METHOD_NAME_TAG, request.MethodName);
            RecursiveTypeSerializer.WriteParams(writer, config, typeSerializerFactory, request.Parameters);

            writer.WriteEndElement();
            writer.WriteEndDocument();
        }
コード例 #4
0
        /// <summary>
        /// Serializes an XML-RPC response to a <see cref="System.Xml.XmlWriter"/>.
        /// </summary>
        /// <param name="writer">the <see cref="System.Xml.XmlWriter"/> to write</param>
        /// <param name="response">the <see cref="LX.EasyWeb.XmlRpc.IXmlRpcResponse"/> to serialize</param>
        /// <param name="config">the context configuration</param>
        /// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
        /// <exception cref="System.Xml.XmlException">failed writing the response XML</exception>
        public void WriteResponse(XmlWriter writer, IXmlRpcResponse response, IXmlRpcStreamRequestConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            writer.WriteStartDocument();
            writer.WriteStartElement(XmlRpcSpec.METHOD_RESPONSE_TAG);

            if (response.Fault == null)
            {
                RecursiveTypeSerializer.WriteParams(writer, config, typeSerializerFactory, response.Result);
            }
            else
            {
                WriteFaultResponse(writer, response.Fault, config, typeSerializerFactory);
            }

            writer.WriteEndElement();
            writer.WriteEndDocument();
        }
コード例 #5
0
        private static void WriteFaultResponse(XmlWriter writer, IXmlRpcFault fault, IXmlRpcStreamRequestConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            writer.WriteStartElement(XmlRpcSpec.FAULT_TAG);

            ArrayList nestvedObjs = new ArrayList();

            if (config != null && config.EnabledForExceptions)
            {
                Hashtable   ht  = new Hashtable(3);
                XmlRpcFault xpf = fault as XmlRpcFault;
                ht.Add(XmlRpcSpec.FAULT_CODE_TAG, fault.FaultCode);
                ht.Add(XmlRpcSpec.FAULT_STRING_TAG, fault.FaultString);
                ht.Add("faultCause", fault is XmlRpcFault ? ((XmlRpcFault)fault).Exception : null);
                RecursiveTypeSerializer.WriteValue(writer, ht, config, typeSerializerFactory, nestvedObjs);
            }
            else
            {
                RecursiveTypeSerializer.WriteValue(writer, fault, config, typeSerializerFactory, nestvedObjs);
            }

            writer.WriteEndElement();
        }
コード例 #6
0
        private static IXmlRpcResponse ReadFaultResponse(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            IDictionary dict = null;

            do
            {
                reader.Read();
                if (reader.NodeType == XmlNodeType.Element)
                {
                    dict = (IDictionary)RecursiveTypeSerializer.ReadValue(reader, config, typeSerializerFactory);
                }
            } while (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.FAULT_TAG.Equals(reader.LocalName));

            if (dict != null)
            {
                if (!dict.Contains(XmlRpcSpec.FAULT_CODE_TAG))
                {
                    throw new XmlRpcException("Invalid XML-RPC response: missing fault code");
                }
                if (!dict.Contains(XmlRpcSpec.FAULT_STRING_TAG))
                {
                    throw new XmlRpcException("Invalid XML-RPC response: missing fault string");
                }

                try
                {
                    XmlRpcFault    fault    = new XmlRpcFault((Int32)dict[XmlRpcSpec.FAULT_CODE_TAG], (String)dict[XmlRpcSpec.FAULT_STRING_TAG]);
                    XmlRpcResponse response = new XmlRpcResponse(null);
                    response.Fault = fault;
                    return(response);
                }
                catch (Exception ex)
                {
                    throw new XmlRpcException("Invalid XML-RPC response: " + ex.Message);
                }
            }

            throw new XmlRpcException("Invalid XML-RPC response.");
        }
コード例 #7
0
        /// <summary>
        /// Deserializes an XML-RPC request from a <see cref="System.Xml.XmlReader"/>.
        /// </summary>
        /// <param name="reader">the <see cref="System.Xml.XmlReader"/> to read</param>
        /// <param name="config">the context configuration</param>
        /// <param name="typeSerializerFactory">the <see cref="LX.EasyWeb.XmlRpc.Serializer.ITypeSerializerFactory"/> to get type serializers</param>
        /// <returns>a <see cref="LX.EasyWeb.XmlRpc.IXmlRpcRequest"/> read from the reader</returns>
        /// <exception cref="System.Xml.XmlException">failed parsing the request XML</exception>
        public IXmlRpcRequest ReadRequest(XmlReader reader, IXmlRpcStreamConfig config, ITypeSerializerFactory typeSerializerFactory)
        {
            String methodName = null;
            IList  args       = null;

            do
            {
                reader.Read();
                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (!String.IsNullOrEmpty(reader.NamespaceURI) || !XmlRpcSpec.METHOD_CALL_TAG.Equals(reader.LocalName))
                    {
                        throw new XmlException("Expected root element methodCall, got " + new XmlQualifiedName(reader.LocalName, reader.NamespaceURI));
                    }

                    RecursiveTypeSerializer.ReadToElement(reader);
                    methodName = ReadMethodName(reader);
                    RecursiveTypeSerializer.ReadToElement(reader);
                    args = RecursiveTypeSerializer.ReadParams(reader, config, typeSerializerFactory);
                }
            } while (!reader.EOF && (reader.NodeType != XmlNodeType.EndElement || !XmlRpcSpec.METHOD_CALL_TAG.Equals(reader.LocalName)));
            return(new XmlRpcRequest(methodName, args == null ? null : ToArray(args)));
        }
コード例 #8
0
 private static String ReadMethodName(XmlReader reader)
 {
     RecursiveTypeSerializer.CheckTag(reader, XmlRpcSpec.METHOD_NAME_TAG);
     return(reader.ReadElementString());
 }