org.openspaces.rest.space.SpaceTaskAPIController.java Source code

Introduction

Here is the source code for org.openspaces.rest.space.SpaceTaskAPIController.java

Source

/*
 * Copyright 2011 GigaSpaces Technologies Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at *
 *     
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License."
 */
package org.openspaces.rest.space;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Logger;

import org.openspaces.core.GigaSpace;
import org.openspaces.remoting.scripting.ExecutorScriptingProxyConfigurer;
import org.openspaces.remoting.scripting.ScriptingExecutor;
import org.openspaces.remoting.scripting.StaticScript;
import org.openspaces.rest.utils.ControllerUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

/**
 * Spring MVC controller for the RESTful Space API (Task Execution)
 * 
 */
@Controller
@RequestMapping(value = "/rest/task/*")
public class SpaceTaskAPIController {
    private static final Logger log = Logger.getLogger(SpaceTaskAPIController.class.getName());

    public SpaceTaskAPIController() {
        super();
    }

    /**
     * Execute task on supplied space.  Space must be running the remoting
     * service exporter
     * 
     * @return
     */
    @RequestMapping(value = "/execute", method = RequestMethod.POST)
    public ModelAndView executeTask(@RequestParam String spaceName, @RequestParam String locators,
            @RequestBody SpaceTaskRequest body) {
        return execute(spaceName, locators, body);
    }

    private ModelAndView execute(String spaceName, String locators, final SpaceTaskRequest request) {
        GigaSpace space = ControllerUtils.xapCache.get(spaceName, locators);
        final int instanceCount = ControllerUtils.xapCache.getInstances(spaceName);
        ExecutorService svc = Executors.newFixedThreadPool(instanceCount);
        int instances = 0;

        log.fine("request.target=" + request.target);
        if (request.target != null && !request.target.equals("all")) {
            instances = 1;
        } else {
            instances = instanceCount;
        }

        System.out.println("instances=" + instances);

        List<Callable<Object>> tasks = new ArrayList<Callable<Object>>(instances);
        for (int i = 0; i < instances; i++) {
            Object routing = 0;
            if (request.target != null && request.target.equals("all")) {
                routing = i;
            } else {
                routing = request.target;
            }
            tasks.add(new ScriptCallable(space, request, routing));
        }

        ModelAndView mv = new ModelAndView("jsonView");
        List<Object> model = new ArrayList<Object>(instances);
        try {
            List<Future<Object>> results = svc.invokeAll(tasks);

            for (Future<Object> fut : results) {
                if (fut.get() != null)
                    model.add(fut.get());
            }
            mv.addObject("results", model);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            svc.shutdownNow();
        }
        return mv;
    }

    protected static class SpaceTaskRequest {
        public Object target;
        public String language;
        public String code;

        public Object getTarget() {
            return target;
        }

        public void setTarget(Object target) {
            this.target = target;
        }

        public String getLanguage() {
            return language;
        }

        public void setLanguage(String language) {
            this.language = language;
        }

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

    }

    private static class ScriptCallable implements Callable<Object> {
        private final GigaSpace space;
        private final StaticScript script;

        public ScriptCallable(final GigaSpace space, final SpaceTaskRequest req, Object routing) {
            this.space = space;
            script = new StaticScript("resttask" + UUID.randomUUID().toString(), req.language, req.code);
            script.routing(routing);
        }

        @Override
        public Object call() throws Exception {
            ScriptingExecutor<Object> executor = new ExecutorScriptingProxyConfigurer<Object>(space)
                    .scriptingExecutor();

            return executor.execute(script);
        }
    }

}