running the service, and return the result
762907
public Object execute(TargetMetaDef targetMetaDef, MethodMetaArgs methodMetaArgs, AppContextWrapper acw) throws Exception {
		Debug.logVerbose("[JdonFramework]enter service execution core ", module);
		userTargetMetaDefFactory.createTargetMetaRequest(targetMetaDef, acw);
		TargetMetaRequest targetMetaRequest = userTargetMetaDefFactory.targetMetaRequestsHolder.getTargetMetaRequest();
		targetMetaRequest.setMethodMetaArgs(methodMetaArgs);
		return webServiceAccessor.execute();
	}
770884
def get_results(self):
        '''
        
        '''
        self._event.wait()
        if self._exception is not None:
            #
            # Well... rethrownig the exception caught in execute
            # but on the caller thread
            #
            raise self._exception  # pylint: disable=E0702
        return self._result
1290270
def run():
    """"""
    args = parse()
    build_results = [build(p) for p in glob.iglob(glob_path)]

    if not args['publish']:
        return

    for entry in build_results:
        publish(entry)
360172
def execute(self, return_results=True):
        '''
        
        '''
        if self.results:
            return self.results if return_results else None

        self.execute_raw()

        if self._raw_results_only:
            self.results = self.raw_results
        else:
            self.map_results()

        if return_results:
            return self.results
347860
def run(self):
        """"""
        # Catch all possible exceptions raised by the running thread
        # and let parent process know about it.
        try:
            self._run()
        except Exception:  # pylint: disable=broad-except
            self.action.put(
                ServiceCheckDiedError(self.name, traceback.format_exc())
            )
783407
def _run(self):
        
        while self.running:
            try:
                result = self.client_api.call('GetFeed', type_name=self.type_name, search=self.search,
                                              from_version=self._version, results_limit=self.results_limit)
                self._version = result['toVersion']
                self.listener.on_data(result['data'])
            except api.MyGeotabException as exception:
                if self.listener.on_error(exception) is False:
                    break
            if not self.running:
                break
            sleep(self.interval)
        self.running = False
1180651
def run(self):
        
        self._logger.info("running for <{url}>".format(url=self._url))

        args = format_args(self._options)
        self._logger.debug("command: `{cmd}` / args: {args}".
                           format(cmd=self._cmd, args=args))

        # run the process
        try:
            process = Popen(
                args=[self._cmd] + args,
                stdin=PIPE,
                stdout=PIPE,
                stderr=PIPE
            )

            pid = process.pid
            self._logger.debug("running as PID #{pid}".format(pid=pid))
        except OSError as ex:
            raise PhantomasRunError(
                "Failed to run phantomas: {0}".format(ex), ex.errno)

        # wait to complete
        try:
            stdout, stderr = process.communicate()
            returncode = process.returncode
        except Exception:
            raise PhantomasRunError("Failed to complete the run")

        # for Python 3.x - decode bytes to string
        stdout = stdout.decode('utf8')
        stderr = stderr.decode('utf8')

        # check the response code
        self._logger.debug("completed with return code #{returncode}".
                           format(returncode=returncode))

        if stderr != '':
            self._logger.debug("stderr: {stderr}".format(stderr=stderr))

            raise PhantomasFailedError(stderr.strip(), returncode)

        # try parsing the response
        try:
            results = json.loads(stdout)
        except Exception:
            raise PhantomasResponseParsingError("Unable to parse the response")

        if self._options.get("runs", 0) > 1:
            return Runs(self._url, results)
        else:
            return Results(self._url, results)
1297147
function _run() {
    _verifyCWD();

    var customStartupFilePath = path.resolve(process.cwd() + '/bin/www');

    if (fs.existsSync(customStartupFilePath)) {
        require(customStartupFilePath);
    } else if (fs.existsSync(PROJECT_INDEX)) {
        let service = require(PROJECT_INDEX);
        if (!(service instanceof Service)) {
            utils._stderr(`${PROJECT_INDEX} does not export a Service object`);
            process.exit(1);
        }

        service.listen();
    }
}
1170254
def service_action(self, service, action):
        ""
        try:
            service = api.get_cluster(self.cluster).get_service(service)
        except ApiException:
            print("Service not found")
            return None

        if action == "start":
            service.start()
        if action == "restart":
            service.restart()
        if action == "stop":
            service.stop()

        return True
910971
def _get_result(future, pipe, timeout):
    """"""
    counter = count(step=SLEEP_UNIT)

    try:
        while not pipe.poll(SLEEP_UNIT):
            if timeout is not None and next(counter) >= timeout:
                return TimeoutError('Task Timeout', timeout)
            elif future.cancelled():
                return CancelledError()

        return pipe.recv()
    except (EOFError, OSError):
        return ProcessExpired('Abnormal termination')
    except Exception as error:
        return error
69921
def run():
    
    plugin_list = load_plugins()

    module = sys.modules['__main__']
    plugin_list.insert(0, ObjectSupplier(module))

    return run_with_plugins(plugin_list)
285528
def run(self):
        """"""
        self.compile()

        s = "%s&format=%s" % (self.compiled_str, self.format)
        s = "%s%s&env=%s" % (self.endpoint, s, urllib.parse.quote(self.store))

        self.conn.request("GET", s)
        r = self.conn.getresponse()
        r = r.read().decode('UTF-8')
        if self.format is "json":
            return json.loads(r)
        else:
            return r
1216493
def Run(self):
        ""
        inputs = self.GetInput()
        return SendInput(
            len(inputs),
            ctypes.byref(inputs),
            ctypes.sizeof(INPUT))
1217124
def run(self):
        
        luigi.LocalTarget(path=self.fixture).copy(self.output().path)
163119
def run(wrapped):
    

    @wraps(wrapped)
    def _run(self, query, bindings=None, *args, **kwargs):
        self._reconnect_if_missing_connection()

        start = time.time()
        try:
            result = wrapped(self, query, bindings, *args, **kwargs)
        except Exception as e:
            result = self._try_again_if_caused_by_lost_connection(
                e, query, bindings, wrapped
            )

        t = self._get_elapsed_time(start)
        self.log_query(query, bindings, t)

        return result

    return _run
648433
def run(cls):
        
        if not all(v is None for v in cls._services.values()):
            cls._set_host_id()
            cls._setup_logging()
            cls._set_process_name()
            cls._set_signal_handlers()
            cls._start_server()
        else:
            cls._logger.error('No services to host')
261863
def run(self):
        """"""
        (task_id, tasks) = self.server.get_task()
        self.task_store.from_dict(tasks)
        for (index, task) in self.task_store:
            result = self.compute(index, task)
            self.results.append(result)
        self.server.task_done((task_id, self.results))