private static void startTelemetryClient() { TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.getActive(); telemetryConfiguration.setInstrumentationKey(Globals.BUILD_INFO.getAzureInstrumentationKey()); telemetryConfiguration.setTrackingIsDisabled(!Globals.prefs.shouldCollectTelemetry()); telemetryClient = new TelemetryClient(telemetryConfiguration); telemetryClient.getContext().getProperties().put("JabRef version", Globals.BUILD_INFO.getVersion().toString()); telemetryClient.getContext().getProperties().put("Java version", StandardSystemProperty.JAVA_VERSION.value()); telemetryClient.getContext().getUser().setId(Globals.prefs.getOrCreateUserId()); telemetryClient.getContext().getSession().setId(UUID.randomUUID().toString()); telemetryClient.getContext().getDevice().setOperatingSystem(StandardSystemProperty.OS_NAME.value()); telemetryClient.getContext().getDevice().setOperatingSystemVersion(StandardSystemProperty.OS_VERSION.value()); telemetryClient.getContext().getDevice().setScreenResolution( Toolkit.getDefaultToolkit().getScreenSize().toString()); telemetryClient.trackSessionState(SessionState.Start); }
private boolean pathsOverlap(String firstPath, String secondPath) { if (firstPath.equals(secondPath)) { return true; } String shorter; String longer; if (firstPath.length() > secondPath.length()) { shorter = secondPath; longer = firstPath; } else { shorter = firstPath; longer = secondPath; } return longer.startsWith(shorter + StandardSystemProperty.FILE_SEPARATOR.value()); }
private JSch configureIdentity(final JSch jsch) throws JSchException { final File sshDirectory = new File(StandardSystemProperty.USER_HOME.value() + "/.ssh"); checkState(sshDirectory.exists(), ".ssh directory does not exist under home folder."); checkState(sshDirectory.canRead(), ".ssh directory content cannot be read."); checkState(sshDirectory.isDirectory(), sshDirectory.getAbsoluteFile() + " is not a directory."); final File[] keyFiles = sshDirectory.listFiles(); checkState(null != keyFiles && keyFiles.length > 0, "No SSH key files exist."); jsch.removeAllIdentity(); for (final File keyFile : keyFiles) { if (keyFile.isFile()) { final String keyUri = keyFile.toURI().toString(); final int lastIndexOf = keyUri.lastIndexOf("/"); if (lastIndexOf > 0) { final String keyFileName = keyUri.substring(lastIndexOf + 1); if ("id_rsa".equals(keyFileName) || "id_dsa".equals(keyFileName)) { if (isEncrypted(keyFile)) { String pw = getPassphrase(keyFile); jsch.addIdentity(keyFile.getAbsolutePath(), pw); } else { jsch.addIdentity(keyFile.getAbsolutePath()); } break; } } } } return jsch; }
private void groups(ServerBootstrap b) { if (StandardSystemProperty.OS_NAME.value().equals("Linux")) { bossGroup = new EpollEventLoopGroup(1); workerGroup = new EpollEventLoopGroup(); b.channel(EpollServerSocketChannel.class) .group(bossGroup, workerGroup) .option(EpollChannelOption.TCP_CORK, true); } else { bossGroup = new NioEventLoopGroup(1); workerGroup = new NioEventLoopGroup(); b.channel(NioServerSocketChannel.class) .group(bossGroup, workerGroup); } b.option(ChannelOption.TCP_NODELAY, true) .option(ChannelOption.SO_REUSEADDR, true) .option(ChannelOption.SO_BACKLOG, 100); logger.info("Bootstrap configuration: " + b.toString()); }
@Override protected void execute() throws Exception { checkState(!inputs.isEmpty(), "input is not set"); RxJavaBdioDocument document = new RxJavaBdioDocument(new BdioOptions.Builder().build()); StreamSupplier out = new BdioWriter.BdioFile(output.openStream()); BdioMetadata metadata = new BdioMetadata(); metadata.id(id.orElseGet(BdioObject::randomId)); metadata.publisher(ProductList.of(getProduct())); metadata.creationDateTime(ZonedDateTime.now()); metadata.creator(StandardSystemProperty.USER_NAME.value()); // Read all the configured inputs into a single sequence of entries Flowable<InputStream> data = Flowable.fromIterable(inputs).map(ByteSource::openStream); // Only collect limited entries for metadata if possible document.metadata(data.flatMap(in -> document.read(in).takeUntil((Predicate<Object>) ConcatenateTool::needsMoreMetadata))) .subscribe(m -> combineMetadata(metadata, m)) .isDisposed(); // Write the all the entries back out using the new metadata data.flatMap(document::read).subscribe(document.write(metadata, out)); }
private String computeIdentity(String type, String ref) { ToStringHelper helper = MoreObjects.toStringHelper(type) .add("type", "workflow") .add("config_path", mainConfigFile.relativeToRoot()) .add("workflow_name", this.name) .add("context_ref", ref); helper.add("user", workflowOptions.workflowIdentityUser != null ? workflowOptions.workflowIdentityUser : StandardSystemProperty.USER_NAME.value()); String identity = helper.toString(); String hash = BaseEncoding.base16().encode( Hashing.md5() .hashString(identity, StandardCharsets.UTF_8) .asBytes()); // Important to log the source of the hash and the hash for debugging purposes. logger.info("Computed migration identity hash for " + identity + " as " + hash); return hash; }
/** * Returns the base directory to be used by Copybara to write execution related files (Like * logs). */ private String getBaseExecDir() { // In this case we are not using GeneralOptions.getEnvironment() because we still haven't built // the options, but it's fine. This is the tool's Main and is also injecting System.getEnv() // to the options, so the value is the same. String userHome = StandardSystemProperty.USER_HOME.value(); switch (StandardSystemProperty.OS_NAME.value()) { case "Linux": String xdgCacheHome = System.getenv("XDG_CACHE_HOME"); return Strings.isNullOrEmpty(xdgCacheHome) ? userHome + "/.cache/" + COPYBARA_NAMESPACE : xdgCacheHome + COPYBARA_NAMESPACE; case "Mac OS X": return userHome + "/Library/Logs/" + COPYBARA_NAMESPACE; default: return "/var/tmp/" + COPYBARA_NAMESPACE; } }
@Before public void before() { try { final Path tmpPath = Paths.get(StandardSystemProperty.JAVA_IO_TMPDIR.value()); StringConcatenation _builder = new StringConcatenation(); _builder.append("tempFolder_"); UUID _randomUUID = UUID.randomUUID(); _builder.append(_randomUUID); final Path output = Files.createTempDirectory(tmpPath, _builder.toString()); final Path resource = Files.createFile(output.resolve(URIBasedFileSystemAccessTest.EXISTING_RESOURCE_NAME)); resource.toFile().deleteOnExit(); output.toFile().deleteOnExit(); final OutputConfiguration config = IterableExtensions.<OutputConfiguration>head(this.configProvider.getOutputConfigurations()); config.setOutputDirectory(output.toString()); Pair<String, OutputConfiguration> _mappedTo = Pair.<String, OutputConfiguration>of(IFileSystemAccess.DEFAULT_OUTPUT, config); this.fsa.setOutputConfigurations(Collections.<String, OutputConfiguration>unmodifiableMap(CollectionLiterals.<String, OutputConfiguration>newHashMap(_mappedTo))); this.fsa.setConverter(this.uriConverter); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
private void logSplitDocIdsTobeDeleted(DBObject query) { // Fetch only the id final BasicDBObject keys = new BasicDBObject(Document.ID, 1); List<String> ids; DBCursor cursor = getNodeCollection().find(query, keys) .setReadPreference(store.getConfiguredReadPreference(Collection.NODES)); try { ids = ImmutableList.copyOf(Iterables.transform(cursor, new Function<DBObject, String>() { @Override public String apply(@Nullable DBObject input) { return (String) input.get(Document.ID); } })); } finally { cursor.close(); } StringBuilder sb = new StringBuilder("Split documents with following ids were deleted as part of GC \n"); Joiner.on(StandardSystemProperty.LINE_SEPARATOR.value()).appendTo(sb, ids); log.debug(sb.toString()); }
public static synchronized String getKmsUrl(String id, Properties properties) { if (properties == null) { properties = new Properties(); } if (kmsUrlLoader == null) { Path configFile = Paths.get(StandardSystemProperty.USER_HOME.value(), ".kurento", "config.properties"); kmsUrlLoader = new KmsUrlLoader(configFile); } Object load = properties.get("loadPoints"); if (load == null) { return kmsUrlLoader.getKmsUrl(id); } else { if (load instanceof Number) { return kmsUrlLoader.getKmsUrlLoad(id, ((Number) load).intValue()); } else { return kmsUrlLoader.getKmsUrlLoad(id, Integer.parseInt(load.toString())); } } }
public static File createTempDir(String prefix) throws IOException { final int tempDirAttempts = 10000; String javaTempDir = MoreObjects.firstNonNull(StandardSystemProperty.JAVA_IO_TMPDIR.value(), "."); File baseDir = new File(javaTempDir); String baseName = prefix + "-" + System.currentTimeMillis() + "-"; for (int counter = 0; counter < tempDirAttempts; counter++) { File tempDir = new File(baseDir, baseName + counter); if (tempDir.mkdir()) { return tempDir; } } throw new IOException( "Failed to create directory within " + tempDirAttempts + " attempts (tried " + baseName + "0 to " + baseName + (tempDirAttempts - 1) + ')'); }
static void runViewer(Directories directories) throws InterruptedException { // initLogging() already called by OfflineViewer.main() checkNotNull(startupLogger); String version; try { version = Version.getVersion(MainEntryPoint.class); startupLogger.info("Glowroot version: {}", version); startupLogger.info("Java version: {}", StandardSystemProperty.JAVA_VERSION.value()); ImmutableMap<String, String> properties = getGlowrootProperties(directories.getConfDir(), directories.getSharedConfDir()); new EmbeddedGlowrootAgentInit(directories.getDataDir(), true) .init(directories.getPluginsDir(), directories.getConfDir(), directories.getSharedConfDir(), directories.getLogDir(), directories.getTmpDir(), directories.getGlowrootJarFile(), properties, null, version); } catch (AgentDirsLockedException e) { logAgentDirsLockedException(directories.getConfDir(), e.getLockFile()); return; } catch (Throwable t) { startupLogger.error("Glowroot cannot start: {}", t.getMessage(), t); return; } // Glowroot does not create any non-daemon threads, so need to block jvm from exiting when // running the viewer Thread.sleep(Long.MAX_VALUE); }
@RequiresNonNull("startupLogger") private static void start(Directories directories, Map<String, String> properties, @Nullable Instrumentation instrumentation) throws Exception { ManagementFactory.getThreadMXBean().setThreadCpuTimeEnabled(true); ManagementFactory.getThreadMXBean().setThreadContentionMonitoringEnabled(true); String version = Version.getVersion(MainEntryPoint.class); startupLogger.info("Glowroot version: {}", version); startupLogger.info("Java version: {}", StandardSystemProperty.JAVA_VERSION.value()); String collectorAddress = properties.get("glowroot.collector.address"); Collector customCollector = loadCustomCollector(directories.getGlowrootDir()); if (Strings.isNullOrEmpty(collectorAddress) && customCollector == null) { glowrootAgentInit = new EmbeddedGlowrootAgentInit(directories.getDataDir(), false); } else { if (customCollector != null) { startupLogger.info("using collector: {}", customCollector.getClass().getName()); } String collectorAuthority = properties.get("glowroot.collector.authority"); glowrootAgentInit = new NonEmbeddedGlowrootAgentInit(collectorAddress, collectorAuthority, customCollector); } glowrootAgentInit.init(directories.getPluginsDir(), directories.getConfDir(), directories.getSharedConfDir(), directories.getLogDir(), directories.getTmpDir(), directories.getGlowrootJarFile(), properties, instrumentation, version); }
private static JavaInfo createJavaInfo(String glowrootVersion, JvmConfig jvmConfig, RuntimeMXBean runtimeMXBean) { String jvm = ""; String javaVmName = StandardSystemProperty.JAVA_VM_NAME.value(); if (javaVmName != null) { jvm = javaVmName + " (" + StandardSystemProperty.JAVA_VM_VERSION.value() + ", " + System.getProperty("java.vm.info") + ")"; } String javaVersion = StandardSystemProperty.JAVA_VERSION.value(); String heapDumpPath = getHeapDumpPathFromCommandLine(); if (heapDumpPath == null) { String javaTempDir = MoreObjects.firstNonNull(StandardSystemProperty.JAVA_IO_TMPDIR.value(), "."); heapDumpPath = new File(javaTempDir).getAbsolutePath(); } return JavaInfo.newBuilder() .setVersion(Strings.nullToEmpty(javaVersion)) .setVm(jvm) .addAllArg(SystemProperties.maskJvmArgs(runtimeMXBean.getInputArguments(), jvmConfig.maskSystemProperties())) .setHeapDumpDefaultDir(heapDumpPath) .setGlowrootAgentVersion(glowrootVersion) .build(); }
private static List<String> buildClasspath(@Nullable File glowrootJarFile) { if (glowrootJarFile == null || !isShaded()) { // this is just to support testing List<String> classpath = Lists.newArrayList(); if (glowrootJarFile != null) { classpath.add(glowrootJarFile.getAbsolutePath()); } classpath.addAll(splitClasspath(StandardSystemProperty.JAVA_CLASS_PATH.value())); for (String jvmArg : ManagementFactory.getRuntimeMXBean().getInputArguments()) { if (jvmArg.startsWith("-Xbootclasspath/a:")) { classpath.addAll( splitClasspath(jvmArg.substring("-Xbootclasspath/a:".length()))); break; } } return classpath; } else { return ImmutableList.of(glowrootJarFile.getAbsolutePath()); } }
public static void main(String[] args) throws IOException { MatlabServerCLIOptions options = new MatlabServerCLIOptions() .setPort(DEFAULT_PORT) .setThreads(DEFAULT_THREADS) .setPath(StandardSystemProperty.USER_DIR.value()); JCommander cli = new JCommander(options); cli.setProgramName("java " + MatlabServerCLI.class.getName()); MatlabServerConfiguration config = null; try { cli.parse(args); config = createConfig(options); } catch (ParameterException e) { cli.usage(); printAndExit(e); } if (options.isHelp()) { cli.usage(); } else { try { start(config); } catch (Exception ex) { printAndExit(ex); } } }
private static File getTempFolder() { final String tempFolder = StandardSystemProperty.JAVA_IO_TMPDIR.value(); final File file = new File(tempFolder); if (!file.exists() || !file.canWrite()) { throw new RuntimeException("Cannot access temporary directory under: " + tempFolder); } return file; }
/** * @return The project path. If it is not specified as a JVM parameter it will be set equal to * user.dir folder. */ public static Path getProjectPath() { if (GraknSystemProperty.CURRENT_DIRECTORY.value() == null) { GraknSystemProperty.CURRENT_DIRECTORY.set(StandardSystemProperty.USER_DIR.value()); } return Paths.get(GraknSystemProperty.CURRENT_DIRECTORY.value()); }
public static void main(String[] args) throws IOException { String workingDirectory = StandardSystemProperty.USER_DIR.value(); LOGGER.info("Starting server; Working directory is {}", workingDirectory); if (args.length < REQUIRED_ARGUMENTS_COUNT) { LOGGER.error("No configuration file provided"); return; } ServerConfiguration serverConfiguration = parseConfiguration(args[0]); Server server = serverConfiguration.build(); server.serveBlocking(); }
public OptionsBuilder setOutputRootToTmpDir() throws IOException { general = new GeneralOptions( general.getEnvironment(), general.getFileSystem(), general.isVerbose(), general.console(), general.getConfigRoot(), // Using Files.createTempDirectory() generates paths > 255 in some tests and that causes // 'File name too long' exceptions in Linux FileSystems.getDefault().getPath(StandardSystemProperty.JAVA_IO_TMPDIR.value()), general.isNoCleanup(), general.isDisableReversibleCheck(), general.isForced(), /*outputLimit*/ 0); return this; }
@Before public void setup() throws IOException, RepoException { workdir = Files.createTempDirectory("workdir"); options = new OptionsBuilder() .setWorkdirToRealTempDir() .setHomeDir(StandardSystemProperty.USER_HOME.value()); Files.createDirectory(workdir.resolve("dir")); Files.write(workdir.resolve("test.txt"), new byte[]{}); Files.write(workdir.resolve("dir/file.txt"), new byte[]{}); excludedPathsForDeletion = ImmutableList.of(); skylark = new SkylarkTestExecutor(options, FolderModule.class); }
@Before public void setup() throws IOException, RepoException { workdir = Files.createTempDirectory("workdir"); options = new OptionsBuilder() .setWorkdirToRealTempDir() .setHomeDir(StandardSystemProperty.USER_HOME.value()); skylark = new SkylarkTestExecutor(options, FolderModule.class); }
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!isAllowed(sender, command)) { sender.sendMessage(org.bukkit.ChatColor.DARK_RED + "Not whitelisted"); return true; } RuntimeMXBean runtimeBean = ManagementFactory.getRuntimeMXBean(); //java info sender.sendMessage(PRIMARY_COLOR + "Java VM: " + SECONDARY_COLOR + runtimeBean.getVmName()); sender.sendMessage(PRIMARY_COLOR + "Java Version: " + SECONDARY_COLOR + StandardSystemProperty.JAVA_VERSION.value()); sender.sendMessage(PRIMARY_COLOR + "Java Vendor: " + SECONDARY_COLOR + runtimeBean.getVmVendor() + ' ' + runtimeBean.getVmVersion()); //vm specification sender.sendMessage(PRIMARY_COLOR + "Spec name: " + SECONDARY_COLOR + runtimeBean.getSpecName()); sender.sendMessage(PRIMARY_COLOR + "Spec Vendor: " + SECONDARY_COLOR + runtimeBean.getSpecVendor()); sender.sendMessage(PRIMARY_COLOR + "Spec Version: " + SECONDARY_COLOR + runtimeBean.getSpecVersion()); //class loading ClassLoadingMXBean classBean = ManagementFactory.getClassLoadingMXBean(); sender.sendMessage(PRIMARY_COLOR + "Loaded Classes: " + SECONDARY_COLOR + classBean.getLoadedClassCount()); sender.sendMessage(PRIMARY_COLOR + "Total Loaded: " + SECONDARY_COLOR + classBean.getTotalLoadedClassCount()); sender.sendMessage(PRIMARY_COLOR + "Unloaded Classes: " + SECONDARY_COLOR + classBean.getUnloadedClassCount()); //garbage collector List<GarbageCollectorMXBean> gcBean = ManagementFactory.getGarbageCollectorMXBeans(); for (GarbageCollectorMXBean collector : gcBean) { sender.sendMessage(PRIMARY_COLOR + "Garbage Collector: " + SECONDARY_COLOR + collector.getName()); sender.sendMessage(PRIMARY_COLOR + " Time: " + SECONDARY_COLOR + collector.getCollectionTime()); sender.sendMessage(PRIMARY_COLOR + " Count: " + SECONDARY_COLOR + collector.getCollectionCount()); } return true; }
public static OperatingSystem getOs() { final String os = StandardSystemProperty.OS_NAME.value(); if (os.toLowerCase().startsWith("linux")) { return OperatingSystem.LINUX; } else if (os.toLowerCase().startsWith("windows")) { return OperatingSystem.WINDOWS; } else { throw new RuntimeException("Operating system \"" + os + "\" not supported."); } }
public NativesInfo getNativesInfoForCurrentPlatform() { Os currentOs = Os.getCurrentOs(); String currentArch = getCanonicalArchitecture( StandardSystemProperty.OS_ARCH.value() ).toUpperCase(); return nativesTable.get( currentOs.name(), currentArch ); }
/** * The description of the environment. * * @return a formatted {@link StringBuilder} to describe the * environment instance. */ default StringBuilder getDescription() { final String newLine = StandardSystemProperty.LINE_SEPARATOR.value(); final StringBuilder sb = new StringBuilder(""); sb.append(newLine); try (final Formatter f = new Formatter(sb)) { final String format = "%1$24s %2$s" + newLine; sb.append(newLine); f.format(format, "OS", StandardSystemProperty.OS_NAME.value() + " " + StandardSystemProperty.OS_ARCH.value() + " " + StandardSystemProperty.OS_VERSION.value()); f.format(format, "Java Runtime", System.getProperty("java.runtime.name") + " " + System.getProperty("java.runtime.version")); f.format(format, "Java VM", StandardSystemProperty.JAVA_VM_NAME.value() + " " + StandardSystemProperty.JAVA_VM_VENDOR.value() + " " + StandardSystemProperty.JAVA_VM_VERSION.value()); f.format(format, "Java Class Ver.", StandardSystemProperty.JAVA_CLASS_VERSION.value()); f.format(format, "Environment ID", getId()); f.format(format, "Environment Ver.", Environment.class.getPackage().getImplementationVersion()); f.format(format, "Environment Name", getEnvironmentName()); f.format(format, "Runtime Mode", RuntimeMode.fromEnvironment(this)); f.format(format, "Application", getApplicationName()); f.format(format, "Application Root", getApplicationRoot()); f.format(format, "Application Logs", getApplicationLogsRoot()); f.format(format, "Server Host", getServerHost()); f.format(format, "Server Port", getServerPort()); sb.append(newLine); } catch (Exception e) { // Ignore } return sb; }
/** * builds a file environment by reading the information from an options object. * Throws an unsupported operations exception if the options are malformed (i.e. * no main file supplied) */ public FileEnvironment(Options options,BuiltinQuery query){ this.query = query; //parse main file String main = ""; if (options.main() != null && options.main().length() > 0){ main = options.main(); } else { List<String> list = options.files(); if (list != null && list.size() > 0){ main = list.get(0); } } if (main.length() == 0) throw new UnsupportedOperationException("no main file provided"); this.main = GenericFile.create(main); if (this.main == null || !this.main.exists()){ throw new UnsupportedOperationException("file "+main+" not found"); } this.pwd = this.main.getParent(); this.pwdHandler = FolderHandler.getFolderHandler(this.pwd); //get path @SuppressWarnings("unchecked") List<String> paths = (List<String>)options.lp(); if (paths == null || paths.size() == 0){ this.natlabPath = MatlabPath.getNatlabPath(); this.matlabPath = MatlabPath.getMatlabPath(); } else { this.natlabPath = new MatlabPath(paths.stream() .collect(Collectors.joining(StandardSystemProperty.PATH_SEPARATOR.value()))); } this.folderHandlers = getFolderHandlers(); }
/** * creates a path environment from the ';'-separated String of directories * if the persistent flag is set, the directories will be cached persistently * (i.e. they will be more quickly available during the next VM session) */ public MatlabPath(String path,boolean persistent){ super(null); this.persistent = persistent; if (path == null || path.length() == 0){ return; } //put all directories in for (String s : Splitter.on(StandardSystemProperty.PATH_SEPARATOR.value()).split(path)) { GenericFile file = GenericFile.create(s); DirectoryCache.put(file,persistent); directories.add(DirectoryCache.get(file)); } }
public static void testProgFile() { StringBuffer inline = null; String basePath = StandardSystemProperty.USER_DIR.value() + "/languages/Natlab/test/"; //System.out.println(basePath); String filename = basePath + "prettyprinttest.in"; try { Scanner reader = new Scanner(new File(filename)); inline = new StringBuffer(); while ( reader.hasNext() ) inline.append(reader.nextLine() + '\n' ); } catch(Exception e){ e.printStackTrace(); } Assert.assertNotNull(inline.toString()); System.out.println("=======================Input================================="); System.out.println(inline); String line1 = genFile(filename); Assert.assertNotNull(line1); writeToFile(line1, "parsedprettyprinttest.out" ); String line2 = genFile("parsedprettyprinttest.out"); Assert.assertNotNull(line2); writeToFile(line2, "parsedprettyprinttest.out" ); String regex = "%Declare [a-z A-Z]*\n"; System.out.println("=======================Input'================================="); System.out.println(line1); System.out.println("=======================Input''================================="); System.out.println(line2); // compare results; exclude those strings matching the pattern from the comparison Assert.assertTrue("Different ", line1.replaceAll(regex, "").equals(line2.replaceAll(regex, "")) ); }
@Before public void before() throws Exception { defaultEnv = new HashMap<>(); String name = UUID.randomUUID().toString(); defaultEnv.put(Environment.APPLICATION_NAME, name); defaultEnv.put(name + Environment.ROOT_SUFFIX, StandardSystemProperty.JAVA_IO_TMPDIR.value()); defaultEnv.put(name + Environment.SERVER_HOST_SUFFIX, "localhost"); defaultEnv.put(name + Environment.SERVER_PORT_SUFFIX, "7777"); env = Environment.createEnvironment(defaultEnv); }
public static void verifyJvmRequirements() { String specVersion = StandardSystemProperty.JAVA_SPECIFICATION_VERSION.value(); if ((specVersion == null) || (specVersion.compareTo("1.8") < 0)) { failRequirement("Presto requires Java 1.8+ (found %s)", specVersion); } String vendor = StandardSystemProperty.JAVA_VENDOR.value(); if (!"Oracle Corporation".equals(vendor)) { failRequirement("Presto requires an Oracle or OpenJDK JVM (found %s)", vendor); } String dataModel = System.getProperty("sun.arch.data.model"); if (!"64".equals(dataModel)) { failRequirement("Presto requires a 64-bit JVM (found %s)", dataModel); } String osName = StandardSystemProperty.OS_NAME.value(); String osArch = StandardSystemProperty.OS_ARCH.value(); if ("Linux".equals(osName)) { if (!"amd64".equals(osArch)) { failRequirement("Presto requires x86-64 or amd64 on Linux (found %s)", osArch); } } else if ("Mac OS X".equals(osName)) { if (!"x86_64".equals(osArch)) { failRequirement("Presto requires x86_64 on Mac OS X (found %s)", osArch); } } else { failRequirement("Presto requires Linux or Mac OS X (found %s)", osName); } if (!ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)) { failRequirement("Presto requires a little endian platform (found %s)", ByteOrder.nativeOrder()); } verifySlice(); }
public static Path createTemporaryPath(HdfsEnvironment hdfsEnvironment, Path targetPath) { // use a per-user temporary directory to avoid permission problems // TODO: this should use Hadoop UserGroupInformation String temporaryPrefix = "/tmp/presto-" + StandardSystemProperty.USER_NAME.value(); // create a temporary directory on the same filesystem Path temporaryRoot = new Path(targetPath, temporaryPrefix); Path temporaryPath = new Path(temporaryRoot, randomUUID().toString()); createDirectory(hdfsEnvironment, temporaryPath); return temporaryPath; }
@Subscribe public void onSourceRemovedEvent(SourceRemovedEvent event) throws InterruptedException, TimeoutException, IOException { if (event.getSource() == this) { try { // Stop the camera service and wait for it to terminate. // If we just use stopAsync(), the camera service won't always have terminated by the time // a new camera source is added. For webcam sources, this means that the video stream // won't be freed and new sources won't be able to connect to the webcam until the // application is closed. if (StandardSystemProperty.OS_NAME.value().toLowerCase(Locale.ENGLISH).contains("mac")) { // Workaround for #716. This affects webcams as well as IP camera sources. // Use only stopAsync() to avoid blocking. Since we have no way of knowing when // the capture has actually been freed, we use a dumb delay to try to make sure it's // freed before returning. THIS IS NOT A GOOD SOLUTION. But it's the best one we have // until the bug is fixed. stopAsync(); try { // Wait a bit to try to make sure the capture is actually freed before returning Thread.sleep(100); } catch (InterruptedException ignore) { // We did our best. Hopefully, the webcam has been freed at this point. Thread.currentThread().interrupt(); } } else { this.stopAndAwait(); } } finally { this.eventBus.unregister(this); } } }
@Override public FrameGrabber create(int deviceNumber) { // On Windows, videoInput is much more reliable for webcam capture. On other platforms, // OpenCV's frame // grabber class works fine. if (StandardSystemProperty.OS_NAME.value().contains("Windows")) { return new VideoInputFrameGrabber(deviceNumber); } else { return new OpenCVFrameGrabber(deviceNumber); } }