public bool Parse(ProcessDescription processDescription) { string responseDocumentParam = Utils.DecodeURI(Utils.GetParameter("ResponseDocument")); string rawDataOutputParam = Utils.DecodeURI(Utils.GetParameter("RawDataOutput")); if (!String.IsNullOrEmpty(responseDocumentParam)) { if (!String.IsNullOrEmpty(rawDataOutputParam)) { throw new ExceptionReport("Only one kind of ResponseForm is allowed, but ResponseDocument and RawDataOutput were found!", ExceptionCode.InvalidParameterValue, "ResponseForm"); } responseDocument = new ResponseDocumentType("wps:ResponseDocument"); responseDocument.lineage = Boolean.Parse(Utils.GetParameter("lineage", "false")); responseDocument.status = Boolean.Parse(Utils.GetParameter("status", "false")); responseDocument.storeExecuteResponse = Boolean.Parse(Utils.GetParameter("storeExecuteResponse", "false")); responseDocument.Parse(responseDocumentParam, processDescription); } else if (!String.IsNullOrEmpty(rawDataOutputParam)) { outputDefinition = new OutputDefinitionType("wps:RawDataOutput"); outputDefinition.Parse(rawDataOutputParam, processDescription); } else { // include all responses because no requested identifier was provided responseDocument = new ResponseDocumentType("wps:ResponseDocument"); responseDocument.Outputs.AddRange(processDescription.GetProcessOutputParameters()); responseDocument.lineage = Boolean.Parse(Utils.DecodeURI(Utils.GetParameter("lineage", "false"))); responseDocument.status = Boolean.Parse(Utils.DecodeURI(Utils.GetParameter("status", "false"))); responseDocument.storeExecuteResponse = Boolean.Parse(Utils.DecodeURI(Utils.GetParameter("storeExecuteResponse", "false"))); } return(true); }
public static ProcessDescription GetProcessDescription(string processId) { AppDomain mainDomain = AppDomain.CurrentDomain; // A secondary operation domain has to be used so that the assemblies can be loaded/unloaded, as the function Assembly AppDomain operationDomain = null; ProcessDescription result = null; try { operationDomain = Utils.CreateDomain(); Utils.AssemblyLoader assemblyLoader = Utils.AssemblyLoader.Create(operationDomain); assemblyLoader.Load(Utils.MapPath(Global.ProcessesBinPath + processId + ".dll")); result = (ProcessDescription)assemblyLoader.ExecuteMethod("WPSProcess." + processId, "GetDescription", null, null); AppDomain.Unload(operationDomain); } catch (Exception /*e*/) { if (operationDomain != null) { AppDomain.Unload(operationDomain); } throw new ExceptionReport("Unable to retrieve the description of the process '" + processId + "'.\nEnsure that the Identifier parameter really is the name of a service proposed on this server. The name is case dependent. The name of the available processes can be get with the GetCapabilities operation.", ExceptionCode.InvalidParameterValue, "Identifier"); } return(result); }
public ProcessData(ProcessReturnValue executeResponseValue, ProcessDescription processDescription, AppDomain parentAppDomain, AppDomain processAppDompain, int processProgress, Exception processError = null) { this.ExecuteResponseValue = executeResponseValue; this.ParentApplicationDomain = parentAppDomain; this.ProcessDescription = processDescription; this.Error = processError; this.ProcessApplicationDomain = processAppDompain; this.Progress = processProgress; }
public static XmlDocument Run(string[] processes, string Language) { StringBuilder retString = new StringBuilder(); retString.Append(Global.XmlHeader + "<wps:ProcessDescriptions " + Global.WPSServiceVersion + " xml:lang='" + Language + "' " + Global.WPSXmlSchemas + " " + Global.WPSDescribeProcessSchema + ">"); // On identifier is ALL, catch all the available processes if (processes.Length == 1 && Utils.StrICmp(processes[0], "ALL")) { ProcessDescription[] processDescriptions = GetCapabilities.getAvailableProcesses(); foreach (ProcessDescription process in processDescriptions) { retString.Append(process.GetProcessDescriptionDocument()); } } else { ExceptionReport exception = null; // Loop through all the processes and get process description foreach (string processId in processes) { try { retString.Append(ProcessDescription.GetProcessDescription(processId).GetProcessDescriptionDocument()); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } } if (exception != null) { throw exception; } } retString.Append("</wps:ProcessDescriptions>"); try { XmlDocument doc = new XmlDocument(); doc.LoadXml(retString.ToString()); HttpContext.Current.Response.StatusCode = 200; return(doc); } catch (XmlException ex) { throw new ExceptionReport("Unable to generate the description document. Contact the administrator." + ex.ToString()); } }
public override bool Parse(string str, ProcessDescription processDescription) { if (String.IsNullOrEmpty(str)) { return(false); } string[] tokens = str.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); ExceptionReport exception = null; foreach (string param in tokens) { string[] kv = param.Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries); if (kv.Length > 0) { OutputData output = processDescription.GetProcessOutputParameter(kv[0]); if (output != null) { OutputData myoutput = output.Clone(); try { myoutput.Parse(param); Outputs.Add(myoutput); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } } else { exception = new ExceptionReport(exception, "The output " + kv[0] + " is not a valid output for the process " + processDescription.Identifier, ExceptionCode.InvalidParameterValue, "responseDocument"); } } } if (exception != null) { throw exception; } return(tokens.Length != 0); }
public override bool Parse(string str, ProcessDescription processDescription) { if (String.IsNullOrEmpty(str)) { return(false); } string[] tokens = str.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); if (tokens.Length != 1) { throw new ExceptionReport("One identifier is mandatory when requesting a raw data output but " + tokens.Length + " were found.", ExceptionCode.InvalidParameterValue, "RawDataOutput"); } string[] kv = str.Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries); if (kv.Length > 0) { OutputData outputData = processDescription.GetProcessOutputParameter(kv[0]); if (outputData == null) { throw new ExceptionReport(String.Format("The output {0} is not a valid output for the process {1}", kv[0], processDescription.Identifier), ExceptionCode.InvalidParameterValue, "rawDataOutput"); } ComplexOutput output = outputData.asComplexOutput(); if (output == null) { throw new ExceptionReport(String.Format("Only ComplexOutputs can be requested as rawDataOutput but {0} is a {1}", kv[0], outputData.GetType().ToString()), ExceptionCode.InvalidParameterValue, "rawDataOutput"); } Identifier = kv[0]; Format = output.Format; // default format Format.ParseValue(str); if (output.Formats.Find(delegate(ComplexFormat cf) { return(cf.Equals(Format)); }) == null) { throw new ExceptionReport(string.Format("Requested format for the output {0} is not supported", kv[0]), ExceptionCode.InvalidParameterValue, kv[0]); } } return(false); }
public override bool Parse(XmlNode node, ProcessDescription processDescription) { if (node == null) { return(false); } XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(node.OwnerDocument); XmlNodeList childs = node.SelectNodes("ows:Identifier", nsmgr); if (childs.Count != 1) { throw new ExceptionReport("One identifier is mandatory when requesting a raw data output but " + childs.Count + " were found.", ExceptionCode.InvalidParameterValue, "wps:RawDataOutput/ows:Identifier"); } Identifier = childs[0].InnerText; OutputData outputData = processDescription.GetProcessOutputParameter(Identifier); if (outputData == null) { throw new ExceptionReport(String.Format("The output {0} is not a valid output for the process {1}", Identifier, processDescription.Identifier), ExceptionCode.InvalidParameterValue, "rawDataOutput"); } ComplexOutput processOutput = outputData.asComplexOutput(); if (processOutput == null) { throw new ExceptionReport(String.Format("Only ComplexOutputs can be requested as rawDataOutput but {0} is a {1}", Identifier, outputData.GetType().Name), ExceptionCode.InvalidParameterValue, "rawDataOutput"); } Format = processOutput.Format; Format.ParseValue(node); return(true); }
public override bool Parse(XmlNode node, ProcessDescription processDescription) { if (node == null) { // include all responses because no requested identifier was provided responseDocument = new ResponseDocumentType("wps:ResponseDocument"); responseDocument.Outputs.AddRange(processDescription.GetProcessOutputParameters()); return(true); } // Create an XmlNamespaceManager for resolving namespaces. XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(node.OwnerDocument); XmlNode rawDataOutputNode = node.SelectSingleNode("wps:RawDataOutput", nsmgr); XmlNode responseDocNode = node.SelectSingleNode("wps:ResponseDocument", nsmgr); if (responseDocNode != null) { if (rawDataOutputNode != null) { throw new ExceptionReport("Only one kind of ResponseForm is allowed, but ResponseDocument and RawDataOutput were found!", ExceptionCode.InvalidParameterValue, "ResponseForm"); } responseDocument = new ResponseDocumentType("wps:ResponseDocument"); return(responseDocument.Parse(responseDocNode, processDescription)); } else if (rawDataOutputNode != null) { outputDefinition = new OutputDefinitionType("wps:RawDataOutput"); return(outputDefinition.Parse(rawDataOutputNode, processDescription)); } else { throw new ExceptionReport("A ResponseForm is provided, but neither ResponseDocument nor RawDataOutput element was found!", ExceptionCode.MissingParameterValue, "wps:ResponseForm"); } }
// Return the available processes (for which a dll is present and an xml description file is associated) public static ProcessDescription[] getAvailableProcesses() { // Search all the DLL files could contain process operations string[] processDLLPath; try { processDLLPath = Directory.GetFiles(Utils.MapPath(Global.ProcessesBinPath), "*.dll"); } catch { throw new ExceptionReport("Unable to retrieve the list of assemblies containing the processes available on the server. Contact the administrator."); } // Retrieve the name of all the available processes List <string> processIdList = new List <string>(); for (int i = 0; i < processDLLPath.Length; i++) { string processDllName = processDLLPath[i].Substring(processDLLPath[i].LastIndexOf("\\") + 1, processDLLPath[i].IndexOf(".dll") - processDLLPath[i].LastIndexOf("\\") - 1); processIdList.Add(processDllName); } List <ProcessDescription> processes = new List <ProcessDescription>(); foreach (string processId in processIdList) { try { processes.Add(ProcessDescription.GetProcessDescription(processId)); } catch { } } return(processes.ToArray()); }
public ProcessDescription GetDescription() { ProcessDescription process = new ProcessDescription("Calculator", "Calculator", "Basic operations through WPS", "1.1"); LiteralInput oper = new LiteralInput("operator", "operator", "abstract operator", "string", "add"); oper.AllowedValues.AddRange(new string[] { "add", "sub", "mult", "div"}); process.inputs.Add(oper); process.inputs.Add(new ComplexInput("a", "operand a", "abstract a", new ComplexFormat("text/xml", "uf8", "myschema.xsd"))); process.inputs.Add(new ComplexInput("b", "operand b", "abstract b", new ComplexFormat("text/xml", "uf8", "myschema.xsd"))); process.outputs.Add(new ComplexOutput("result", "result of operation as file", "raw abstract result of operation as file", new ComplexFormat("text/xml", "utf8", "myschema.xsd"))); return process; }
public override bool Parse(XmlNode node, ProcessDescription processDescription) { if (node == null) { return(false); } // Create an XmlNamespaceManager for resolving namespaces. XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(node.OwnerDocument); lineage = Boolean.Parse(Utils.GetXmlAttributesValue(node, "lineage", "false")); status = Boolean.Parse(Utils.GetXmlAttributesValue(node, "status", "false")); storeExecuteResponse = Boolean.Parse(Utils.GetXmlAttributesValue(node, "storeExecuteResponse", "false")); XmlNodeList outputs = node.SelectNodes("wps:Output", nsmgr); if (outputs.Count == 0) { throw new ExceptionReport(String.Format("No 'wps:Output' node was found inside the 'wps:ResponseDocument' node for the process '{0}'. Please check your request.", processDescription.Identifier), ExceptionCode.MissingParameterValue, processDescription.Identifier); } ExceptionReport exception = null; foreach (XmlNode output in outputs) { XmlNode id = output.SelectSingleNode("ows:Identifier", nsmgr); XmlNode abst = output.SelectSingleNode("ows:Abstract", nsmgr); XmlNode title = output.SelectSingleNode("ows:Title", nsmgr); string identifier = id.InnerText; string titleStr = title != null ? title.InnerText : ""; string abstStr = abst != null ? abst.InnerText : ""; OutputData processOutput = processDescription.GetProcessOutputParameter(identifier); if (processOutput != null) { OutputData myoutput = processOutput.Clone(); myoutput.Title = titleStr; myoutput.Abstract = abstStr; myoutput.asReference = Boolean.Parse(Utils.GetXmlAttributesValue(output, "asReference", "false")); if (myoutput.asReference && !processDescription.storeSupported) { exception = new ExceptionReport(exception, String.Format("The storage of response is not supported for the process {0} but is requested for the output {1}.", processDescription.Identifier, identifier), ExceptionCode.StorageNotSupported); } try { myoutput.Parse(output); Outputs.Add(myoutput); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } } else { exception = new ExceptionReport(exception, String.Format("The output {0} is not a valid output for the process {1}", identifier, processDescription.Identifier), ExceptionCode.InvalidParameterValue, "responseDocument"); } } if (exception != null) { throw exception; } return(true); }
public virtual bool Parse(XmlNode node, ProcessDescription processDescription) { return(false); }
public virtual bool Parse(string str, ProcessDescription processDescription) { return false; }
public virtual bool Parse(string str, ProcessDescription processDescription) { return(false); }
public bool Parse(ProcessDescription processDescription) { string responseDocumentParam = Utils.DecodeURI(Utils.GetParameter("ResponseDocument")); string rawDataOutputParam = Utils.DecodeURI(Utils.GetParameter("RawDataOutput")); if (!String.IsNullOrEmpty(responseDocumentParam)) { if (!String.IsNullOrEmpty(rawDataOutputParam)) throw new ExceptionReport("Only one kind of ResponseForm is allowed, but ResponseDocument and RawDataOutput were found!", ExceptionCode.InvalidParameterValue, "ResponseForm"); responseDocument = new ResponseDocumentType("wps:ResponseDocument"); responseDocument.lineage = Boolean.Parse(Utils.GetParameter("lineage", "false")); responseDocument.status = Boolean.Parse(Utils.GetParameter("status", "false")); responseDocument.storeExecuteResponse = Boolean.Parse(Utils.GetParameter("storeExecuteResponse", "false")); responseDocument.Parse(responseDocumentParam, processDescription); } else if (!String.IsNullOrEmpty(rawDataOutputParam)) { outputDefinition = new OutputDefinitionType("wps:RawDataOutput"); outputDefinition.Parse(rawDataOutputParam, processDescription); } else { // include all responses because no requested identifier was provided responseDocument = new ResponseDocumentType("wps:ResponseDocument"); responseDocument.Outputs.AddRange(processDescription.GetProcessOutputParameters()); responseDocument.lineage = Boolean.Parse(Utils.DecodeURI(Utils.GetParameter("lineage", "false"))); responseDocument.status = Boolean.Parse(Utils.DecodeURI(Utils.GetParameter("status", "false"))); responseDocument.storeExecuteResponse = Boolean.Parse(Utils.DecodeURI(Utils.GetParameter("storeExecuteResponse", "false"))); } return true; }
public virtual bool Parse(XmlNode node, ProcessDescription processDescription) { return false; }
public override bool Parse(string str, ProcessDescription processDescription) { if (String.IsNullOrEmpty(str)) return false; string[] tokens = str.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); ExceptionReport exception = null; foreach (string param in tokens) { string[] kv = param.Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries); if (kv.Length > 0) { OutputData output = processDescription.GetProcessOutputParameter(kv[0]); if (output != null) { OutputData myoutput = output.Clone(); try { myoutput.Parse(param); Outputs.Add(myoutput); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } } else { exception = new ExceptionReport(exception, "The output " + kv[0] + " is not a valid output for the process " + processDescription.Identifier, ExceptionCode.InvalidParameterValue, "responseDocument"); } } } if (exception != null) throw exception; return tokens.Length != 0; }
public override bool Parse(XmlNode node, ProcessDescription processDescription) { if (node == null) { // include all responses because no requested identifier was provided responseDocument = new ResponseDocumentType("wps:ResponseDocument"); responseDocument.Outputs.AddRange(processDescription.GetProcessOutputParameters()); return true; } // Create an XmlNamespaceManager for resolving namespaces. XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(node.OwnerDocument); XmlNode rawDataOutputNode = node.SelectSingleNode("wps:RawDataOutput", nsmgr); XmlNode responseDocNode = node.SelectSingleNode("wps:ResponseDocument", nsmgr); if (responseDocNode != null) { if (rawDataOutputNode != null) throw new ExceptionReport("Only one kind of ResponseForm is allowed, but ResponseDocument and RawDataOutput were found!", ExceptionCode.InvalidParameterValue, "ResponseForm"); responseDocument = new ResponseDocumentType("wps:ResponseDocument"); return responseDocument.Parse(responseDocNode, processDescription); } else if (rawDataOutputNode != null) { outputDefinition = new OutputDefinitionType("wps:RawDataOutput"); return outputDefinition.Parse(rawDataOutputNode, processDescription); } else throw new ExceptionReport("A ResponseForm is provided, but neither ResponseDocument nor RawDataOutput element was found!", ExceptionCode.MissingParameterValue, "wps:ResponseForm"); }
private static XmlDocument FormatResponseMessage(ProcessDescription processDescription, ProcessInputParams args, ResponseFormType responseForm, ProcessReturnValue result, ExceptionReport exception, string xmlHeader = "") { // Format the response message StringBuilder retString = new StringBuilder(); retString.Append(xmlHeader); /* if (responseForm.responseDocument.status) {*/ retString.Append("<wps:Status creationTime=\"" + System.DateTime.Now.ToString("s") + "\">"); if (result.status == ProcessState.Succeeded) { retString.Append("<wps:ProcessSucceeded>" + (result.statusMessage != "" ? result.statusMessage : "Process completed successfully.") + "</wps:ProcessSucceeded>"); //TODO: retiré 'wps:' } else if (result.status == ProcessState.Accepted) { retString.Append("<wps:ProcessAccepted>" + (result.statusMessage != "" ? result.statusMessage : "Process has been accepted and is pending execution.") + "</wps:ProcessAccepted>"); //TODO: retiré 'wps:' } else if (result.status == ProcessState.Paused) { retString.Append("<wps:ProcessPaused percentCompleted=\""+result.percentageCompleted+"\" >" + (result.statusMessage != "" ? result.statusMessage : "Process is paused.") + "</wps:ProcessPaused>"); } else if (result.status == ProcessState.Started) { retString.Append("<wps:ProcessStarted percentCompleted=\""+result.percentageCompleted+"\" >" + (result.statusMessage != "" ? result.statusMessage : "Process is running.") + "</wps:ProcessStarted>"); } else if (result.status == ProcessState.Failed) { retString.Append("<wps:ProcessFailed>" + (exception != null ? exception.GetReport().InnerText + " - " + result.statusMessage : new ExceptionReport("Failed to execute WPS process : "+result.statusMessage, ExceptionCode.NoApplicableCode).GetReport().InnerText) + "</wps:ProcessFailed>"); } retString.Append("</wps:Status>"); // } if (responseForm.responseDocument.lineage) { retString.Append("<wps:DataInputs>"); foreach (KeyValuePair<string, InputData[]> ent in args.parameters) foreach (InputData processInputParam in ent.Value) retString.Append(processInputParam.GetXmlValue()); retString.Append("</wps:DataInputs>"); retString.Append("<wps:OutputDefinitions>"); // TODO do not retrieve output from return values (may not be the same as request) //foreach (OutputData processOutputParam in result.returnValues) foreach (OutputData processOutputParam in responseForm.responseDocument.Outputs) retString.Append(processOutputParam.GetXmlDescription()); retString.Append("</wps:OutputDefinitions>"); } if (result.returnValues.Count > 0) { retString.Append("<wps:ProcessOutputs>"); foreach (OutputData outputData in result.returnValues) retString.Append(outputData.GetXmlValue()); retString.Append("</wps:ProcessOutputs>"); } retString.Append("</wps:ExecuteResponse>"); try { XmlDocument doc = new XmlDocument(); doc.LoadXml(retString.ToString()); return doc; } catch (Exception e) { throw new ExceptionReport("The service execution has encountered an error while formatting the result stream. Check the parameters values.\n" + e.ToString()); } }
public override bool Parse(XmlNode node, ProcessDescription processDescription) { if (node == null) return false; // Create an XmlNamespaceManager for resolving namespaces. XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(node.OwnerDocument); lineage = Boolean.Parse(Utils.GetXmlAttributesValue(node, "lineage", "false")); status = Boolean.Parse(Utils.GetXmlAttributesValue(node, "status", "false")); storeExecuteResponse = Boolean.Parse(Utils.GetXmlAttributesValue(node, "storeExecuteResponse", "false")); XmlNodeList outputs = node.SelectNodes("wps:Output", nsmgr); if (outputs.Count == 0) throw new ExceptionReport(String.Format("No 'wps:Output' node was found inside the 'wps:ResponseDocument' node for the process '{0}'. Please check your request.", processDescription.Identifier), ExceptionCode.MissingParameterValue, processDescription.Identifier); ExceptionReport exception = null; foreach (XmlNode output in outputs) { XmlNode id = output.SelectSingleNode("ows:Identifier", nsmgr); XmlNode abst = output.SelectSingleNode("ows:Abstract", nsmgr); XmlNode title = output.SelectSingleNode("ows:Title", nsmgr); string identifier = id.InnerText; string titleStr = title != null ? title.InnerText : ""; string abstStr = abst != null ? abst.InnerText : ""; OutputData processOutput = processDescription.GetProcessOutputParameter(identifier); if (processOutput != null) { OutputData myoutput = processOutput.Clone(); myoutput.Title = titleStr; myoutput.Abstract = abstStr; myoutput.asReference = Boolean.Parse(Utils.GetXmlAttributesValue(output, "asReference", "false")); if (myoutput.asReference && !processDescription.storeSupported) exception = new ExceptionReport(exception, String.Format("The storage of response is not supported for the process {0} but is requested for the output {1}.", processDescription.Identifier, identifier), ExceptionCode.StorageNotSupported); try { myoutput.Parse(output); Outputs.Add(myoutput); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } } else { exception = new ExceptionReport(exception, String.Format("The output {0} is not a valid output for the process {1}", identifier, processDescription.Identifier), ExceptionCode.InvalidParameterValue, "responseDocument"); } } if (exception != null) throw exception; return true; }
private static XmlDocument FormatResponseMessage(ProcessDescription processDescription, ProcessInputParams args, ResponseFormType responseForm, ProcessReturnValue result, ExceptionReport exception, string xmlHeader = "") { // Format the response message StringBuilder retString = new StringBuilder(); retString.Append(xmlHeader); /* * if (responseForm.responseDocument.status) * {*/ retString.Append("<wps:Status creationTime=\"" + System.DateTime.Now.ToString("s") + "\">"); if (result.status == ProcessState.Succeeded) { retString.Append("<wps:ProcessSucceeded>" + (result.statusMessage != "" ? result.statusMessage : "Process completed successfully.") + "</wps:ProcessSucceeded>"); //TODO: retiré 'wps:' } else if (result.status == ProcessState.Accepted) { retString.Append("<wps:ProcessAccepted>" + (result.statusMessage != "" ? result.statusMessage : "Process has been accepted and is pending execution.") + "</wps:ProcessAccepted>"); //TODO: retiré 'wps:' } else if (result.status == ProcessState.Paused) { retString.Append("<wps:ProcessPaused percentCompleted=\"" + result.percentageCompleted + "\" >" + (result.statusMessage != "" ? result.statusMessage : "Process is paused.") + "</wps:ProcessPaused>"); } else if (result.status == ProcessState.Started) { retString.Append("<wps:ProcessStarted percentCompleted=\"" + result.percentageCompleted + "\" >" + (result.statusMessage != "" ? result.statusMessage : "Process is running.") + "</wps:ProcessStarted>"); } else if (result.status == ProcessState.Failed) { retString.Append("<wps:ProcessFailed>" + (exception != null ? exception.GetReport().InnerText + " - " + result.statusMessage : new ExceptionReport("Failed to execute WPS process : " + result.statusMessage, ExceptionCode.NoApplicableCode).GetReport().InnerText) + "</wps:ProcessFailed>"); } retString.Append("</wps:Status>"); // } if (responseForm.responseDocument.lineage) { retString.Append("<wps:DataInputs>"); foreach (KeyValuePair <string, InputData[]> ent in args.parameters) { foreach (InputData processInputParam in ent.Value) { retString.Append(processInputParam.GetXmlValue()); } } retString.Append("</wps:DataInputs>"); retString.Append("<wps:OutputDefinitions>"); // TODO do not retrieve output from return values (may not be the same as request) //foreach (OutputData processOutputParam in result.returnValues) foreach (OutputData processOutputParam in responseForm.responseDocument.Outputs) { retString.Append(processOutputParam.GetXmlDescription()); } retString.Append("</wps:OutputDefinitions>"); } if (result.returnValues.Count > 0) { retString.Append("<wps:ProcessOutputs>"); foreach (OutputData outputData in result.returnValues) { retString.Append(outputData.GetXmlValue()); } retString.Append("</wps:ProcessOutputs>"); } retString.Append("</wps:ExecuteResponse>"); try { XmlDocument doc = new XmlDocument(); doc.LoadXml(retString.ToString()); return(doc); } catch (Exception e) { throw new ExceptionReport("The service execution has encountered an error while formatting the result stream. Check the parameters values.\n" + e.ToString()); } }
public static XmlDocument Run(ProcessDescription processDescription, List <InputData> inputParams, ResponseFormType responseForm) { /* error is unreachable because check (via throwing an exception) is done before * if (processDescription == null) * throw new ExceptionReport("The ows:Identifier tag of the process can't be found in the xml file. It must be placed under the root 'Execute' node.", * ExceptionCode.MissingParameterValue);*/ string processId = processDescription.Identifier; List <InputData> processInputParams = processDescription.GetProcessInputParameters(); List <OutputData> processOutputParams = processDescription.GetProcessOutputParameters(); ExceptionReport exception = null; ProcessInputParams args = new ProcessInputParams(); // Get and check input parameters foreach (InputData processInputParam in processInputParams) { int occurs = 0; bool loop = processInputParam.MaxOccurs > 0 || processInputParam.MaxOccurs == -1; List <InputData> iargs = new List <InputData>(); while (loop) { loop = false; foreach (InputData input in inputParams) { if (input.Identifier != processInputParam.Identifier) { continue; } if (!input.IsValueAllowed()) { exception = new ExceptionReport(exception, "The parameter " + input.Identifier + " has not a valid value!", ExceptionCode.InvalidParameterValue, input.Identifier); } occurs++; iargs.Add(input.Clone()); inputParams.Remove(input); loop = true; break; } } if (occurs < processInputParam.MinOccurs || (occurs > processInputParam.MaxOccurs && processInputParam.MaxOccurs != -1)) { exception = new ExceptionReport(exception, "The parameter " + processInputParam.Identifier + " has " + occurs + " occurrences but it should have at least " + processInputParam.MinOccurs + " and at most " + processInputParam.MaxOccurs + " occurrences.", ExceptionCode.InvalidParameterValue, processInputParam.Identifier); } // default value for LiteralData if (occurs == 0 && processInputParam.asLiteralInput() != null && !String.IsNullOrEmpty(processInputParam.asLiteralInput().Default)) { iargs.Add(processInputParam); } args.parameters[processInputParam.Identifier] = iargs.ToArray(); } if (exception != null) { throw exception; } ProcessReturnValue result = null; try { processDescription = ProcessDescription.GetProcessDescription(processId); if (responseForm.responseDocument != null && responseForm.responseDocument.status && responseForm.responseDocument.storeExecuteResponse) { result = processDescription.CallProcess(args, responseForm, true); } else { result = processDescription.CallProcess(args, responseForm, false); } } catch (ExceptionReport e) { if (responseForm.responseDocument != null && responseForm.responseDocument.status) { exception = e; } else { throw;// new ExceptionReport(e, "Error during process...", ExceptionCode.NoApplicableCode); } } int requestedOutputCount = result.GetOutputIdentifiers().Count; int returnedOutputCount = result.returnValues.Count; // Problem during the process (validity check is done before launching the process)! if (requestedOutputCount != returnedOutputCount) { throw new ExceptionReport(String.Format("The process has generated {0} output{1} but {2} {3} requested. Contact the administrator to fix the process issue.", returnedOutputCount, returnedOutputCount > 1 ? "s" : "", requestedOutputCount, requestedOutputCount > 1 ? "were" : "was"), ExceptionCode.NoApplicableCode); } if (responseForm.outputDefinition != null) { OutputData data = result.returnValues[0]; if (result.fileName == "") { result.fileName = processId + "RawDataOuput"; } HttpContext.Current.Response.Clear(); HttpContext.Current.Response.ClearHeaders(); HttpContext.Current.Response.StatusCode = 200; HttpContext.Current.Response.Buffer = true; // not needed because rawdataoutput can only concern a ComplexOutput //string mimeType = (data is ComplexOutput) ? ((ComplexOutput)data).format.mimeType : "text/plain"; string mimeType = data.asComplexOutput().Format.mimeType; HttpContext.Current.Response.ContentType = mimeType; string dispo = true ? "inline" : "attachment"; HttpContext.Current.Response.AddHeader("Content-Disposition", dispo + "; filename=" + System.Uri.EscapeDataString(result.fileName)); HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", "*"); byte[] content = data.ToByteArray(); HttpContext.Current.Response.AddHeader("Content-Length", "" + content.Length); HttpContext.Current.Response.AddHeader("cache-control", "must-revalidate"); HttpContext.Current.Response.OutputStream.Write(content, 0, content.Length); HttpContext.Current.Response.Flush(); HttpContext.Current.ApplicationInstance.CompleteRequest(); return(new XmlDocument()); } else { s_processStartDate = DateTime.Now.ToString("yyyy_MM_dd_hh_mm_ss_ffff"); s_processArgs = args; s_responseHeader = Global.XmlHeader + "<wps:ExecuteResponse " + Global.WPSServiceVersion + " xml:lang='" + processDescription.Language + "' serviceInstance='" + HttpContext.Current.Request.Url.AbsoluteUri.Split('?')[0] + "?service=WPS&Request=GetCapabilities' " + Global.WPSXmlSchemas + " " + Global.WPSExecuteSchema /** In case of storeExecuteResponse==true : append the absolute url to the stored response file */ /**/ + (responseForm.responseDocument.storeExecuteResponse ? " statusLocation='" /**/ + Utils.ResolveUrl(Global.StoredResponsesPath /**/ + processDescription.processClass + "/response_" /**/ + s_processStartDate + ".xml' ") : " ") /************************************************************************************************/ + ">" + Environment.NewLine + "<wps:Process wps:processVersion=\"" + processDescription.Version + "\"><ows:Identifier>" + processDescription.Identifier + "</ows:Identifier><ows:Title>" + processDescription.Title + "</ows:Title></wps:Process>"; //TODO: retiré 'wps:' XmlDocument xmlResponse = FormatResponseMessage(processDescription, s_processArgs, responseForm, result, exception, s_responseHeader); if (responseForm.responseDocument.storeExecuteResponse) { if (!Directory.Exists(Global.StoredResponsesPath + "/" + processDescription.processClass)) { Directory.CreateDirectory(Global.StoredResponsesPath + "/" + processDescription.processClass); } xmlResponse.Save(Global.StoredResponsesPath + processDescription.processClass + "/response_" + s_processStartDate + ".xml"); } HttpContext.Current.Response.StatusCode = 200; return(xmlResponse); } }
/// <summary> /// This method is called by the DescribeProcess part of WPS.NET, it must be implemented. /// </summary> /// <returns>The process description</returns> public override ProcessDescription GetDescription() { ///This is where we create the process description ProcessDescription process = new ProcessDescription("AsyncClock", "Async Clock", "Counts a user-defined number of seconds asynchronously (This is an example of async process for developpers)", "1.1"); ///This check is meant to make sure everything is in it's place so that the process ///can be called asynchronously without failing miserably. if (this is IAsyncProcess && this.MainAppDomain != null) { ///Is this process implements IAsyncProcess and if the Main Application Domain is provided, ///we can assume that status will be supported (provided status updates are properly coded). process.statusSupported = true; if (this.BaseUrlToResultPath != String.Empty && this.StoredResultPath != string.Empty) ///If the necessary informations for responses and results storage are provided ///we can enable storage support. process.storeSupported = true; } ///This is the declaration of the numberOfSeconds parameter ///It has 1 minoccurs and 1 maxoccurs, it is mandatory. LiteralInput numberOfSeconds = new LiteralInput("numberOfSeconds", "Number of seconds", "The number of seconds this process will count", "integer", "100"); numberOfSeconds.MinOccurs = 1; numberOfSeconds.MaxOccurs = 1; ///Dont forget to add the previously created parameter in the inputs collection of the process. process.inputs.Add(numberOfSeconds); ///A start date should be also specified process.processStartDate = this.startDate; ///Specify the output of the process LiteralOutput output = new LiteralOutput("AsyncClockResult", "Async Clock Result", "A string containing the start datetime and the end datetime", "string"); output.Value = String.Empty; process.outputs.Add(output); ///Return the description of the process. return process; }
public ProcessDescription GetDescription() { ProcessDescription process = new ProcessDescription("Add", "Add", "(a + b) through WPS", "1.1"); LiteralInput a = new LiteralInput("a", "operand a", "abstract a", "integer", "88"); a.MinOccurs = 0; a.MaxOccurs = 3; //a.AllowedValues.Add("88"); //a.AllowedValues.Add("6"); process.inputs.Add(a); process.inputs.Add(new LiteralInput("b", "operand b", "abstract b", "integer", "22")); process.outputs.Add(new LiteralOutput("sum", "sum of a + b", "abstract sum a + b", "integer")); ComplexOutput sumFile = new ComplexOutput("sumFile", "sum of a + b as file", "raw abstract sum a + b", new ComplexFormat("text/xml", "utf8", "")); sumFile.Formats.Add(new ComplexFormat("plain/text", "utf8", "")); process.outputs.Add(sumFile); return process; }
public static XmlDocument Run(ProcessDescription processDescription, List<InputData> inputParams, ResponseFormType responseForm) { /* error is unreachable because check (via throwing an exception) is done before if (processDescription == null) throw new ExceptionReport("The ows:Identifier tag of the process can't be found in the xml file. It must be placed under the root 'Execute' node.", ExceptionCode.MissingParameterValue);*/ string processId = processDescription.Identifier; List<InputData> processInputParams = processDescription.GetProcessInputParameters(); List<OutputData> processOutputParams = processDescription.GetProcessOutputParameters(); ExceptionReport exception = null; ProcessInputParams args = new ProcessInputParams(); // Get and check input parameters foreach (InputData processInputParam in processInputParams) { int occurs = 0; bool loop = processInputParam.MaxOccurs > 0 || processInputParam.MaxOccurs == -1; List<InputData> iargs = new List<InputData>(); while (loop) { loop = false; foreach (InputData input in inputParams) { if (input.Identifier != processInputParam.Identifier) continue; if (!input.IsValueAllowed()) exception = new ExceptionReport(exception, "The parameter " + input.Identifier + " has not a valid value!", ExceptionCode.InvalidParameterValue, input.Identifier); occurs++; iargs.Add(input.Clone()); inputParams.Remove(input); loop = true; break; } } if (occurs < processInputParam.MinOccurs || (occurs > processInputParam.MaxOccurs && processInputParam.MaxOccurs != -1)) exception = new ExceptionReport(exception, "The parameter " + processInputParam.Identifier + " has " + occurs + " occurrences but it should have at least " + processInputParam.MinOccurs + " and at most " + processInputParam.MaxOccurs + " occurrences.", ExceptionCode.InvalidParameterValue, processInputParam.Identifier); // default value for LiteralData if (occurs == 0 && processInputParam.asLiteralInput() != null && !String.IsNullOrEmpty(processInputParam.asLiteralInput().Default)) iargs.Add(processInputParam); args.parameters[processInputParam.Identifier] = iargs.ToArray(); } if (exception != null) throw exception; ProcessReturnValue result = null; try { processDescription = ProcessDescription.GetProcessDescription(processId); if (responseForm.responseDocument != null && responseForm.responseDocument.status && responseForm.responseDocument.storeExecuteResponse) { result = processDescription.CallProcess(args, responseForm, true); } else result = processDescription.CallProcess(args, responseForm, false); } catch (ExceptionReport e) { if (responseForm.responseDocument != null && responseForm.responseDocument.status) exception = e; else throw;// new ExceptionReport(e, "Error during process...", ExceptionCode.NoApplicableCode); } int requestedOutputCount = result.GetOutputIdentifiers().Count; int returnedOutputCount = result.returnValues.Count; // Problem during the process (validity check is done before launching the process)! if (requestedOutputCount != returnedOutputCount) throw new ExceptionReport(String.Format("The process has generated {0} output{1} but {2} {3} requested. Contact the administrator to fix the process issue.", returnedOutputCount, returnedOutputCount > 1 ? "s" : "", requestedOutputCount, requestedOutputCount > 1 ? "were" : "was"), ExceptionCode.NoApplicableCode); if (responseForm.outputDefinition != null) { OutputData data = result.returnValues[0]; if (result.fileName == "") result.fileName = processId + "RawDataOuput"; HttpContext.Current.Response.Clear(); HttpContext.Current.Response.ClearHeaders(); HttpContext.Current.Response.StatusCode = 200; HttpContext.Current.Response.Buffer = true; // not needed because rawdataoutput can only concern a ComplexOutput //string mimeType = (data is ComplexOutput) ? ((ComplexOutput)data).format.mimeType : "text/plain"; string mimeType = data.asComplexOutput().Format.mimeType; HttpContext.Current.Response.ContentType = mimeType; string dispo = true ? "inline" : "attachment"; HttpContext.Current.Response.AddHeader("Content-Disposition", dispo + "; filename=" + System.Uri.EscapeDataString(result.fileName)); HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", "*"); byte[] content = data.ToByteArray(); HttpContext.Current.Response.AddHeader("Content-Length", "" + content.Length); HttpContext.Current.Response.AddHeader("cache-control", "must-revalidate"); HttpContext.Current.Response.OutputStream.Write(content, 0, content.Length); HttpContext.Current.Response.Flush(); HttpContext.Current.ApplicationInstance.CompleteRequest(); return new XmlDocument(); } else { s_processStartDate = DateTime.Now.ToString("yyyy_MM_dd_hh_mm_ss_ffff"); s_processArgs = args; s_responseHeader = Global.XmlHeader + "<wps:ExecuteResponse " + Global.WPSServiceVersion + " xml:lang='" + processDescription.Language + "' serviceInstance='" + HttpContext.Current.Request.Url.AbsoluteUri.Split('?')[0] + "?service=WPS&Request=GetCapabilities' " + Global.WPSXmlSchemas + " " + Global.WPSExecuteSchema /** In case of storeExecuteResponse==true : append the absolute url to the stored response file */ /**/ + (responseForm.responseDocument.storeExecuteResponse ? " statusLocation='" /**/ + Utils.ResolveUrl(Global.StoredResponsesPath /**/ + processDescription.processClass + "/response_" /**/ + s_processStartDate + ".xml' ") : " ") /************************************************************************************************/ + ">" + Environment.NewLine + "<wps:Process wps:processVersion=\""+processDescription.Version+"\"><ows:Identifier>" + processDescription.Identifier + "</ows:Identifier><ows:Title>" + processDescription.Title + "</ows:Title></wps:Process>"; //TODO: retiré 'wps:' XmlDocument xmlResponse = FormatResponseMessage(processDescription, s_processArgs, responseForm, result, exception, s_responseHeader); if (responseForm.responseDocument.storeExecuteResponse) { if (!Directory.Exists(Global.StoredResponsesPath + "/" + processDescription.processClass)) Directory.CreateDirectory(Global.StoredResponsesPath + "/" + processDescription.processClass); xmlResponse.Save(Global.StoredResponsesPath + processDescription.processClass + "/response_" + s_processStartDate + ".xml"); } HttpContext.Current.Response.StatusCode = 200; return xmlResponse; } }
public static XmlDocument RunFromHTTPGet(string language) { ResponseFormType responseForm = new ResponseFormType("wps:ResponseForm"); string processId = Utils.GetParameter("Identifier"); if (string.IsNullOrEmpty(processId)) { throw new ExceptionReport(ExceptionCode.MissingParameterValue, "Identifier"); } List <InputData> processInputParams = null; List <OutputData> processOutputParams = null; ProcessDescription processDescription = null; processDescription = ProcessDescription.GetProcessDescription(processId); processInputParams = processDescription.GetProcessInputParameters(); processOutputParams = processDescription.GetProcessOutputParameters(); List <InputData> inputParams = new List <InputData>(); //string p = Utils.DecodeURI(Utils.GetParameter("DataInputs")); string p = Utils.GetParameter("DataInputs"); ExceptionReport exception = null; if (!String.IsNullOrEmpty(p)) { string[] tokens = p.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); foreach (string param in tokens) { string[] kv = param.Split(new char[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries); if (kv.Length == 2) { InputData input = processDescription.GetProcessInputParameter(kv[0]); if (input != null) { InputData myinput = input.Clone(); try { myinput.ParseValue(kv[1]); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } inputParams.Add(myinput); } else { exception = new ExceptionReport(exception, "The parameter " + kv[0] + " is not a valid parameter for this execute request!", ExceptionCode.InvalidParameterValue, kv[0]); } } } } if (exception != null) { throw exception; } //List<string> outputIds = new List<string>(); responseForm.Parse(processDescription); return(Run(processDescription, inputParams, responseForm)); }
public override bool Parse(XmlNode node, ProcessDescription processDescription) { if (node == null) return false; XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(node.OwnerDocument); XmlNodeList childs = node.SelectNodes("ows:Identifier", nsmgr); if (childs.Count != 1) throw new ExceptionReport("One identifier is mandatory when requesting a raw data output but " + childs.Count + " were found.", ExceptionCode.InvalidParameterValue, "wps:RawDataOutput/ows:Identifier"); Identifier = childs[0].InnerText; OutputData outputData = processDescription.GetProcessOutputParameter(Identifier); if (outputData == null) throw new ExceptionReport(String.Format("The output {0} is not a valid output for the process {1}", Identifier, processDescription.Identifier), ExceptionCode.InvalidParameterValue, "rawDataOutput"); ComplexOutput processOutput = outputData.asComplexOutput(); if (processOutput == null) throw new ExceptionReport(String.Format("Only ComplexOutputs can be requested as rawDataOutput but {0} is a {1}", Identifier, outputData.GetType().Name), ExceptionCode.InvalidParameterValue, "rawDataOutput"); Format = processOutput.Format; Format.ParseValue(node); return true; }
public static XmlDocument RunFromHTTPPost(XmlNode requestNode, string language) { XmlNamespaceManager nsmgr = Utils.CreateWPSNamespaceManager(requestNode.OwnerDocument); XmlNode processNode = requestNode.SelectSingleNode("ows:Identifier", nsmgr); if (processNode == null || string.IsNullOrEmpty(processNode.InnerText)) { throw new ExceptionReport(ExceptionCode.MissingParameterValue, "ows:Identifier"); } string processId = processNode.InnerText; //List<InputData> processInputParams = null; //List<OutputData> processOutputParams = null; ProcessDescription processDescription = null; processDescription = ProcessDescription.GetProcessDescription(processId); //processInputParams = processDescription.GetProcessInputParameters(); //processOutputParams = processDescription.GetProcessOutputParameters(); List <InputData> inputParams = new List <InputData>(); ExceptionReport exception = null; XmlNodeList inputs = requestNode.SelectNodes("wps:DataInputs/wps:Input", nsmgr); foreach (XmlNode node in inputs) { XmlNode nodeid = node.SelectSingleNode("ows:Identifier", nsmgr); if (nodeid == null) { exception = new ExceptionReport(exception, "The parameter <ows:Identifier> is missing!", ExceptionCode.MissingParameterValue, "ows:Identifier"); continue; } InputData input = processDescription.GetProcessInputParameter(nodeid.InnerText); if (input == null) { exception = new ExceptionReport(exception, "The parameter " + nodeid.InnerText + " is not a valid parameter for this execute request!", ExceptionCode.InvalidParameterValue, nodeid.InnerText); continue; } InputData myinput = input.Clone(); try { myinput.ParseValue(node); inputParams.Add(myinput); } catch (ExceptionReport e) { exception = new ExceptionReport(e, exception); } } if (exception != null) { throw exception; } ResponseFormType responseForm = new ResponseFormType("wps:ResponseForm"); XmlNode responseFormNode = requestNode.SelectSingleNode("wps:ResponseForm", nsmgr); responseForm.Parse(responseFormNode, processDescription); return(Execute.Run(processDescription, inputParams, responseForm)); }
public override bool Parse(string str, ProcessDescription processDescription) { if (String.IsNullOrEmpty(str)) return false; string[] tokens = str.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); if (tokens.Length != 1) throw new ExceptionReport("One identifier is mandatory when requesting a raw data output but " + tokens.Length + " were found.", ExceptionCode.InvalidParameterValue, "RawDataOutput"); string[] kv = str.Split(new char[] { '@' }, StringSplitOptions.RemoveEmptyEntries); if (kv.Length > 0) { OutputData outputData = processDescription.GetProcessOutputParameter(kv[0]); if (outputData == null) throw new ExceptionReport(String.Format("The output {0} is not a valid output for the process {1}", kv[0], processDescription.Identifier), ExceptionCode.InvalidParameterValue, "rawDataOutput"); ComplexOutput output = outputData.asComplexOutput(); if (output == null) throw new ExceptionReport(String.Format("Only ComplexOutputs can be requested as rawDataOutput but {0} is a {1}", kv[0], outputData.GetType().ToString()), ExceptionCode.InvalidParameterValue, "rawDataOutput"); Identifier = kv[0]; Format = output.Format; // default format Format.ParseValue(str); if (output.Formats.Find(delegate(ComplexFormat cf) { return cf.Equals(Format); }) == null) throw new ExceptionReport(string.Format("Requested format for the output {0} is not supported", kv[0]), ExceptionCode.InvalidParameterValue, kv[0]); } return false; }