Get Runtime Info

@api private
767688
function getRuntimeInfo() {
  var execPath = fs.realpathSync(process.execPath); // resolve symbolic link

  var runtime = execPath
               .split(/[\\/]+/).pop()
               .split('.').shift();

  runtime = runtime === 'nodejs' ? 'node' : runtime;

  return {
    name: runtime,
    execPath: execPath
  };
}
1280258
def get_runtime_value(self, ihcid: int):
        
        if self.client.get_runtime_value(ihcid):
            return True
        self.re_authenticate()
        return self.client.get_runtime_value(ihcid)
66499
def info(version=nil, &block)
      if version.nil?
        if block_given?
          @global_info.instance_eval(&block)
        else
          @global_info
        end
      else
        i = @infos[version]
        if block_given?
          i.instance_eval(&block)
        end
        i
      end
    end
1270308
def x_runtime(f, *args, **kwargs):
    """"""

    _t0 = now()
    r = f(*args, **kwargs)
    _t1 = now()
    r.headers['X-Runtime'] = '{0}s'.format(Decimal(str(_t1 - _t0)))

    return r
1131815
function getBasicInfo() {
    const result = {};
    for (const key in info) {
        if (info.hasOwnProperty(key)) {
            result[key] = info[key]();
        }
    }
    return result;
}
1173775
def extractRuntime(runtime_dirs):
    
    names = [str(item) for name in runtime_dirs for item in os.listdir(name)]
    string = '\n'.join(names)
    result = extract(RUNTIME_PATTERN, string, condense=True)
    return result
1020699
function runtimeReq(mId) {
  const parsed = parse(mId);
  return _fetch(parsed.cleanId)
  .then(response => {
    // ensure default user space
    define.switchToUserSpace();

    for (let i = 0, len = _translators.length; i < len; i++) {
      const result = _translators[i](parsed, response);
      if (result && typeof result.then === 'function') return result;
    }
    throw new Error(`no runtime translator to handle ${parsed.cleanId}`);
  })
  .then(() => {
    if (userSpace.has(parsed.cleanId)) return userSpace.req(parsed.cleanId);
    throw new Error(`module "${parsed.cleanId}" is missing from url "${toUrl(mId)}"`);
  })
  .catch(err => {
    console.error(`could not load module "${parsed.cleanId}" from remote`); // eslint-disable-line no-console
    throw err;
  });
}
157277
def get_runtime_configuration(self):
        # type: () -> RuntimeConfiguration
        
        request_mapper = GenericRequestMapper(
            request_handler_chains=self.request_handler_chains)
        exception_mapper = GenericExceptionMapper(
            exception_handlers=self.exception_handlers)
        handler_adapter = GenericHandlerAdapter()

        runtime_configuration = RuntimeConfiguration(
            request_mappers=[request_mapper],
            handler_adapters=[handler_adapter],
            exception_mapper=exception_mapper,
            request_interceptors=self.global_request_interceptors,
            response_interceptors=self.global_response_interceptors)

        return runtime_configuration
974297
def getAppDTMInfo( dbid )
      @dbid = dbid

      sendRequest( :getAppDTMInfo )

      @requestTime = getResponseElement( "RequestTime" )
      @requestNextAllowedTime = getResponseElement( "RequestNextAllowedTime" )
      @app = getResponseElement( "app" )
      @lastModifiedTime = getResponsePathValue( "app/lastModifiedTime" )
      @lastRecModTime = getResponsePathValue( "app/lastRecModTime" )
      @tables = getResponseElement( :tables )

      return self if @chainAPIcalls

      if @app and @tables and block_given?
         @app.each { |element| yield element }
         @tables.each { |element| yield element }
      else
         return @app, @tables
      end
   end
1313084
def cli_info(self, event):
        """"""

        self.log('Instance:', self.instance,
                 'Dev:', self.development,
                 'Host:', self.host,
                 'Port:', self.port,
                 'Insecure:', self.insecure,
                 'Frontend:', self.frontendtarget)
1170314
def runtime_import(object_path):
    """"""
    obj_module, obj_element = object_path.rsplit(".", 1)
    loader = __import__(obj_module, globals(), locals(), [str(obj_element)])
    return getattr(loader, obj_element)
1237850
private String getRuntimeLibrary(final CommandLineCompilerConfiguration compilerConfig, final boolean isDebug) {
    String rtl = null;
    final String[] args = compilerConfig.getPreArguments();
    for (final String arg : args) {
      if (arg.startsWith("/MT")) {
        if (isDebug) {
          rtl = "1";
        } else {
          rtl = "0";
        }
      } else if (arg.startsWith("/MD")) {
        if (isDebug) {
          rtl = "3";
        } else {
          rtl = "2";
        }
      }
    }
    return rtl;
  }
915982
function () {
            var self = this;
            return self.packageInfo ||
                (self.packageInfo = getPackage(self.runtime, self.name));
        }
410482
private String prepareBundledRuntime() {
        try {
            String directory = Files.createTempDirectory("jsii-java-runtime").toString();

            String entrypoint = extractResource(getClass(), "jsii-runtime.js", directory);
            extractResource(getClass(), "jsii-runtime.js.map", directory);
            extractResource(getClass(), "mappings.wasm", directory);
            return entrypoint;
        } catch (IOException e) {
            throw new JsiiException("Unable to extract bundle of jsii-runtime.js from jar", e);
        }
    }
394814
public static function runtime($context) {
        $class = new \ReflectionClass($context['runtime']);
        $ret = '';
        $methods = static::getClassMethods($context, $class);

        $exports = array_keys($context['usedCount']['runtime']);

        while (true) {
            if (array_sum(array_map(function ($name) use (&$exports, $methods) {
                $n = 0;
                foreach ($methods[$name][1] as $child => $count) {
                    if (!in_array($child, $exports)) {
                       $exports[] = $child;
                       $n++;
                    }
                }
                return $n;
            }, $exports)) == 0) {
                break;
            }
        }

        foreach ($exports as $export) {
            $ret .= ($methods[$export][0] . "\n");
        }

        return $ret;
    }
462343
function (runtime, modNames) {
            var mods = [runtime], mod,
                unalias,
                allOk,
                m,
                runtimeMods = runtime.Env.mods;

            S.each(modNames, function (modName) {
                mod = runtimeMods[modName];
                if (!mod || mod.getType() != 'css') {
                    unalias = Utils.unalias(runtime, modName);
                    allOk = S.reduce(unalias, function (a, n) {
                        m = runtimeMods[n];
                        return a && m && m.status == ATTACHED;
                    }, true);
                    if (allOk) {
                        mods.push(runtimeMods[unalias[0]].value);
                    } else {
                        mods.push(null);
                    }
                }
            });

            return mods;
        }
596214
function showRunningStatus(version, config, isShowDevInfo) {
    colorsLog.info(`[i] MockStar@${version} is running for ${config.options.rootPath}`);

    colorsLog.info(getIpList().map(function (ip) {
        return '       http://' + colorsLog.colors.bold(ip) + (config.options.port ? ':' + config.options.port : '');
    }).join('\n'));

    if (isShowDevInfo) {
        colorsLog.info('[i] pid=' + config.pid);
        colorsLog.info('\n' + JSON.stringify(config, null, 2));
    }
}