Changeset 5971


Ignore:
Timestamp:
02/12/15 13:09:57 (9 years ago)
Author:
emanuel.dima@uni-tuebingen.de
Message:
  1. alpha 19: better UI for statistics, misc bugfixes
Location:
SRUAggregator/trunk
Files:
2 added
18 edited
1 moved

Legend:

Unmodified
Added
Removed

  • SRUAggregator/trunk/aggregator.yml

    r5960 r5971  
    11aggregatorParams:
    22  CENTER_REGISTRY_URL: http://centres.clarin.eu/restxml/
    3   WEBLICHT_URL: https://weblicht.sfs.uni-tuebingen.de/WebLicht-4/?input=
     3#  additionalCQLEndpoints:
     4#    - https://clarin.ids-mannheim.de/digibibsru-new
     5    # - https://lux17.mpi.nl/ds/cqlsearch
     6    # - http://www.meertens.knaw.nl/mimore/srucql/
     7    # - http://gysseling.corpus.taalbanknederlands.inl.nl/gyssru/
     8    # - http://brievenalsbuit.inl.nl/zbsru/
     9    # - http://corpus3.aac.ac.at/ddconsru/
    410
     11  # AGGREGATOR_FILE_PATH: /data/fcsAggregator/fcsAggregatorCorpora.json
    512  AGGREGATOR_FILE_PATH: /Users/edima/fcsAggregatorCorpora.json
    6   SCAN_MAX_DEPTH: 2
     13
     14  SCAN_MAX_DEPTH: 1 # recommended 3
    715  SCAN_TASK_INITIAL_DELAY: 0
    816  SCAN_TASK_INTERVAL: 12
    … …  
    1220  SEARCH_MAX_CONCURRENT_REQUESTS_PER_ENDPOINT: 4
    1321
    14 
    15   ENDPOINTS_SCAN_TIMEOUT_MS: 60000
     22  ENDPOINTS_SCAN_TIMEOUT_MS: 10000
    1623  ENDPOINTS_SEARCH_TIMEOUT_MS: 30000
    1724  EXECUTOR_SHUTDOWN_TIMEOUT_MS: 1000
     25
     26  WEBLICHT_URL: https://weblicht.sfs.uni-tuebingen.de/WebLicht-4/?input=
    1827
    1928# use the simple server factory, run on a single port

  • SRUAggregator/trunk/build.sh

    r5919 r5971  
    1818        cp bower_components/bootstrap/dist/js/bootstrap.min.js $LIBDIR/
    1919        cp bower_components/jquery/dist/jquery.min.js $LIBDIR/
     20        cp bower_components/jquery/dist/jquery.min.map $LIBDIR/
    2021        cp bower_components/react/react-with-addons.js $LIBDIR/
    2122        cp bower_components/react/react-with-addons.min.js $LIBDIR/

  • SRUAggregator/trunk/pom.xml

    r5959 r5971  
    88        <groupId>eu.clarin.sru.fcs</groupId>
    99        <artifactId>Aggregator2</artifactId>
    10         <version>2.0.0-alpha-16</version>
     10        <version>2.0.0-alpha-19</version>
    1111        <name>FCS Aggregator</name>
    1212
    … …  
    6262                        <groupId>eu.clarin.sru</groupId>
    6363                        <artifactId>sru-client</artifactId>
    64                         <version>0.9.4</version>
     64                        <version>0.9.5-DEBUG</version>
    6565                </dependency>
    6666

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/app/Aggregator.java

    r5960 r5971  
    8888 * @author edima
    8989 *
     90 * TODO: Send mail to Dieter with centers that do not accept recordSchema
     91 * parameter
     92 *
     93 * TODO: mail to LINDAT-Clarin devel about matching whole word in search
     94 *
     95 * TODO: routing
     96 *
     97 * TODO: stats page as tabs
     98 *
    9099 * TODO: Download search results as csv, excel, tcf, plain text
    91100 *
    … …  
    232241                ScanCrawlTask task = new ScanCrawlTask(sruScanClient,
    233242                                params.CENTER_REGISTRY_URL, params.SCAN_MAX_DEPTH,
    234                                 null, scanCacheAtom, corporaCacheFile, scanStatsAtom, searchStatsAtom);
     243                                params.additionalCQLEndpoints,
     244                                null, scanCacheAtom, corporaCacheFile,
     245                                scanStatsAtom, searchStatsAtom);
    235246                scheduler.scheduleAtFixedRate(task, params.SCAN_TASK_INITIAL_DELAY,
    236247                                params.SCAN_TASK_INTERVAL, params.getScanTaskTimeUnit());

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/app/AggregatorConfiguration.java

    r5901 r5971  
    44import com.fasterxml.jackson.annotation.JsonProperty;
    55import io.dropwizard.Configuration;
     6import java.net.URL;
     7import java.util.List;
    68import java.util.concurrent.TimeUnit;
    79import org.hibernate.validator.constraints.NotEmpty;
    … …  
    6062                long EXECUTOR_SHUTDOWN_TIMEOUT_MS;
    6163
     64                @JsonProperty
     65                List<URL> additionalCQLEndpoints;
     66
    6267                @JsonIgnore
    6368                public TimeUnit getScanTaskTimeUnit() {

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/scan/CenterRegistryForTesting.java

    r5957 r5971  
    1818    private static final Logger logger = Logger.getLogger(CenterRegistryForTesting.class.getName());
    1919    private boolean hasChildrenLoaded = false;
    20         private List<Institution> centers = new ArrayList<Institution>() {
    21                 {
    22                         Institution inst = new Institution("test_IDS", null);
    23                         inst.addEndpoint("https://clarin.ids-mannheim.de/digibibsru-new");
    24                         add(inst);
    25                 }
    26         };
     20        private List<Institution> centers = new ArrayList<Institution>();
    2721
    2822    @Override

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/scan/Diagnostic.java

    r5954 r5971  
    11package eu.clarin.sru.fcs.aggregator.scan;
     2
     3import com.fasterxml.jackson.annotation.JsonProperty;
    24
    35/*
    … …  
    68public class Diagnostic {
    79
    8         private String reqEndpointUrl, reqContext;
    9         private String dgnUri, dgnMessage, dgnDiagnostic;
     10        @JsonProperty
     11        String uri;
    1012
    11         public Diagnostic(String reqEndpointUrl, String reqContext, String dgnUri, String dgnMessage, String dgnDiagnostic) {
    12                 this.reqEndpointUrl = reqEndpointUrl;
    13                 this.reqContext = reqContext;
    14                 this.dgnUri = dgnUri;
    15                 this.dgnMessage = dgnMessage;
    16                 this.dgnDiagnostic = dgnDiagnostic;
    17         }
     13        @JsonProperty
     14        String message;
    1815
    19         public Diagnostic() {
    20         }
     16        @JsonProperty
     17        String diagnostic;
    2118
    22         public String getDgnDiagnostic() {
    23                 return dgnDiagnostic;
    24         }
    25 
    26         public String getDgnMessage() {
    27                 return dgnMessage;
    28         }
    29 
    30         public String getDgnUri() {
    31                 return dgnUri;
    32         }
    33 
    34         public String getReqContext() {
    35                 return reqContext;
    36         }
    37 
    38         public String getReqEndpointUrl() {
    39                 return reqEndpointUrl;
    40         }
    41 
    42         public void setDgnDiagnostic(String dgnDiagnostic) {
    43                 this.dgnDiagnostic = dgnDiagnostic;
    44         }
    45 
    46         public void setDgnMessage(String dgnMessage) {
    47                 this.dgnMessage = dgnMessage;
    48         }
    49 
    50         public void setDgnUri(String dgnUri) {
    51                 this.dgnUri = dgnUri;
    52         }
    53 
    54         public void setReqContext(String reqContext) {
    55                 this.reqContext = reqContext;
    56         }
    57 
    58         public void setReqEndpointUrl(String reqEndpointUrl) {
    59                 this.reqEndpointUrl = reqEndpointUrl;
     19        public Diagnostic(String uri, String message, String diagnostic) {
     20                this.uri = uri;
     21                this.message = message;
     22                this.diagnostic = diagnostic;
    6023        }
    6124
    … …  
    6326        public int hashCode() {
    6427                https://primes.utm.edu/lists/small/1000.txt
    65                 return reqEndpointUrl.hashCode() * 967 + reqContext.hashCode() * 797
    66                                 + dgnUri.hashCode() * 1669 + dgnMessage.hashCode() * 31
    67                                 + dgnDiagnostic.hashCode();
     28                return uri.hashCode() * 1669 + message.hashCode() * 31
     29                                + diagnostic.hashCode();
    6830        }
    6931
    … …  
    7436                }
    7537                Diagnostic d = (Diagnostic) obj;
    76                 return reqEndpointUrl.equals(d.reqEndpointUrl)
    77                                 && reqContext.equals(d.reqContext)
    78                                 && dgnUri.equals(d.dgnUri)
    79                                 && dgnMessage.equals(d.dgnMessage)
    80                                 && dgnDiagnostic.equals(d.dgnDiagnostic);
     38                return uri.equals(d.uri) && message.equals(d.message)
     39                                && diagnostic.equals(d.diagnostic);
    8140        }
    8241}

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/scan/ScanCrawlTask.java

    r5959 r5971  
    55import java.io.File;
    66import java.io.IOException;
     7import java.net.URL;
     8import java.util.List;
     9import java.util.ArrayList;
    710import java.util.concurrent.atomic.AtomicReference;
    811import org.slf4j.LoggerFactory;
    … …  
    2427        private AtomicReference<Statistics> searchStatisticsAtom;
    2528        private String centerRegistryUrl;
     29        private List<URL> additionalCQLEndpoints;
    2630
    2731        public ScanCrawlTask(ThrottledClient sruClient, String centerRegistryUrl,
    28                         int cacheMaxDepth, EndpointFilter filter,
     32                        int cacheMaxDepth, List<URL> additionalCQLEndpoints,
     33                        EndpointFilter filter,
    2934                        AtomicReference<Corpora> corporaAtom, File cachedCorpora,
    3035                        AtomicReference<Statistics> scanStatisticsAtom,
    … …  
    3439                this.centerRegistryUrl = centerRegistryUrl;
    3540                this.cacheMaxDepth = cacheMaxDepth;
     41                this.additionalCQLEndpoints = additionalCQLEndpoints;
    3642                this.filter = filter;
    3743                this.corporaAtom = corporaAtom;
    … …  
    4753
    4854                        log.info("ScanCrawlTask: Initiating crawl");
    49                         CenterRegistry centerRegistry = new CenterRegistryLive(centerRegistryUrl, filter);
    50 //                      centerRegistry.getCQLInstitutions().add(0,
    51 //                                      new Institution("test_IDS", null) {
    52 //                                              {
    53 //                                                      addEndpoint("https://clarin.ids-mannheim.de/digibibsru-new");
    54 //                                              }
    55 //                                      });
    56 //                      CenterRegistry centerRegistry = new CenterRegistryForTesting();
    57                         ScanCrawler scanCrawler = new ScanCrawler(centerRegistry, sruClient, cacheMaxDepth);
     55                        List<Institution> institutions = new ArrayList<Institution>();
     56                        if (centerRegistryUrl != null && !centerRegistryUrl.isEmpty()) {
     57                                institutions = new CenterRegistryLive(centerRegistryUrl, filter).getCQLInstitutions();
     58                        }
     59                        if (additionalCQLEndpoints != null && !additionalCQLEndpoints.isEmpty()) {
     60                                institutions.add(0,
     61                                                new Institution("ZZZ", null) {
     62                                                        {
     63                                                                for (URL u : additionalCQLEndpoints) {
     64                                                                        addEndpoint(u.toExternalForm());
     65                                                                }
     66                                                        }
     67                                                });
     68                        }
     69                        ScanCrawler scanCrawler = new ScanCrawler(institutions, sruClient, cacheMaxDepth);
    5870
    5971                        log.info("ScanCrawlTask: Starting crawl");

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/scan/ScanCrawler.java

    r5959 r5971  
    1010import eu.clarin.sru.client.SRUScanResponse;
    1111import eu.clarin.sru.client.SRUTerm;
     12import eu.clarin.sru.client.SRUVersion;
    1213import eu.clarin.sru.client.fcs.ClarinFCSEndpointDescription;
    1314import eu.clarin.sru.client.fcs.ClarinFCSEndpointDescription.ResourceInfo;
    … …  
    1617import eu.clarin.sru.fcs.aggregator.util.Throw;
    1718import java.net.SocketTimeoutException;
     19import java.util.ArrayList;
    1820import java.util.HashSet;
    1921import java.util.List;
    … …  
    3638        private static final org.slf4j.Logger log = LoggerFactory.getLogger(ScanCrawler.class);
    3739
    38         private final CenterRegistry centerRegistry;
     40        private final List<Institution> institutions;
    3941        private final int maxDepth;
    4042        private final CounterLatch latch;
    … …  
    4244        private final Statistics statistics = new Statistics();
    4345
    44         public ScanCrawler(CenterRegistry centerRegistry, ThrottledClient sruClient, int maxDepth) {
    45                 this.centerRegistry = centerRegistry;
     46        public ScanCrawler(List<Institution> institutions, ThrottledClient sruClient, int maxDepth) {
     47                this.institutions = institutions;
    4648                this.sruClient = sruClient;
    4749                this.maxDepth = maxDepth;
    … …  
    5153        public Corpora crawl() {
    5254                Corpora cache = new Corpora();
    53                 for (Institution institution : centerRegistry.getCQLInstitutions()) {
     55                for (Institution institution : institutions) {
    5456                        cache.addInstitution(institution);
    5557                        Iterable<Endpoint> endpoints = institution.getEndpoints();
    … …  
    6870                log.info("done crawling");
    6971
    70                 for (Institution institution : centerRegistry.getCQLInstitutions()) {
     72                for (Institution institution : institutions) {
    7173                        Iterable<Endpoint> endpoints = institution.getEndpoints();
    7274                        for (Endpoint endp : endpoints) {
    … …  
    8385                final Endpoint endpoint;
    8486                final Corpora corpora;
     87                String fullRequestUrl;
    8588
    8689                ExplainTask(final Institution institution, final Endpoint endpoint, final Corpora corpora) {
    … …  
    9699                                explainRequest.setExtraRequestData(SRUCQL.EXPLAIN_ASK_FOR_RESOURCES_PARAM, "true");
    97100                                explainRequest.setParseRecordDataEnabled(true);
     101                                fullRequestUrl = explainRequest.makeURI(SRUVersion.VERSION_1_2).toString();
    98102                        } catch (Throwable ex) {
    99103                                log.error("Exception creating explain request for {}: {}", endpoint.getUrl(), ex.getMessage());
    … …  
    113117                        try {
    114118                                statistics.addEndpointDatapoint(institution, endpoint, stats.getQueueTime(), stats.getExecutionTime());
     119
     120                                List<String> rootCollections = new ArrayList<String>();
    115121                                if (response != null && response.hasExtraResponseData()) {
    116122                                        for (SRUExtraResponseData data : response.getExtraResponseData()) {
    … …  
    119125                                                        statistics.upgradeProtocolVersion(institution, endpoint);
    120126                                                        ClarinFCSEndpointDescription desc = (ClarinFCSEndpointDescription) data;
    121                                                         addCorpora(corpora, institution, endpoint, desc.getResources(), null);
     127                                                        addCorpora(corpora, institution, endpoint, rootCollections, desc.getResources(), null);
    122128                                                }
    123129                                        }
    124130                                }
     131                                statistics.addEndpointCollections(institution, endpoint, rootCollections);
    125132
    126133                                if (response != null && response.hasDiagnostics()) {
    127134                                        for (SRUDiagnostic d : response.getDiagnostics()) {
    128135                                                SRUExplainRequest request = response.getRequest();
    129                                                 Diagnostic diag = new Diagnostic(request.getBaseURI().toString(), null,
    130                                                                 d.getURI(), d.getMessage(), d.getDetails());
    131                                                 statistics.addEndpointDiagnostic(institution, endpoint, diag);
    132                                                 log.info("Diagnostic: {} {}: {} {} {}", diag.getReqEndpointUrl(), diag.getReqContext(),
    133                                                                 diag.getDgnUri(), diag.getDgnMessage(), diag.getDgnDiagnostic());
     136                                                Diagnostic diag = new Diagnostic(d.getURI(), d.getMessage(), d.getDetails());
     137                                                statistics.addEndpointDiagnostic(institution, endpoint, diag, fullRequestUrl);
     138                                                log.info("Diagnostic: {}: {}", fullRequestUrl, diag.message);
    134139                                        }
    135140                                }
    … …  
    139144                                log.error("{} Exception in explain callback {}", latch.get(), endpoint.getUrl());
    140145                                log.error("--> ", xc);
     146                                statistics.addErrorDatapoint(institution, endpoint, xc, fullRequestUrl);
    141147                        } finally {
    142148                                if (endpoint.getProtocol().equals(FCSProtocolVersion.LEGACY)) {
    143149                                        new ScanTask(institution, endpoint, null, corpora, 0).start();
     150                                        Diagnostic diag = new Diagnostic("LEGACY", "Endpoint didn't return any resource on EXPLAIN, presuming legacy support", "");
     151                                        statistics.addEndpointDiagnostic(institution, endpoint, diag, fullRequestUrl);
    144152                                }
    145153
    … …  
    153161                                log.error("{} Error while explaining {}: {}", latch.get(), endpoint.getUrl(), error.getMessage());
    154162                                statistics.addEndpointDatapoint(institution, endpoint, stats.getQueueTime(), stats.getExecutionTime());
    155                                 statistics.addErrorDatapoint(institution, endpoint, error);
     163                                statistics.addErrorDatapoint(institution, endpoint, error, fullRequestUrl);
    156164                                if (Throw.isCausedBy(error, SocketTimeoutException.class)) {
    157165                                        return;
    … …  
    166174        }
    167175
    168         private static void addCorpora(Corpora corpora, Institution institution, Endpoint endpoint,
     176        private static void addCorpora(Corpora corpora,
     177                        Institution institution, Endpoint endpoint,
     178                        List<String> rootCollections,
    169179                        List<ResourceInfo> resources, Corpus parentCorpus) {
    170180                if (resources == null) {
    … …  
    180190
    181191                        if (corpora.addCorpus(c, parentCorpus)) {
    182                                 addCorpora(corpora, institution, endpoint, ri.getSubResources(), c);
     192                                if (rootCollections != null) {
     193                                        rootCollections.add(c.getTitle());
     194                                }
     195                                addCorpora(corpora, institution, endpoint, null, ri.getSubResources(), c);
    183196                        }
    184197                }
    … …  
    208221                final Corpora corpora;
    209222                final int depth;
     223                String fullRequestUrl;
    210224
    211225                ScanTask(final Institution institution, final Endpoint endpoint,
    … …  
    230244                                scanRequest.setExtraRequestData(SRUCQL.SCAN_RESOURCE_INFO_PARAMETER,
    231245                                                SRUCQL.SCAN_RESOURCE_INFO_PARAMETER_DEFAULT_VALUE);
     246                                fullRequestUrl = scanRequest.makeURI(SRUVersion.VERSION_1_2).toString();
    232247                        } catch (Throwable ex) {
    233248                                log.error("Exception creating scan request for {}: {}", endpoint.getUrl(), ex.getMessage());
    … …  
    255270                                                        if (corpora.addCorpus(c, parentCorpus)) {
    256271                                                                new ScanTask(institution, endpoint, c, corpora, depth + 1).start();
     272                                                                statistics.addEndpointCollection(institution, endpoint, c.getTitle());
    257273                                                        }
    258274                                                }
    259275                                        }
    260                                 } else if (parentCorpus == null) {
    261                                         Corpus c = createCorpus(institution, endpoint, null);
    262                                         if (corpora.addCorpus(c, parentCorpus)) {
    263                                                 new ScanTask(institution, endpoint, c, corpora, depth + 1).start();
    264                                         }
    265276                                }
    266277
    267278                                if (response != null && response.hasDiagnostics()) {
    268279                                        for (SRUDiagnostic d : response.getDiagnostics()) {
    269                                                 SRUScanRequest request = response.getRequest();
    270 
    271                                                 String handle = SRUCQL.SCAN_RESOURCE_PARAMETER + "=" + normalizeHandle(parentCorpus);
    272                                                 Diagnostic diag = new Diagnostic(request.getBaseURI().toString(), handle,
    273                                                                 d.getURI(), d.getMessage(), d.getDetails());
    274                                                 statistics.addEndpointDiagnostic(institution, endpoint, diag);
    275                                                 log.info("Diagnostic: {} {}: {} {} {}", diag.getReqEndpointUrl(), diag.getReqContext(),
    276                                                                 diag.getDgnUri(), diag.getDgnMessage(), diag.getDgnDiagnostic());
     280                                                Diagnostic diag = new Diagnostic(d.getURI(), d.getMessage(), d.getDetails());
     281                                                statistics.addEndpointDiagnostic(institution, endpoint, diag, fullRequestUrl);
     282                                                log.info("Diagnostic: {}: {}", fullRequestUrl, diag.message);
    277283                                        }
    278284                                }
    … …  
    282288                                log.error("{} Exception in scan callback {}#{}", latch.get(), endpoint.getUrl(), normalizeHandle(parentCorpus));
    283289                                log.error("--> ", xc);
     290                                statistics.addErrorDatapoint(institution, endpoint, xc, fullRequestUrl);
    284291                        } finally {
    285292                                latch.decrement();
    … …  
    292299                                log.error("{} Error while scanning {}#{}: {}", latch.get(), endpoint.getUrl(), normalizeHandle(parentCorpus), error.getMessage());
    293300                                statistics.addEndpointDatapoint(institution, endpoint, stats.getQueueTime(), stats.getExecutionTime());
    294                                 statistics.addErrorDatapoint(institution, endpoint, error);
     301                                statistics.addErrorDatapoint(institution, endpoint, error, fullRequestUrl);
    295302                                if (Throw.isCausedBy(error, SocketTimeoutException.class)) {
    296303                                        return;
    … …  
    322329        private static Corpus createCorpus(Institution institution, Endpoint endpoint, SRUTerm term) {
    323330                Corpus c = new Corpus(institution, endpoint);
    324                 c.setTitle(term.getDisplayTerm());
     331                c.setTitle("" + term.getDisplayTerm());
    325332                String handle = term.getValue();
    326333                if (handle == null) {

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/scan/Statistics.java

    r5959 r5971  
    22
    33import com.fasterxml.jackson.annotation.JsonProperty;
    4 import eu.clarin.sru.client.SRUClientException;
    54import java.util.ArrayList;
    65import java.util.Collections;
    … …  
    1716        public static class EndpointStats {
    1817
     18                private final Object lock = new Object();
     19
    1920                @JsonProperty
    2021                FCSProtocolVersion version = FCSProtocolVersion.LEGACY;
     22
     23                @JsonProperty
     24                List<String> rootCollections = new ArrayList<String>();
    2125
    2226                List<Long> queueTimes = Collections.synchronizedList(new ArrayList<Long>());
    … …  
    2529                public static class DiagPair {
    2630
    27                         public DiagPair(Diagnostic diagnostic, int counter) {
     31                        public DiagPair(Diagnostic diagnostic, String context, int counter) {
    2832                                this.diagnostic = diagnostic;
     33                                this.context = context;
    2934                                this.counter = counter;
    3035                        }
    3136
     37                        @JsonProperty
    3238                        public Diagnostic diagnostic;
     39                        @JsonProperty
     40                        String context;
     41                        @JsonProperty
    3342                        public int counter;
    3443                }
    … …  
    3645                @JsonProperty
    3746                Map<String, DiagPair> diagnostics = Collections.synchronizedMap(new HashMap<String, DiagPair>());
     47
     48                public static class ExcPair {
     49
     50                        public ExcPair(JsonException exception, String context, int counter) {
     51                                this.exception = exception;
     52                                this.context = context;
     53                                this.counter = counter;
     54                        }
     55
     56                        @JsonProperty
     57                        public JsonException exception;
     58                        @JsonProperty
     59                        String context;
     60                        @JsonProperty
     61                        public int counter;
     62                }
     63
    3864                @JsonProperty
    39                 Map<String, Integer> errors = Collections.synchronizedMap(new HashMap<String, Integer>());
     65                Map<String, ExcPair> errors = Collections.synchronizedMap(new HashMap<String, ExcPair>());
    4066
    4167                double avg(List<Long> q) {
    … …  
    81107        };
    82108
     109        private final Object lock = new Object();
     110
    83111        // institution to endpoint to statistics_per_endpoint map
    84112        Map<String, Map<String, EndpointStats>> institutions
    … …  
    91119        public void addEndpointDatapoint(Institution institution, Endpoint endpoint, long enqueuedTime, long executionTime) {
    92120                EndpointStats stats = getEndpointStats(institution, endpoint);
    93                 stats.queueTimes.add(enqueuedTime);
    94                 stats.executionTimes.add(executionTime);
    95         }
    96 
    97         public void addEndpointDiagnostic(Institution institution, Endpoint endpoint, Diagnostic diag) {
    98                 EndpointStats stats = getEndpointStats(institution, endpoint);
    99                 if (!stats.diagnostics.containsKey(diag.getDgnUri())) {
    100                         stats.diagnostics.put(diag.getDgnUri(), new EndpointStats.DiagPair(diag, 1));
    101                 } else {
    102                         stats.diagnostics.get(diag.getDgnUri()).counter++;
     121                synchronized (stats.lock) {
     122                        stats.queueTimes.add(enqueuedTime);
     123                        stats.executionTimes.add(executionTime);
    103124                }
    104125        }
    105126
    106         public void addErrorDatapoint(Institution institution, Endpoint endpoint, SRUClientException error) {
     127        public void addEndpointDiagnostic(Institution institution, Endpoint endpoint, Diagnostic diag, String context) {
    107128                EndpointStats stats = getEndpointStats(institution, endpoint);
    108                 int number = 0;
    109                 if (stats.errors.containsKey(error.getMessage())) {
    110                         number = stats.errors.get(error.getMessage());
     129                synchronized (stats.lock) {
     130                        if (!stats.diagnostics.containsKey(diag.uri)) {
     131                                stats.diagnostics.put(diag.uri, new EndpointStats.DiagPair(diag, context, 1));
     132                        } else {
     133                                stats.diagnostics.get(diag.uri).counter++;
     134                        }
    111135                }
    112                 stats.errors.put(error.getMessage(), number + 1);
     136        }
     137
     138        public void addErrorDatapoint(Institution institution, Endpoint endpoint, Exception error, String context) {
     139                EndpointStats stats = getEndpointStats(institution, endpoint);
     140                JsonException jxc = new JsonException(error);
     141                synchronized (stats.lock) {
     142                        if (!stats.errors.containsKey(jxc.message)) {
     143                                stats.errors.put(jxc.message, new EndpointStats.ExcPair(jxc, context, 1));
     144                        } else {
     145                                stats.errors.get(jxc.message).counter++;
     146                        }
     147                }
    113148        }
    114149
    115150        public void upgradeProtocolVersion(Institution institution, Endpoint endpoint) {
    116151                EndpointStats stats = getEndpointStats(institution, endpoint);
    117                 stats.version = FCSProtocolVersion.VERSION_1;
     152                synchronized (stats.lock) {
     153                        stats.version = FCSProtocolVersion.VERSION_1;
     154                }
     155        }
     156
     157        public void addEndpointCollection(Institution institution, Endpoint endpoint, String collectionName) {
     158                EndpointStats stats = getEndpointStats(institution, endpoint);
     159                synchronized (stats.lock) {
     160                        stats.rootCollections.add(collectionName);
     161                }
     162        }
     163
     164        public void addEndpointCollections(Institution institution, Endpoint endpoint, List<String> collections) {
     165                EndpointStats stats = getEndpointStats(institution, endpoint);
     166                synchronized (stats.lock) {
     167                        stats.rootCollections.addAll(collections);
     168                }
    118169        }
    119170
    120171        private EndpointStats getEndpointStats(Institution institution, Endpoint endpoint) {
    121                 if (!institutions.containsKey(institution.getName())) {
    122                         institutions.put(institution.getName(),
    123                                         Collections.synchronizedMap(new HashMap<String, EndpointStats>()));
     172                EndpointStats stats;
     173                synchronized (lock) {
     174                        if (!institutions.containsKey(institution.getName())) {
     175                                institutions.put(institution.getName(),
     176                                                Collections.synchronizedMap(new HashMap<String, EndpointStats>()));
     177                        }
     178                        Map<String, EndpointStats> esmap = institutions.get(institution.getName());
     179                        if (!esmap.containsKey(endpoint.getUrl())) {
     180                                EndpointStats es = new EndpointStats();
     181                                es.version = endpoint.getProtocol();
     182                                esmap.put(endpoint.getUrl(), es);
     183                        }
     184                        stats = esmap.get(endpoint.getUrl());
    124185                }
    125                 Map<String, EndpointStats> esmap = institutions.get(institution.getName());
    126                 if (!esmap.containsKey(endpoint.getUrl())) {
    127                         EndpointStats es = new EndpointStats();
    128                         es.version = endpoint.getProtocol();
    129                         esmap.put(endpoint.getUrl(), es);
    130                 }
    131                 return esmap.get(endpoint.getUrl());
     186                return stats;
    132187        }
    133188}

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/search/Result.java

    r5959 r5971  
    1515import eu.clarin.sru.client.fcs.Resource;
    1616import eu.clarin.sru.fcs.aggregator.scan.Diagnostic;
     17import eu.clarin.sru.fcs.aggregator.scan.JsonException;
    1718import java.util.ArrayList;
    1819import java.util.Collections;
    … …  
    3536        private Request request;
    3637        private List<Kwic> kwics = new ArrayList<Kwic>();
    37         private SRUClientException exception;
     38        private JsonException exception;
    3839        private List<Diagnostic> diagnostics = new ArrayList<Diagnostic>();
    3940
    … …  
    4546                        SRUClientException xc) {
    4647                this.request = request;
    47                 this.exception = xc;
     48                if (xc != null) {
     49                        exception = new JsonException(xc);
     50                }
    4851                if (response != null && response.hasRecords()) {
    4952                        setResponse(response);
    … …  
    7578                for (SRUDiagnostic d : response.getDiagnostics()) {
    7679                        SRUSearchRetrieveRequest srurequest = response.getRequest();
    77                         diagnostics.add(new Diagnostic(srurequest.getBaseURI().toString(),
    78                                         srurequest.getQuery(),
    79                                         d.getURI(), d.getMessage(), d.getDetails()));
     80                        diagnostics.add(new Diagnostic(d.getURI(), d.getMessage(), d.getDetails()));
    8081                }
    8182        }
    … …  
    124125        }
    125126
    126         public SRUClientException getException() {
    127                 return exception;
     127        public List<Diagnostic> getDiagnostics() {
     128                return Collections.unmodifiableList(diagnostics);
    128129        }
    129130
    130         public List<Diagnostic> getDiagnostics() {
    131                 return Collections.unmodifiableList(diagnostics);
     131        public JsonException getException() {
     132                return exception;
    132133        }
    133134

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/search/Search.java

    r5960 r5971  
    88import eu.clarin.sru.fcs.aggregator.client.ThrottledClient;
    99import eu.clarin.sru.fcs.aggregator.scan.Corpus;
     10import eu.clarin.sru.fcs.aggregator.scan.Diagnostic;
     11import eu.clarin.sru.fcs.aggregator.scan.FCSProtocolVersion;
    1012import eu.clarin.sru.fcs.aggregator.scan.Statistics;
    1113import eu.clarin.sru.fcs.aggregator.util.SRUCQL;
    … …  
    6163                searchRequest.setVersion(version);
    6264                searchRequest.setMaximumRecords(maxRecords);
     65                FCSProtocolVersion fcsVersion = corpus.getEndpoint().getProtocol();
    6366//              searchRequest.setRecordSchema(
    64 //                              corpus.getEndpoint().getProtocol().equals(FCSProtocolVersion.LEGACY)
     67//                              fcsVersion.equals(FCSProtocolVersion.LEGACY)
    6568//                                              ? ClarinFCSRecordData.LEGACY_RECORD_SCHEMA
    6669//                                              : ClarinFCSRecordData.RECORD_SCHEMA);
    … …  
    6871                searchRequest.setStartRecord(startRecord);
    6972                if (corpus.getHandle() != null) {
    70                         searchRequest.setExtraRequestData(SRUCQL.SEARCH_CORPUS_HANDLE_PARAMETER, corpus.getHandle());
     73                        searchRequest.setExtraRequestData(
     74                                        fcsVersion.equals(FCSProtocolVersion.LEGACY)
     75                                                        ? SRUCQL.SEARCH_CORPUS_HANDLE_LEGACY_PARAMETER
     76                                                        : SRUCQL.SEARCH_CORPUS_HANDLE_PARAMETER,
     77                                        corpus.getHandle());
    7178                }
    7279                requests.add(request);
     80
     81                String url = null;
     82                try {
     83                        url = searchRequest.makeURI(SRUVersion.VERSION_1_2).toString();
     84                } catch (SRUClientException ex) {
     85                }
     86                final String fullRequestUrl = url;
    7387
    7488                try {
    … …  
    8195                                                results.add(result);
    8296                                                requests.remove(request);
    83                                                 if (!result.getDiagnostics().isEmpty()) {
    84                                                         statistics.addEndpointDiagnostic(corpus.getInstitution(), corpus.getEndpoint(), null);
     97                                                List<Diagnostic> diagnostics = result.getDiagnostics();
     98                                                if (diagnostics != null && !diagnostics.isEmpty()) {
     99                                                        log.error("diagnostic for url: " + response.getRequest().makeURI(SRUVersion.VERSION_1_2));
     100                                                        for (Diagnostic diagnostic : diagnostics) {
     101                                                                statistics.addEndpointDiagnostic(corpus.getInstitution(), corpus.getEndpoint(), diagnostic, fullRequestUrl);
     102                                                        }
    85103                                                }
    86104                                        } catch (Throwable xc) {
    … …  
    93111                                        try {
    94112                                                statistics.addEndpointDatapoint(corpus.getInstitution(), corpus.getEndpoint(), stats.getQueueTime(), stats.getExecutionTime());
    95                                                 statistics.addErrorDatapoint(corpus.getInstitution(), corpus.getEndpoint(), xc);
     113                                                statistics.addErrorDatapoint(corpus.getInstitution(), corpus.getEndpoint(), xc, fullRequestUrl);
    96114                                                results.add(new Result(request, null, xc));
    97115                                                requests.remove(request);
     116                                                log.error("search.onError: ", xc);
    98117                                        } catch (Throwable xxc) {
    99118                                                log.error("search.onError exception:", xxc);

  • SRUAggregator/trunk/src/main/java/eu/clarin/sru/fcs/aggregator/util/SRUCQL.java

    r5957 r5971  
    1313
    1414        public static final String SEARCH_RETRIEVE = "searchRetrieve";
    15         public static final String SEARCH_CORPUS_HANDLE_PARAMETER = "x-cmd-context";
    1615        public static final String SEARCH_QUERY_PARAMETER = "query";
     16        public static final String SEARCH_CORPUS_HANDLE_LEGACY_PARAMETER = "x-cmd-context";
     17        public static final String SEARCH_CORPUS_HANDLE_PARAMETER = "x-fcs-context";
    1718
    1819        public static final String SCAN = "scan";

  • SRUAggregator/trunk/src/main/resources/assets/js/main.js

    r5960 r5971  
    22(function() {
    33"use strict";
     4
     5var VERSION = "VERSION 2.0.0.α18";
    46
    57var PT = React.PropTypes;
    … …  
    195197        },
    196198
    197         renderEndpoint: function(endpoint) {
     199        renderCollections: function(colls) {
     200                return  React.createElement("div", {style: {marginLeft:40}},
     201                                         colls.length === 0 ?
     202                                                React.createElement("div", {style: {color:"#a94442"}}, "NO collections found")
     203                                                :
     204                                                React.createElement("div", null,
     205                                                        colls.length, " root collection(s):",
     206                                                        React.createElement("ul", {className: "list-unstyled", style: {marginLeft:40}},
     207                                                                 colls.map(function(name) { return React.createElement("div", null, name); })
     208                                                        )
     209                                                )
     210                                       
     211                                );
     212        },
     213
     214        renderDiagnostic: function(d) {
     215                return  React.createElement("div", {key: d.diagnostic.uri},
     216                                        React.createElement("div", {className: "inline alert alert-warning"},
     217                                                React.createElement("div", null, "Diagnostic: ", d.diagnostic.message, ": ", d.diagnostic.diagnostic),
     218                                                React.createElement("div", null, "Context: ", React.createElement("a", {href: d.context}, d.context))
     219                                        ),
     220                                        " ",
     221                                        React.createElement("div", {className: "inline"}, React.createElement("span", {className: "badge"}, "x ", d.counter))
     222                                );
     223        },
     224
     225        renderError: function(e) {
     226                var xc = e.exception;
     227                return  React.createElement("div", {key: xc.message},
     228                                        React.createElement("div", {className: "inline alert alert-danger", role: "alert"},
     229                                                React.createElement("div", null, "Exception: ", xc.message),
     230                                                React.createElement("div", null, "Context: ", React.createElement("a", {href: e.context}, e.context)),
     231                                                 xc.cause ? React.createElement("div", null, "Caused by: ", xc.cause) : false
     232                                        ),
     233                                        " ",
     234                                        React.createElement("div", {className: "inline"}, React.createElement("span", {className: "badge"}, "x ", e.counter))
     235                                );
     236        },
     237
     238        renderEndpoint: function(isScan, endpoint) {
    198239                var stat = endpoint[1];
    199                 var errors = _.pairs(stat.errors);
     240                var errors = _.values(stat.errors);
    200241                var diagnostics = _.values(stat.diagnostics);
    201                 return React.createElement("div", null,
    202                                         React.createElement("ul", {className: "list-inline list-unstyled"},
     242                return React.createElement("div", {style: {marginTop:10}},
     243                                        React.createElement("ul", {className: "list-inline list-unstyled", style: {marginBottom:0}},
    203244                                                React.createElement("li", null,
    204245                                                         stat.version == "LEGACY" ?
    205246                                                                React.createElement("span", {style: {color:'#a94442'}}, "legacy ", React.createElement("i", {className: "glyphicon glyphicon-thumbs-down"}), " ")
    206                                                                 : false,
     247                                                                : React.createElement("span", {style: {color:'#3c763d'}}, React.createElement("i", {className: "glyphicon glyphicon-thumbs-up"}), " "),
     248                                                       
    207249                                                         " "+endpoint[0], ":"
    208250                                                ),
    … …  
    213255                                                )
    214256                                        ),
     257                                         isScan ? this.renderCollections(stat.rootCollections) : false,
    215258                                                (errors && errors.length) ?
    216                                                 React.createElement("ul", {className: "list-unstyled inline", style: {marginLeft:40}},
    217                                                          errors.map(function(e) {
    218                                                                 return  React.createElement("div", null,
    219                                                                                         React.createElement("div", {className: "inline alert alert-danger"}, " Exception: ", e[0]),
    220                                                                                         " ",
    221                                                                                         React.createElement("div", {className: "inline"}, React.createElement("span", {className: "badge"}, "x ", e[1]))
    222                                                                                 );
    223                                                           })
     259                                                React.createElement("div", {className: "inline", style: {marginLeft:40}},
     260                                                         errors.map(this.renderError)
    224261                                                ) : false,
    225262                                       
    226263                                                (diagnostics && diagnostics.length) ?
    227                                                 React.createElement("ul", {className: "list-unstyled inline", style: {marginLeft:40}},
    228                                                          diagnostics.map(function(d) {
    229                                                                 return  React.createElement("div", null,
    230                                                                                         React.createElement("div", {className: "inline alert alert-warning"},
    231                                                                                                 "Diagnostic: ", d.diagnostic.dgnMessage, ": ", d.diagnostic.dgnDiagnostic
    232                                                                                         ),
    233                                                                                         " ",
    234                                                                                         React.createElement("div", {className: "inline"}, React.createElement("span", {className: "badge"}, "x ", d.counter))
    235                                                                                 );
    236                                                           })
     264                                                React.createElement("div", {className: "inline", style: {marginLeft:40}},
     265                                                         diagnostics.map(this.renderDiagnostic)
    237266                                                ) : false
    238267                                       
    … …  
    240269        },
    241270
    242         renderInstitution: function(inst) {
     271        renderInstitution: function(isScan, inst) {
    243272                return  React.createElement("div", {style: {marginBottom:30}},
    244273                                        React.createElement("h4", null, inst[0]),
    245                                         React.createElement("div", {style: {marginLeft:20}}, " ", _.pairs(inst[1]).map(this.renderEndpoint) )
     274                                        React.createElement("div", {style: {marginLeft:20}}, " ", _.pairs(inst[1]).map(this.renderEndpoint.bind(this, isScan)) )
    246275                                );
    247276        },
    248277
    249         renderStatistics: function(stats) {
     278        renderStatistics: function(isScan, stats) {
    250279                return  React.createElement("div", {className: "container"},
    251280                                        React.createElement("ul", {className: "list-inline list-unstyled"},
    … …  
    262291                                                React.createElement("li", null, "timeout:", " ", React.createElement("kbd", null, stats.timeout, " seconds"))
    263292                                        ),
    264                                         React.createElement("div", null, " ",  _.pairs(stats.institutions).map(this.renderInstitution), " ")
     293                                        React.createElement("div", null, " ",  _.pairs(stats.institutions).map(this.renderInstitution.bind(this, isScan)), " ")
    265294                                )
    266295                                 ;
    … …  
    273302                                        React.createElement("h1", null, "Statistics"),
    274303                                        React.createElement("h2", null, "Last scan"),
    275                                         this.renderStatistics(this.state.lastScanStats),
     304                                        this.renderStatistics(true, this.state.lastScanStats),
    276305                                        React.createElement("h2", null, "Searches since last scan"),
    277                                         this.renderStatistics(this.state.searchStats)
     306                                        this.renderStatistics(false, this.state.searchStats)
    278307                                )
    279308                        )
    … …  
    414443                                                React.createElement("a", {title: "about", href: "#", onClick: this.about},
    415444                                                React.createElement("span", {className: "glyphicon glyphicon-info-sign"}),
    416                                                 React.createElement("span", null, "VERSION 2.0.0.α16")
     445                                                React.createElement("span", null, VERSION)
    417446                                        )
    418447                                ),

  • SRUAggregator/trunk/src/main/resources/assets/js/main.jsx

    r5960 r5971  
    22(function() {
    33"use strict";
     4
     5var VERSION = "VERSION 2.0.0.α19";
    46
    57var PT = React.PropTypes;
    … …  
    195197        },
    196198
    197         renderEndpoint: function(endpoint) {
     199        renderCollections: function(colls) {
     200                return  <div style={{marginLeft:40}}>
     201                                        { colls.length === 0 ?
     202                                                <div style={{color:"#a94442"}}>NO collections found</div>
     203                                                :
     204                                                <div>
     205                                                        {colls.length} root collection(s):
     206                                                        <ul className='list-unstyled' style={{marginLeft:40}}>
     207                                                                { colls.map(function(name) { return <div>{name}</div>; }) }
     208                                                        </ul>
     209                                                </div>
     210                                        }
     211                                </div>;
     212        },
     213
     214        renderDiagnostic: function(d) {
     215                return  <div key={d.diagnostic.uri}>
     216                                        <div className="inline alert alert-warning">
     217                                                <div>Diagnostic: {d.diagnostic.message}: {d.diagnostic.diagnostic}</div>
     218                                                <div>Context: <a href={d.context}>{d.context}</a></div>
     219                                        </div>
     220                                        {" "}
     221                                        <div className="inline"><span className="badge">x {d.counter}</span></div>
     222                                </div>;
     223        },
     224
     225        renderError: function(e) {
     226                var xc = e.exception;
     227                return  <div key={xc.message}>
     228                                        <div className="inline alert alert-danger" role="alert">
     229                                                <div>Exception: {xc.message}</div>
     230                                                <div>Context: <a href={e.context}>{e.context}</a></div>
     231                                                { xc.cause ? <div>Caused by: {xc.cause}</div> : false}
     232                                        </div>
     233                                        {" "}
     234                                        <div className="inline"><span className="badge">x {e.counter}</span></div>
     235                                </div>;
     236        },
     237
     238        renderEndpoint: function(isScan, endpoint) {
    198239                var stat = endpoint[1];
    199                 var errors = _.pairs(stat.errors);
     240                var errors = _.values(stat.errors);
    200241                var diagnostics = _.values(stat.diagnostics);
    201                 return <div>
    202                                         <ul className='list-inline list-unstyled'>
     242                return <div style={{marginTop:10}}>
     243                                        <ul className='list-inline list-unstyled' style={{marginBottom:0}}>
    203244                                                <li>
    204245                                                        { stat.version == "LEGACY" ?
    205246                                                                <span style={{color:'#a94442'}}>legacy <i className="glyphicon glyphicon-thumbs-down"></i> </span>
    206                                                                 : false}
     247                                                                : <span style={{color:'#3c763d'}}><i className="glyphicon glyphicon-thumbs-up"></i> </span>
     248                                                        }
    207249                                                        { " "+endpoint[0] }:
    208250                                                </li>
    … …  
    213255                                                </li>
    214256                                        </ul>
     257                                        { isScan ? this.renderCollections(stat.rootCollections) : false }
    215258                                        {       (errors && errors.length) ?
    216                                                 <ul className='list-unstyled inline' style={{marginLeft:40}}>
    217                                                         { errors.map(function(e) {
    218                                                                 return  <div >
    219                                                                                         <div className="inline alert alert-danger"> Exception: {e[0]}</div>
    220                                                                                         {" "}
    221                                                                                         <div className="inline"><span className="badge">x {e[1]}</span></div>
    222                                                                                 </div>;
    223                                                           }) }
    224                                                 </ul> : false
     259                                                <div className='inline' style={{marginLeft:40}}>
     260                                                        { errors.map(this.renderError) }
     261                                                </div> : false
    225262                                        }
    226263                                        {       (diagnostics && diagnostics.length) ?
    227                                                 <ul className='list-unstyled inline' style={{marginLeft:40}}>
    228                                                         { diagnostics.map(function(d) {
    229                                                                 return  <div >
    230                                                                                         <div className="inline alert alert-warning">
    231                                                                                                 Diagnostic: {d.diagnostic.dgnMessage}: {d.diagnostic.dgnDiagnostic}
    232                                                                                         </div>
    233                                                                                         {" "}
    234                                                                                         <div className="inline"><span className="badge">x {d.counter}</span></div>
    235                                                                                 </div>;
    236                                                           }) }
    237                                                 </ul> : false
     264                                                <div className='inline' style={{marginLeft:40}}>
     265                                                        { diagnostics.map(this.renderDiagnostic) }
     266                                                </div> : false
    238267                                        }
    239268                                </div>;
    240269        },
    241270
    242         renderInstitution: function(inst) {
     271        renderInstitution: function(isScan, inst) {
    243272                return  <div style={{marginBottom:30}}>
    244273                                        <h4>{inst[0]}</h4>
    245                                         <div style={{marginLeft:20}}> {_.pairs(inst[1]).map(this.renderEndpoint) }</div>
     274                                        <div style={{marginLeft:20}}> {_.pairs(inst[1]).map(this.renderEndpoint.bind(this, isScan)) }</div>
    246275                                </div>;
    247276        },
    248277
    249         renderStatistics: function(stats) {
     278        renderStatistics: function(isScan, stats) {
    250279                return  <div className="container">
    251280                                        <ul className='list-inline list-unstyled'>
    … …  
    262291                                                <li>timeout:{" "}<kbd>{stats.timeout} seconds</kbd></li>
    263292                                        </ul>
    264                                         <div> { _.pairs(stats.institutions).map(this.renderInstitution) } </div>
     293                                        <div> { _.pairs(stats.institutions).map(this.renderInstitution.bind(this, isScan)) } </div>
    265294                                </div>
    266295                                 ;
    … …  
    273302                                        <h1>Statistics</h1>
    274303                                        <h2>Last scan</h2>
    275                                         {this.renderStatistics(this.state.lastScanStats)}
     304                                        {this.renderStatistics(true, this.state.lastScanStats)}
    276305                                        <h2>Searches since last scan</h2>
    277                                         {this.renderStatistics(this.state.searchStats)}
     306                                        {this.renderStatistics(false, this.state.searchStats)}
    278307                                </div>
    279308                        </div>
    … …  
    414443                                                <a title="about" href="#" onClick={this.about}>
    415444                                                <span className="glyphicon glyphicon-info-sign"></span>
    416                                                 <span>VERSION 2.0.0.α16</span>
     445                                                <span>{VERSION}</span>
    417446                                        </a>
    418447                                </div>

  • SRUAggregator/trunk/src/main/resources/assets/js/search.js

    r5960 r5971  
    219219                        return;                 
    220220                }
     221                var selectedIds = this.state.corpora.getSelectedIds();
     222                // console.log("searching in the following corpora:", selectedIds);
    221223                this.props.ajax({
    222224                        url: 'rest/search',
    … …  
    227229                                query: query,
    228230                                numberOfResults: this.state.numberOfResults,
    229                                 corporaIds: this.state.corpora.getSelectedIds(),
     231                                corporaIds: selectedIds,
    230232                        },
    231233                        success: function(searchId, textStatus, jqXHR) {
    … …  
    595597        },
    596598
     599        renderDiagnostic: function(d) {
     600                return  React.createElement("div", {className: "alert alert-warning"},
     601                                        React.createElement("div", null, "Diagnostic: ", d.diagnostic.message)
     602                                );
     603        },
     604
    597605        renderDiagnostics: function(corpusHit) {
    598606                if (!corpusHit.diagnostics || corpusHit.diagnostics.length === 0) {
    … …  
    600608                }
    601609
    602                 return corpusHit.diagnostics.map(function(d) {
    603                         return  React.createElement("div", {className: "alert alert-danger", role: "alert", key: d.dgnUri},
    604                                                 d.dgnMessage, ": ", d.dgnDiagnostic
    605                                         );
    606                 });
     610                return corpusHit.diagnostics.map(this.renderDiagnostic);
     611        },
     612
     613        renderErrors: function(corpusHit) {
     614                var xc = corpusHit.exception;
     615                if (!xc) {
     616                        return false;
     617                }
     618                return  (
     619                        React.createElement("div", {className: "alert alert-danger", role: "alert"},
     620                                React.createElement("div", null, "Exception: ", xc.message),
     621                                 xc.cause ? React.createElement("div", null, "Caused by: ", xc.cause) : false
     622                        )
     623                );
    607624        },
    608625
    … …  
    611628                if (this.state.displayKwic) {
    612629                        return  React.createElement("div", null,
     630                                                this.renderErrors(corpusHit),
    613631                                                this.renderDiagnostics(corpusHit),
    614632                                                React.createElement("table", {className: "table table-condensed table-hover", style: fulllength},
    … …  
    618636                } else {
    619637                        return  React.createElement("div", null,
     638                                                this.renderErrors(corpusHit),
    620639                                                this.renderDiagnostics(corpusHit),
    621640                                                corpusHit.kwics.map(this.renderRowsAsHits)
    … …  
    625644
    626645        renderResultPanels: function(corpusHit) {
    627                 if (corpusHit.kwics.length === 0 &&
     646                if (corpusHit.kwics.length === 0 &&
     647                        !corpusHit.exception &&
    628648                        corpusHit.diagnostics.length === 0) {
    629                         return false;
     649                                return false;
    630650                }
    631651                return  React.createElement(Panel, {key: corpusHit.corpus.title,
    … …  
    637657
    638658        renderToolbox: function() {
     659                if (this.props.requests.length > 0) {
     660                        return false;
     661                }
    639662                return  React.createElement("div", {className: "toolbox float-left"},
    640663                                        React.createElement("a", {className: "btn btn-default", href: this.props.getDownloadLink("text")},

  • SRUAggregator/trunk/src/main/resources/assets/js/search.jsx

    r5960 r5971  
    219219                        return;                 
    220220                }
     221                var selectedIds = this.state.corpora.getSelectedIds();
     222                // console.log("searching in the following corpora:", selectedIds);
    221223                this.props.ajax({
    222224                        url: 'rest/search',
    … …  
    227229                                query: query,
    228230                                numberOfResults: this.state.numberOfResults,
    229                                 corporaIds: this.state.corpora.getSelectedIds(),
     231                                corporaIds: selectedIds,
    230232                        },
    231233                        success: function(searchId, textStatus, jqXHR) {
    … …  
    595597        },
    596598
     599        renderDiagnostic: function(d) {
     600                return  <div className="alert alert-warning">
     601                                        <div>Diagnostic: {d.diagnostic.message}</div>
     602                                </div>;
     603        },
     604
    597605        renderDiagnostics: function(corpusHit) {
    598606                if (!corpusHit.diagnostics || corpusHit.diagnostics.length === 0) {
    … …  
    600608                }
    601609
    602                 return corpusHit.diagnostics.map(function(d) {
    603                         return  <div className="alert alert-danger" role="alert" key={d.dgnUri}>
    604                                                 {d.dgnMessage}{": "}{d.dgnDiagnostic}
    605                                         </div>;
    606                 });
     610                return corpusHit.diagnostics.map(this.renderDiagnostic);
     611        },
     612
     613        renderErrors: function(corpusHit) {
     614                var xc = corpusHit.exception;
     615                if (!xc) {
     616                        return false;
     617                }
     618                return  (
     619                        <div className="alert alert-danger" role="alert">
     620                                <div>Exception: {xc.message}</div>
     621                                { xc.cause ? <div>Caused by: {xc.cause}</div> : false}
     622                        </div>
     623                );
    607624        },
    608625
    … …  
    611628                if (this.state.displayKwic) {
    612629                        return  <div>
     630                                                {this.renderErrors(corpusHit)}
    613631                                                {this.renderDiagnostics(corpusHit)}
    614632                                                <table className="table table-condensed table-hover" style={fulllength}>
    … …  
    618636                } else {
    619637                        return  <div>
     638                                                {this.renderErrors(corpusHit)}
    620639                                                {this.renderDiagnostics(corpusHit)}
    621640                                                {corpusHit.kwics.map(this.renderRowsAsHits)}
    … …  
    625644
    626645        renderResultPanels: function(corpusHit) {
    627                 if (corpusHit.kwics.length === 0 &&
     646                if (corpusHit.kwics.length === 0 &&
     647                        !corpusHit.exception &&
    628648                        corpusHit.diagnostics.length === 0) {
    629                         return false;
     649                                return false;
    630650                }
    631651                return  <Panel key={corpusHit.corpus.title}
    … …  
    637657
    638658        renderToolbox: function() {
     659                if (this.props.requests.length > 0) {
     660                        return false;
     661                }
    639662                return  <div className="toolbox float-left">
    640663                                        <a className="btn btn-default" href={this.props.getDownloadLink("text")}>

  • SRUAggregator/trunk/src/test/java/eu/clarin/sru/fcs/aggregator/app/CQLEnumerationTest.java

    r5957 r5971  
    55import eu.clarin.sru.fcs.aggregator.scan.Endpoint;
    66import eu.clarin.sru.fcs.aggregator.scan.Institution;
     7import java.util.HashSet;
     8import java.util.List;
     9import java.util.Set;
    710import javax.naming.NamingException;
    811import org.junit.Ignore;
    … …  
    1720public class CQLEnumerationTest {
    1821
    19         @Test
    20         public void test() throws NamingException {
     22        public void printAll(String centerRegistryUrl) throws NamingException {
    2123
    2224                try {
    23                         String centerRegistryUrl = "https://centres-staging.clarin.eu:4430/restxml/";
    2425                        CenterRegistry centerRegistry = new CenterRegistryLive(centerRegistryUrl, null);
    25                         for (Institution institution : centerRegistry.getCQLInstitutions()) {
    26                                 System.out.println(institution.getName() + ": ");
     26                        List<Institution> list = centerRegistry.getCQLInstitutions();
     27                        for (Institution institution : list) {
     28                                System.out.println("1: " + institution.getName() + ": ");
    2729                                for (Endpoint e : institution.getEndpoints()) {
    28                                         System.out.println("\t -> " + e);
     30                                        System.out.println("1: \t -> " + e);
    2931                                }
    3032                        }
    31                         Assert.assertTrue(centerRegistry.getCQLInstitutions().size() > 10);
     33                        Assert.assertTrue(list.size() > 10);
     34                } finally {
     35                }
     36        }
     37
     38        @Test
     39        public void testPrintAll() throws NamingException {
     40                System.out.println("Official registry:\n========================");
     41                printAll("http://centerregistry-clarin.esc.rzg.mpg.de/restxml/");
     42
     43                System.out.println("Testing registry:\n========================");
     44                printAll("https://centres-staging.clarin.eu:4430/restxml/");
     45        }
     46
     47        @Test
     48        public void testEq() throws NamingException {
     49
     50                try {
     51                        Set<Endpoint> list1, list2;
     52                        {
     53                                String centerRegistryUrl = "http://centerregistry-clarin.esc.rzg.mpg.de/restxml/";
     54                                CenterRegistry centerRegistry = new CenterRegistryLive(centerRegistryUrl, null);
     55                                list1 = new HashSet<Endpoint>();
     56                                for (Institution i : centerRegistry.getCQLInstitutions()) {
     57                                        list1.addAll(i.getEndpoints());
     58                                }
     59                        }
     60
     61                        {
     62                                String centerRegistryUrl = "https://centres-staging.clarin.eu:4430/restxml/";
     63                                CenterRegistry centerRegistry = new CenterRegistryLive(centerRegistryUrl, null);
     64                                list2 = new HashSet<Endpoint>();
     65                                for (Institution i : centerRegistry.getCQLInstitutions()) {
     66                                        list2.addAll(i.getEndpoints());
     67                                }
     68                        }
     69
     70                        Assert.assertTrue(list1.size() > 10);
     71                        Assert.assertTrue(list2.size() > 10);
     72
     73                        for (Endpoint e : list1) {
     74                                Assert.assertTrue("testing registry does not contain " + e, list2.contains(e));
     75                        }
     76                        for (Endpoint e : list2) {
     77                                Assert.assertTrue("official registry does not contain " + e, list1.contains(e));
     78                        }
    3279                } finally {
    3380                }

  • SRUAggregator/trunk/src/test/java/eu/clarin/sru/fcs/aggregator/app/ScanCrawlerTest.java

    r5957 r5971  
    3737                        InitialContext context = new InitialContext();
    3838                        String centerRegistryUrl = (String) context.lookup("java:comp/env/center-registry-url");
    39                         CenterRegistry centerRegistry = new CenterRegistryLive(centerRegistryUrl, filter);
    40                         ScanCrawler crawler = new ScanCrawler(centerRegistry, sruClient, 2);
     39                        ScanCrawler crawler = new ScanCrawler(
     40                                        new CenterRegistryLive(centerRegistryUrl, filter).getCQLInstitutions(),
     41                                        sruClient, 2);
    4142                        Corpora cache = crawler.crawl();
    4243                        Corpus tueRootCorpus = cache.findByEndpoint("http://weblicht.sfs.uni-tuebingen.de/rws/sru/").get(0);
Note: See TracChangeset for help on using the changeset viewer.