コード例 #1
0
        private void MasterWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            List <ServiceCallStatus> rows = e.Argument as List <ServiceCallStatus>;
            int i = 0;

            while (i < rows.Count)
            {
                if (NumWorkers < MAX_WORKERS)
                {
                    Interlocked.Increment(ref NumWorkers);
                    SADIHelper.debug("ServiceInvocation", "queueing worker " + NumWorkers, rows[i].Data);
                    ThreadPool.QueueUserWorkItem(InvokeServicesWorker_DoWork, rows[i++]);
                }
                else
                {
                    SADIHelper.debug("ServiceInvocation", "waiting for some service calls to finish before spawning more than " + MAX_WORKERS, null);
                    Thread.Sleep(30000);
                }
            }
            while (NumWorkers > 0)
            {
                SADIHelper.debug("ServiceInvocation", "waiting for " + NumWorkers + " service calls to finish", null);
                Thread.Sleep(1000);
            }
        }
コード例 #2
0
        public void addPropertyRestrictions(SADIService service)
        {
            if (service.properties.Count > 0)
            {
                SADIHelper.debug("SADIRegistry", "addPropertyRestrictions called twice on same service", service);
                return;
            }

            String query =
                "PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \r\n" +
                "PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> \r\n" +
                "PREFIX owl: <http://www.w3.org/2002/07/owl#> \r\n" +
                "PREFIX sadi: <http://sadiframework.org/ontologies/sadi.owl#> \r\n" +
                "PREFIX mygrid: <http://www.mygrid.org.uk/mygrid-moby-service#> \r\n" +
                "SELECT DISTINCT ?onPropertyURI ?onPropertyLabel ?valuesFromURI ?valuesFromLabel \r\n" +
                "WHERE {\r\n" +
                "	<"+ service.uri + "> sadi:decoratesWith ?decoration . \r\n" +
                "	?decoration owl:onProperty ?onPropertyURI . \r\n"+
                "	OPTIONAL { ?onPropertyURI rdfs:label ?onPropertyLabel } .  \r\n"+
                "	OPTIONAL { \r\n"+
                "		?decoration owl:someValuesFrom ?valuesFromURI . \r\n"+
                "		OPTIONAL { ?valuesFromURI rdfs:label ?valuesFromLabel } \r\n"+
                "	} . \r\n"+
                "}";

            foreach (JsonData binding in executeQuery(query))
            {
                service.addProperty(
                    getSPARQLBindingAsString(binding, "onPropertyURI"),
                    getSPARQLBindingAsString(binding, "onPropertyLabel"),
                    getSPARQLBindingAsString(binding, "valuesFromURI"),
                    getSPARQLBindingAsString(binding, "valuesFromLabel"));
            }
        }
コード例 #3
0
ファイル: SADIService.cs プロジェクト: tce/SADI-Core-Codebase
        private void resolveAsynchronousData(MemoryStore output, string uri)
        {
            while (uri != null)
            {
                //SADIHelper.debug("SADIService", "fetching asynchronous data", uri);
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
                request.Method            = "GET";
                request.AllowAutoRedirect = false;
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                if (response.StatusCode == HttpStatusCode.Redirect)
                {
                    String newURL = response.Headers["Location"];
                    if (newURL != null)
                    {
                        uri = newURL;
                    }

                    int    toSleep = 5;
                    String retry   = response.Headers["Retry-After"];
                    try
                    {
                        if (retry != null)
                        {
                            toSleep = Int16.Parse(retry);
                        }
                    }
                    catch (Exception e)
                    {
                        SADIHelper.error("SADIService", "failed to parse Retry-After header", retry, e);
                    }
                    //SADIHelper.debug("SADIService", "sleeping " + toSleep + "s before asynchronous request", null);
                    System.Threading.Thread.Sleep(toSleep * 1000);
                }
                else
                {
                    Stream       stream = response.GetResponseStream();
                    StreamReader reader = new StreamReader(stream);
                    using (RdfReader rdfReader = new RdfXmlReader(reader))
                    {
                        output.Import(rdfReader);
                    }
                    reader.Close();
                    stream.Close();
                    uri = null;
                }
                response.Close();
            }
        }
コード例 #4
0
 private bool checkForInputInstances(SADIService service, IEnumerable <IResource> selectedNodes)
 {
     if (service.inputInstanceQuery != null)
     {
         string query = SADIHelper.convertConstructQuery(service.inputInstanceQuery);
         if (query != null)
         {
             foreach (ISPARQLResult result in KE.Graph.Query(query).Results)
             {
                 foreach (IResource node in selectedNodes)
                 {
                     if (node.Equals(result["input"]))
                     {
                         return(true);
                     }
                 }
             }
         }
     }
     return(false);
 }
コード例 #5
0
        private void InvokeServicesWorker_DoWork(object threadContext)
        {
            ServiceCallStatus call    = threadContext as ServiceCallStatus;
            SADIService       service = call.Data as SADIService;

            try
            {
                call.Status = "Assembling input";
                MasterWorker.ReportProgress(1, call);
                MemoryStore input = assembleInput(SelectedNodes, service);

                call.Status = "Calling service";
                call.Data   = "Assembled input:\r\n" + SemWebHelper.storeToString(input);
                MasterWorker.ReportProgress(33, call);
                Store output = service.invokeService(input);

                call.Status = "Storing output";
                call.Data   = "Received output:\r\n" + SemWebHelper.storeToString(output);
                MasterWorker.ReportProgress(66, call);
                ICollection <IStatement> statements = KE.Import(output);
                showNewStatements(statements);

                call.Status = "Done";
                call.Data   = service;
                MasterWorker.ReportProgress(100, call);
            }
            catch (Exception err)
            {
                SADIHelper.error("ServiceCall", "error calling service", service, err);
                call.Status = "Error";
                call.Data   = "Error:\r\n" + err.Message;
                MasterWorker.ReportProgress(100, call);
            }
            finally
            {
                Interlocked.Decrement(ref NumWorkers);
            }
        }
コード例 #6
0
        private void FindServicesWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            List <String> types = new List <String>();

            foreach (IResource node in SelectedNodes)
            {
                if (node is IEntity)
                {
                    if (!KE.HasType(node))
                    {
                        Uri uri = (node as IEntity).Uri;
                        if (!ReportProgressIfNotCancelled(0, String.Format("Resolving {0}...", uri)))
                        {
                            return;
                        }
                        try
                        {
                            SADIHelper.debug("ServiceSelection", "resolving URI", node);
                            if (FindServicesWorker.CancellationPending)
                            {
                                return;
                            }
                            KE.Import(SemWebHelper.resolveURI(uri));
                        }
                        catch (Exception err)
                        {
                            SADIHelper.error("ServiceSelection", "error resolving URI", node, err);
                        }
                        try
                        {
                            SADIHelper.debug("ServiceSelection", "resolving against SADI resolver", node);
                            if (FindServicesWorker.CancellationPending)
                            {
                                return;
                            }
                            KE.Import(SADIHelper.resolve(uri));
                        }
                        catch (Exception err)
                        {
                            SADIHelper.error("ServiceSelection", "error resolving against SADI resolver", node, err);
                        }
                    }
                    foreach (IEntity type in KE.GetTypes(node as IEntity))
                    {
                        types.Add(type.Uri.ToString());
                    }
                }
            }

            // find services by exact input class; quick, but misses a lot...
            if (!ReportProgressIfNotCancelled(0, "Finding services by direct type..."))
            {
                return;
            }
            ICollection <SADIService> services = SADIRegistry.Instance().findServicesByInputClass(types);
            int i = 0;
            int n = services.Count;

            foreach (SADIService service in services)
            {
                SADIRegistry.Instance().addPropertyRestrictions(service);
                if (!ReportProgressIfNotCancelled((++i * 100) / n, service))
                {
                    return;
                }
            }

            // reset progress bar
            if (!ReportProgressIfNotCancelled(0, "Finding services by input instance query..."))
            {
                return;
            }

            // find service by input instance SPARQL query; slow, but is complete modulo reasoning...
            i = 0;
            n = SADIRegistry.Instance().getServiceCount();
            do
            {
                if (!ReportProgressIfNotCancelled((i * 100) / n, String.Format("Finding services by input instance query {0}-{1}/{2}",
                                                                               i, Math.Min(i + SERVICES_PER_QUERY, n), n)))
                {
                    return;
                }
                services = SADIRegistry.Instance().getAllServices(i, SERVICES_PER_QUERY);
                foreach (SADIService service in services)
                {
                    //SADIHelper.debug("ServiceDiscoveryDialog", String.Format("checking {0}", service.uri), null);
                    Object rv = null;
                    try
                    {
                        if (checkForInputInstances(service, SelectedNodes))
                        {
                            SADIRegistry.Instance().addPropertyRestrictions(service);
                            rv = service;
                        }
                        else
                        {
                            rv = String.Format("No match to {0}", service.uri);
                        }
                    }
                    catch (Exception ex)
                    {
                        //rv = ex;
                        rv = String.Format("Error executing input instance query for {0}: {1}", service.uri, ex.Message);
                    }
                    if (!ReportProgressIfNotCancelled((++i * 100) / n, rv))
                    {
                        return;
                    }
                }
            } while (services.Count == SERVICES_PER_QUERY);
        }