cdmlib-remote/src/main/java/eu/etaxonomy/cdm/remote/controller/ManagementController.java

   1 /**
   2  * Copyright (C) 2007 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9 package eu.etaxonomy.cdm.remote.controller;
  10
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Map;
  14 import java.util.UUID;
  15
  16 import javax.servlet.http.HttpServletRequest;
  17 import javax.servlet.http.HttpServletResponse;
  18
  19 import org.apache.log4j.Logger;
  20 import org.springframework.beans.factory.annotation.Autowired;
  21 import org.springframework.stereotype.Controller;
  22 import org.springframework.web.bind.WebDataBinder;
  23 import org.springframework.web.bind.annotation.CrossOrigin;
  24 import org.springframework.web.bind.annotation.InitBinder;
  25 import org.springframework.web.bind.annotation.RequestMapping;
  26 import org.springframework.web.bind.annotation.RequestMethod;
  27 import org.springframework.web.bind.annotation.RequestParam;
  28 import org.springframework.web.servlet.ModelAndView;
  29
  30 import eu.etaxonomy.cdm.api.service.search.ICdmMassIndexer;
  31 import eu.etaxonomy.cdm.database.DataSourceInfo;
  32 import eu.etaxonomy.cdm.database.DataSourceReloader;
  33 import eu.etaxonomy.cdm.model.common.CdmBase;
  34 import eu.etaxonomy.cdm.remote.controller.util.ProgressMonitorUtil;
  35 import eu.etaxonomy.cdm.remote.editor.CdmTypePropertyEditor;
  36 import io.swagger.annotations.Api;
  37
  38 @Controller
  39 @Api("manage")
  40 @CrossOrigin(origins="*")
  41 @RequestMapping(value = { "/manage" })
  42 public class ManagementController {
  43     public static final Logger logger = Logger
  44             .getLogger(ManagementController.class);
  45
  46     // @Autowired
  47     private DataSourceReloader datasoucrceLoader;
  48
  49     @Autowired
  50     public ICdmMassIndexer indexer;
  51
  52     @Autowired
  53     public ProgressMonitorController progressMonitorController;
  54
  55     /**
  56      * There should only be one processes operating on the lucene index
  57      * therefore the according progress monitor uuid is stored in this static
  58      * field.
  59      */
  60     private static UUID indexMonitorUuid = null;
  61
  62     @InitBinder
  63     public void initIndexClassBinder(WebDataBinder binder) {
  64         binder.registerCustomEditor(Class.class, new CdmTypePropertyEditor());
  65     }
  66
  67     @InitBinder
  68     public void initIndexArrayBinder(WebDataBinder binder) {
  69         binder.registerCustomEditor(Class[].class, new CdmTypePropertyEditor());
  70     }
  71
  72     /*
  73      * return page not found http error (404) for unknown or incorrect UUIDs
  74      * (non-Javadoc)
  75      *
  76      * @see
  77      * org.springframework.web.servlet.mvc.AbstractController#handleRequestInternal
  78      * (javax.servlet.http.HttpServletRequest,
  79      * javax.servlet.http.HttpServletResponse)
  80      */
  81     // @RequestMapping(value = { "/manager/datasources/list" }, method =
  82     // RequestMethod.GET)
  83     protected ModelAndView doList(HttpServletRequest request,
  84             HttpServletResponse respone) throws Exception {
  85
  86         ModelAndView mv = new ModelAndView();
  87         Map<String, DataSourceInfo> dataSourceInfos = datasoucrceLoader.test();
  88         mv.addObject(dataSourceInfos);
  89
  90         return mv;
  91     }
  92
  93     // @RequestMapping(value = { "/manager/datasources/reload" }, method =
  94     // RequestMethod.GET)
  95     public ModelAndView doReload(HttpServletRequest request,
  96             HttpServletResponse respone) throws Exception {
  97
  98         ModelAndView mv = new ModelAndView();
  99         Map<String, DataSourceInfo> dataSourceInfos = datasoucrceLoader
 100                 .reload();
 101         mv.addObject(dataSourceInfos);
 102
 103         return mv;
 104     }
 105
 106     /**
 107      *
 108      * Reindex all cdm entities listed in
 109      * {@link ICdmMassIndexer#indexedClasses()}. Re-indexing will not purge the
 110      * index.
 111      *
 112      * @param frontendBaseUrl
 113      *            if the CDM server is running behind a reverse proxy you need
 114      *            to supply the base URL of web service front-end which is
 115      *            provided by the proxy server.
 116      * @param request
 117      * @param respone
 118      * @return
 119      * @throws Exception
 120      */
 121     @RequestMapping(value = { "reindex" }, method = {RequestMethod.GET, RequestMethod.OPTIONS})
 122     public synchronized ModelAndView doReindex(
 123              @RequestParam(value = "frontendBaseUrl", required = false) String frontendBaseUrl,
 124              @RequestParam(value = "type", required = false) Class<? extends CdmBase>[] types,
 125              @RequestParam(value = "priority", required = false) Integer priority,
 126              @RequestParam(value = "dataRedirect", required = false) boolean dataRedirect,
 127             HttpServletRequest request, HttpServletResponse response)
 128             throws Exception {
 129
 130         final List<Class<? extends CdmBase>> typeSet = asList(types);
 131
 132         String processLabel = "Re-indexing";
 133
 134         ProgressMonitorUtil progressUtil = new ProgressMonitorUtil(
 135                 progressMonitorController);
 136
 137         if (!progressMonitorController.isMonitorRunning(indexMonitorUuid)) {
 138             indexMonitorUuid = progressUtil.registerNewMonitor();
 139             Thread subThread = new Thread() {
 140                 @Override
 141                 public void run() {
 142                     indexer.reindex(typeSet, progressMonitorController.getMonitor(indexMonitorUuid));
 143                 }
 144             };
 145             if (priority == null) {
 146                 priority = AbstractController.DEFAULT_BATCH_THREAD_PRIORITY;
 147             }
 148             subThread.setPriority(priority);
 149             subThread.start();
 150         }
 151         // send redirect "see other"
 152         return progressUtil.respondWithMonitor(frontendBaseUrl, processLabel,
 153                 indexMonitorUuid, dataRedirect, request, response);
 154     }
 155
 156     /**
 157      * @param types
 158      */
 159     private List<Class<? extends CdmBase>> asList(Class<? extends CdmBase>[] types) {
 160
 161         List<Class<? extends CdmBase>> typeList = null;
 162         if(types != null) {
 163             typeList = new ArrayList<Class<? extends CdmBase>>();
 164             for (Class<? extends CdmBase> type : types) {
 165                 if(type != null && ! typeList.contains(type)) {
 166                     typeList.add(type);
 167                 }
 168             }
 169         }
 170         return typeList;
 171     }
 172
 173     /**
 174      *
 175      * Create dictionaries for all cdm entities listed in
 176      * {@link ICdmMassIndexer#dictionaryClasses()}. Re-dicting will not purge
 177      * the dictionaries.
 178      *
 179      * @param frontendBaseUrl
 180      *            if the CDM server is running behind a reverse proxy you need
 181     *            to supply the base URL of web service front-end which is
 182     *            provided by the proxy server.
 183     * @param request
 184     * @param respone
 185     * @return
 186     * @throws Exception
 187     */
 188    @RequestMapping(value = { "redict" }, method = {RequestMethod.GET, RequestMethod.OPTIONS})
 189     public synchronized ModelAndView doRedict(
 190             @RequestParam(value = "frontendBaseUrl", required = false) String frontendBaseUrl,
 191             @RequestParam(value = "priority", required = false) Integer priority,
 192             @RequestParam(value = "dataRedirect", required = false) boolean dataRedirect,
 193             HttpServletRequest request, HttpServletResponse response)
 194             throws Exception {
 195
 196        String processLabel = "Re-Dicting";
 197         ProgressMonitorUtil progressUtil = new ProgressMonitorUtil(
 198                 progressMonitorController);
 199
 200         if (!progressMonitorController.isMonitorRunning(indexMonitorUuid)) {
 201            indexMonitorUuid = progressUtil.registerNewMonitor();
 202             Thread subThread = new Thread() {
 203                @Override
 204                 public void run() {
 205                     indexer.createDictionary(progressMonitorController
 206                             .getMonitor(indexMonitorUuid));
 207                }
 208            };
 209             if (priority == null) {
 210                priority = AbstractController.DEFAULT_BATCH_THREAD_PRIORITY;
 211            }
 212            subThread.setPriority(priority);
 213            subThread.start();
 214        }
 215        // send redirect "see other"
 216         return progressUtil.respondWithMonitor(frontendBaseUrl, processLabel,
 217                 indexMonitorUuid, dataRedirect, request, response);
 218    }
 219
 220     /**
 221      * This will wipe out the index.
 222      *
 223      * @param request
 224      * @param respone
 225      * @return
 226      * @throws Exception
 227      */
 228     @RequestMapping(value = { "purge" }, method = {RequestMethod.GET, RequestMethod.OPTIONS})
 229     public synchronized ModelAndView doPurge(
 230             @RequestParam(value = "frontendBaseUrl", required = false) String frontendBaseUrl,
 231             @RequestParam(value = "priority", required = false) Integer priority,
 232             @RequestParam(value = "dataRedirect", required = false) boolean dataRedirect,
 233             HttpServletRequest request, HttpServletResponse response)
 234             throws Exception {
 235
 236         String processLabel = "Purging";
 237
 238         ProgressMonitorUtil progressUtil = new ProgressMonitorUtil(
 239                 progressMonitorController);
 240
 241         if (!progressMonitorController.isMonitorRunning(indexMonitorUuid)) {
 242             indexMonitorUuid = progressUtil.registerNewMonitor();
 243             Thread subThread = new Thread() {
 244                 @Override
 245                 public void run() {
 246                     indexer.purge(progressMonitorController
 247                             .getMonitor(indexMonitorUuid));
 248                 }
 249             };
 250             if (priority == null) {
 251                 priority = AbstractController.DEFAULT_BATCH_THREAD_PRIORITY;
 252             }
 253             subThread.setPriority(priority);
 254             subThread.start();
 255         }
 256
 257         // send redirect "see other"
 258         return progressUtil.respondWithMonitor(frontendBaseUrl, processLabel,
 259                 indexMonitorUuid, dataRedirect, request, response);
 260     }
 261
 262
 263
 264 }