public UnfilteredRowIterator deserialize(DataInputPlus in, int version, CFMetaData metadata, SerializationHelper.Flag flag, Header header) throws IOException { if (header.isEmpty) return EmptyIterators.unfilteredRow(metadata, header.key, header.isReversed); final SerializationHelper helper = new SerializationHelper(metadata, version, flag); final SerializationHeader sHeader = header.sHeader; return new AbstractUnfilteredRowIterator(metadata, header.key, header.partitionDeletion, sHeader.columns(), header.staticRow, header.isReversed, sHeader.stats()) { private final Row.Builder builder = BTreeRow.sortedBuilder(); protected Unfiltered computeNext() { try { Unfiltered unfiltered = UnfilteredSerializer.serializer.deserialize(in, sHeader, helper, builder); return unfiltered == null ? endOfData() : unfiltered; } catch (IOException e) { throw new IOError(e); } } }; }
protected Unfiltered computeNext() { while (true) { try { if (!deserializer.hasNext()) return endOfData(); Unfiltered unfiltered = deserializer.readNext(); if (metadata.isStaticCompactTable() && unfiltered.kind() == Unfiltered.Kind.ROW) { Row row = (Row) unfiltered; ColumnDefinition def = metadata.getColumnDefinition(LegacyLayout.encodeClustering(metadata, row.clustering())); if (def != null && def.isStatic()) continue; } return unfiltered; } catch (IOException e) { throw new IOError(e); } } }
@Override public void uncaughtException(Thread t, Throwable e) { if (isFatalUncaught(e)) { try { onFatalUncaught(t.getName(), e); } finally { // we use specific error codes in case the above notification failed, at least we // will have some indication of the error bringing us down if (e instanceof InternalError) { halt(128); } else if (e instanceof OutOfMemoryError) { halt(127); } else if (e instanceof StackOverflowError) { halt(126); } else if (e instanceof UnknownError) { halt(125); } else if (e instanceof IOError) { halt(124); } else { halt(1); } } } else { onNonFatalUncaught(t.getName(), e); } }
public CentralDogmaSecurityManager(File dataDir, Ini securityConfig) { try { sessionDao = new FileBasedSessionDAO(new File(dataDir, "_sessions").toPath()); } catch (IOException e) { throw new IOError(e); } sessionManager = new CentralDogmaSessionManager(sessionDao); final Factory<SecurityManager> factory = new IniSecurityManagerFactory(securityConfig) { @Override protected SecurityManager createDefaultInstance() { DefaultSecurityManager securityManager = new DefaultSecurityManager(); securityManager.setSessionManager(sessionManager); securityManager.setCacheManager(new MemoryConstrainedCacheManager()); return securityManager; } }; delegate = factory.getInstance(); }
/** * Constructor. * @param module Working module */ public SandboxedPrologContext(Module module) throws IOError { this.workingModule = module; // Load the Mochalog Prolog bridge API into the given // Prolog context try { // Ignore output from pack_install routine // TODO: Remove need to force re-upgrade (currently in place due to error logging prove("pack_install('@A', [interactive(false), silent(true), upgrade(true)])", PackLoader.getPackResource("mochalog")); // Build against Mochalog API module prove("use_module(library(mochalog))"); } catch (IOException e) { throw new IOError(e); } }
/** * Convert unvalidated path object to fully validated * path string. * @param path Unvalidated file path * @return Validated path string * @throws IOException IO error occurred. */ public static String getResolvableFilePath(Path path) throws IOException { // Ensure valid file path was supplied if (!Files.exists(path)) { throw new IOException("Specified file path could not be resolved"); } try { // Convert to absolute path with forward-slash file // separators Path absolutePath = path.toAbsolutePath(); return absolutePath.toString().replace('\\', '/'); } catch (IOError e) { throw new IOException("File path could not be converted " + "to absolute file path."); } }
/** * Returns the base directory or URL for the given URL. Used to implement __DIR__. * @param url a URL * @return base path or URL, or null if argument is not a hierarchical URL */ public static String baseURL(final URL url) { try { final URI uri = url.toURI(); if (uri.getScheme().equals("file")) { final Path path = Paths.get(uri); final Path parent = path.getParent(); return (parent != null) ? (parent + File.separator) : null; } if (uri.isOpaque() || uri.getPath() == null || uri.getPath().isEmpty()) { return null; } return uri.resolve("").toString(); } catch (final SecurityException | URISyntaxException | IOError e) { return null; } }
@Override public void write(PropertyMap propertyMap) { try { jsonWriter.writeStartObject(); jsonWriter.writeObjectFieldStart("prop"); jsonWriter.writeStartObject(); for (String s : propertyMap.properties.keySet()) { jsonWriter.writeObjectFieldStart(s); DataRef ref = propertyMap.properties.get(s); if(ref instanceof CoreRef) { ((CoreRef) ref).write(this); } else { throw new UnsupportedOperationException("Only core properties are supported with PropertyMap!"); } } jsonWriter.writeEndObject(); jsonWriter.writeEndObject(); } catch (IOException e) { throw new IOError(e); } }
@Override public void writeIntArray(int[] intValues) { try { jsonWriter.writeStartObject(); jsonWriter.writeArrayFieldStart("intarray"); for (int value : intValues) { jsonWriter.writeNumber(value); } jsonWriter.writeEndArray(); jsonWriter.writeEndObject(); } catch (IOException e) { throw new IOError(e); } }
@Override public void writeLongArray(long[] longValues) { try { jsonWriter.writeStartObject(); jsonWriter.writeArrayFieldStart("longarray"); for (long value : longValues) { jsonWriter.writeNumber(value); } jsonWriter.writeEndArray(); jsonWriter.writeEndObject(); } catch (IOException e) { throw new IOError(e); } }
@Override public void writeDocumentArray(MemoryDocument[] docValues) { try { jsonWriter.writeStartObject(); jsonWriter.writeObjectFieldStart("docarray"); jsonWriter.writeStartArray(docValues.length); for (MemoryDocument document : docValues) { MemoryJsonLevel0Codec.INSTANCE.encode(document, jsonWriter); } jsonWriter.writeEndArray(); jsonWriter.writeEndObject(); jsonWriter.writeEndObject(); } catch (IOException e) { throw new IOError(e); } }
public void writeProperties(Object2ObjectOpenHashMap<String,DataRef> props) { try { writer.writeStartObject(); for (Object2ObjectMap.Entry<String, DataRef> entry : props.object2ObjectEntrySet()) { writer.writeFieldName(entry.getKey()); if(entry.getValue() instanceof CoreRef) { CoreRef prop = (CoreRef)(entry.getValue()); prop.write(propwriter); } else throw new UnsupportedOperationException("Only CoreRefs are supported for encoding."); } writer.writeEndObject(); } catch (IOException e) { throw new IOError(e); } }
private PropertySet[] readPropertySets(PropertyKey[] keys, Int2ObjectOpenHashMap<IntArrayList> pkeyid2setid) { int numPropertySets = reader.readVarInt(true); if(numPropertySets < 0) throw new IOError(new IOException("Failed to read property sets, count is negative: " + numPropertySets)); PropertySet[] propertySets = new PropertySet[numPropertySets]; for(int i = 0; i < numPropertySets; i++) { int numKeys = reader.readVarInt(true); PropertyKey[] propertySet = new PropertyKey[numKeys]; for(int k = 0; k < numKeys; k++) { int pkey; propertySet[k] = keys[pkey = reader.readVarInt(true)]; getPkey2IdList(pkeyid2setid, pkey).add(i); } propertySets[i] = new PropertySet(propertySet); } return propertySets; }
/** @return true if the buffer has been resized. */ protected boolean require (int required) { if (capacity - position >= required) return false; if (required > maxCapacity) throw new IOError(new IOException("Buffer overflow. Max capacity: " + maxCapacity + ", required: " + required)); flush(); while (capacity - position < required) { if (capacity == maxCapacity) throw new IOError(new IOException("Buffer overflow. Available: " + (capacity - position) + ", required: " + required)); // Grow buffer. if (capacity == 0) capacity = 1; capacity = Math.min(capacity * 2, maxCapacity); if (capacity < 0) capacity = maxCapacity; byte[] newBuffer = new byte[capacity]; System.arraycopy(buffer, 0, newBuffer, 0, position); buffer = newBuffer; } return true; }
public static byte[] compress(byte[] data) { try { //Heuristic, 75% compression. Output compressed = new Output(32,2147483647); GZIPOutputStream gzipOutputStream = new GZIPOutputStream(compressed, 1 << 12); Output output = new Output(gzipOutputStream); output.writeVarInt(data.length, true); output.write(data); output.close(); return compressed.toBytes(); } catch (IOException e) { throw new IOError(e); } }
public static ByteBuffer compress(ByteBuffer data) { try { //Heuristic, 75% compression. ByteBufferOutputStream bufferOutputStream = new ByteBufferOutputStream(); GZIPOutputStream gzipOutputStream = new GZIPOutputStream(bufferOutputStream, 1 << 12); Output output = new Output(gzipOutputStream); output.writeVarInt(data.remaining(), true); output.write(data); output.close(); ByteBuffer buffer = bufferOutputStream.buffer(); buffer.flip(); return buffer; } catch (IOException e) { throw new IOError(e); } }
@Inject public AnchorLookup(@Model(MODEL) Resource resource, @LanguageCode String language) { try { this.language = language; System.out.println("Loading anchor lookup map for " + language); BufferedReader reader = new BufferedReader(new InputStreamReader(new GZIPInputStream(resource.binaryRead()))); String line = null; while((line = reader.readLine()) != null) { String[] split = line.split("\t", 2); String source = split[0]; String target = split[1]; lookup.put(source, target); } } catch (IOException e) { throw new IOError(e); } }
@Inject public SimpleWordSet(@Model(MODEL_ID) Resource resource) { BufferedReader reader = new BufferedReader(resource.textRead()); String line; try { while( (line = reader.readLine()) != null) { String trimmed = line.trim(); if(trimmed.length() == 0) continue; words.add(trimmed); } } catch (IOException e) { throw new IOError(e); } }
public static Iterator<OnDiskAtom> onDiskIterator(final DataInput in, final ColumnSerializer.Flag flag, final int expireBefore, final Descriptor.Version version, final CellNameType type) { return new AbstractIterator<OnDiskAtom>() { protected OnDiskAtom computeNext() { OnDiskAtom atom; try { atom = type.onDiskAtomSerializer().deserializeFromSSTable(in, flag, expireBefore, version); } catch (IOException e) { throw new IOError(e); } if (atom == null) return endOfData(); return atom; } }; }
private static void printHistory(String... args) { //don't bother to print if no args passed (meaning, nodetool is just printing out the sub-commands list) if (args.length == 0) return; String cmdLine = Joiner.on(" ").skipNulls().join(args); cmdLine = cmdLine.replaceFirst("(?<=(-pw|--password))\\s+\\S+", " <hidden>"); try (FileWriter writer = new FileWriter(new File(FBUtilities.getToolsOutputDirectory(), HISTORYFILE), true)) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS"); writer.append(sdf.format(new Date())).append(": ").append(cmdLine).append(System.lineSeparator()); } catch (IOException | IOError ioe) { //quietly ignore any errors about not being able to write out history } }
public void append(byte[] buffer, int start, int end, boolean checksumIncrementalResult) { try { int incrementalChecksumValue; incrementalChecksum.update(buffer, start, end); incrementalChecksumValue = (int) incrementalChecksum.getValue(); incrementalOut.writeInt(incrementalChecksumValue); incrementalChecksum.reset(); fullChecksum.update(buffer, start, end); if (checksumIncrementalResult) { ByteBuffer byteBuffer = ByteBuffer.allocate(4); byteBuffer.putInt(incrementalChecksumValue); fullChecksum.update(byteBuffer.array(), 0, byteBuffer.array().length); } } catch (IOException e) { throw new IOError(e); } }
public static StressProfile load(URI file) throws IOError { try { Constructor constructor = new Constructor(StressYaml.class); Yaml yaml = new Yaml(constructor); InputStream yamlStream = file.toURL().openStream(); if (yamlStream.available() == 0) throw new IOException("Unable to load yaml file from: "+file); StressYaml profileYaml = yaml.loadAs(yamlStream, StressYaml.class); StressProfile profile = new StressProfile(); profile.init(profileYaml); return profile; } catch (YAMLException | IOException | RequestValidationException e) { throw new IOError(e); } }
private static DB constructDB(String dbFile) { DB db; try{ DBMaker dbMaker = DBMaker.newFileDB(new File(dbFile)); db = dbMaker .transactionDisable() .mmapFileEnable() .asyncWriteEnable() .compressionEnable() // .cacheSize(1024 * 1024) this bloats memory consumption .make(); return db; } catch (ExecutionError | IOError | Exception e) { LOG.error("Could not construct db from file.", e); return null; } }
@Override public String readLine(String prompt) { try { if (System.console() != null) { return System.console().readLine(prompt); } else { if (prompt != null) { write(prompt); } BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); return reader.readLine(); } } catch (IOException e) { throw new IOError(e); } }
public String readLine(String fmt, Object... args) { String line = null; synchronized (this.writeLock) { synchronized (this.readLock) { if (fmt.length() != 0) { this.writer.format(fmt, args); } try { char[] ca = this.readline(false); if (ca != null) { line = new String(ca); } } catch (IOException x) { throw new IOError(x); } } } return line; }
@Override public void onCustomerPicked(Customer customer) { TicketFragment tFrag = getTicketFragment(); tFrag.setCustomer(customer); tFrag.updateView(); if (mPager.getCurrentItem() != CATALOG_FRAG) { updatePaymentFragment(tFrag, null); } disposeTicketFragment(tFrag); try { Data.Session.save(mContext); } catch (IOError ioe) { Log.e(LOG_TAG, "Unable to save session", ioe); Error.showError(R.string.err_save_session, this); } }
private void closeCashAction() throws IOException { Data.Cash.currentCash(this).closeNow(); Data.Cash.dirty = true; // Archive and create a new cash CashArchive.archiveCurrent(); Data.Cash.clear(this); int cashRegId = Data.CashRegister.current(this).getId(); Data.Cash.setCash(new Cash(cashRegId)); Data.Receipt.clear(this); try { Data.Cash.save(this); } catch (IOError e) { Log.e(LOG_TAG, "Unable to save cash", e); Error.showError(R.string.err_save_cash, this); } Data.Session.clear(this); }
/** * On check result */ @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { switch (resultCode) { case Activity.RESULT_CANCELED: // Check canceled, undo close this.undoClose(); break; case Activity.RESULT_OK: if (data.hasExtra("inventory")) { Inventory inv = (Inventory) data.getSerializableExtra("inventory"); Data.Cash.currentCash(this).setCloseInventory(inv); try { Data.Cash.save(this); } catch (IOError e) { Log.e(LOG_TAG, "Unable to save cash", e); Error.showError(R.string.err_save_cash, this); } } // Continue close process this.closeCash(); break; } }
@Override public void load(Context ctx) throws DataCorruptedException, IOError { int objectsNumber = getNumberOfObjects(); List<Type> classes = getClassList(); List<Object> result = new ArrayList<>(); Gson gson = getGson(); JsonParser parser = new JsonParser(); String stringFile = null; try { stringFile = file.read(); JsonElement tradeElement = parser.parse(stringFile); JsonArray array = tradeElement.getAsJsonArray(); for (int i = 0; i < objectsNumber; i++) { Object objectToAdd = gson.fromJson(gson.toJson(array.get(i)), classes.get(i)); result.add(i, objectToAdd); } } catch (JsonSyntaxException | FileNotFoundException | IllegalStateException e) { throw newException(e, stringFile); } if (result.size() != getObjectList().size()) { throw newException(null, stringFile); } this.recoverObjects(result); }
protected SemanticSpace getSpace() { try { int dimensions = argOptions.getIntOption("dimensions", 300); Transform transform = new LogEntropyTransform(); if (argOptions.hasOption("preprocess")) transform = ReflectionUtil.getObjectInstance( argOptions.getStringOption("preprocess")); String algName = argOptions.getStringOption("svdAlgorithm", "ANY"); MatrixFactorization factorization = SVD.getFactorization( Algorithm.valueOf(algName.toUpperCase())); basis = new StringBasisMapping(); return new LatentSemanticAnalysis( false, dimensions, transform, factorization, false, basis); } catch (IOException ioe) { throw new IOError(ioe); } }
/** * Extracts entries into the directory. * @param source the source archive file * @param destination the destination file */ public static void extract(File source, File destination) { try (ZipInputStream input = new ZipInputStream(open(source))) { while (true) { ZipEntry entry = input.getNextEntry(); if (entry == null) { break; } File target = new File(destination, entry.getName()); if (entry.isDirectory()) { mkdir(target); } else { copy(input, target); } } } catch (IOException e) { throw new IOError(e); } }
/** * Extracts entries into the directory. * @param source the source archive input stream * @param destination the destination file */ public static void extract(ZipInputStream source, File destination) { try { while (true) { ZipEntry entry = source.getNextEntry(); if (entry == null) { break; } File target = new File(destination, entry.getName()); if (entry.isDirectory()) { mkdir(target); } else { copy(source, target); } } } catch (IOException e) { throw new IOError(e); } }
protected Unfiltered computeNext() { try { if (!deserializer.hasNext()) return endOfData(); Unfiltered unfiltered = deserializer.readNext(); if (metadata.isStaticCompactTable() && unfiltered.kind() == Unfiltered.Kind.ROW) { Row row = (Row) unfiltered; ColumnDefinition def = metadata.getColumnDefinition(LegacyLayout.encodeClustering(metadata, row.clustering())); if (def != null && def.isStatic()) return computeNext(); } return unfiltered; } catch (IOException e) { throw new IOError(e); } }
public static Closeable markDirectoriesUnwriteable(ColumnFamilyStore cfs) { try { for ( ; ; ) { DataDirectory dir = cfs.getDirectories().getWriteableLocation(1); BlacklistedDirectories.maybeMarkUnwritable(cfs.getDirectories().getLocationForDisk(dir)); } } catch (IOError e) { // Expected -- marked all directories as unwritable } return () -> BlacklistedDirectories.clearUnwritableUnsafe(); }
static Set<File> listFiles(File folder, Directories.FileType... types) { Collection<Directories.FileType> match = Arrays.asList(types); return new LogAwareFileLister(folder.toPath(), (file, type) -> match.contains(type), Directories.OnTxnErr.IGNORE).list() .stream() .map(f -> { try { return f.getCanonicalFile(); } catch (IOException e) { throw new IOError(e); } }) .collect(Collectors.toSet()); }
/** * Validates ioError(). */ @Test public void testIOError() { // Check true cases. Throwable ioError1 = new EOFException("io error 1"); assertTrue(errorExtractor.ioError(ioError1)); assertTrue(errorExtractor.ioError(new Exception(ioError1))); assertTrue(errorExtractor.ioError(new RuntimeException(new RuntimeException(ioError1)))); Throwable ioError2 = new IOException("io error 2"); assertTrue(errorExtractor.ioError(ioError2)); assertTrue(errorExtractor.ioError(new Exception(ioError2))); assertTrue(errorExtractor.ioError(new RuntimeException(new RuntimeException(ioError2)))); Throwable ioError3 = new IOError(new Exception("io error 3")); assertTrue(errorExtractor.ioError(ioError3)); assertTrue(errorExtractor.ioError(new Exception(ioError3))); assertTrue(errorExtractor.ioError(new RuntimeException(new RuntimeException(ioError3)))); // Check false cases. Throwable notIOError = new Exception("not io error"); assertFalse(errorExtractor.ioError(notIOError)); assertFalse(errorExtractor.ioError(new RuntimeException(notIOError))); }
@Override public void onTokenRequestFailed(TokenRequest request, Throwable throwable) { enableForm(); TextView textView = views.textView(R.id.text_error_message); textView.setVisibility(View.VISIBLE); String message = null; if (throwable instanceof IOError) { message = getString(R.string.error_io, throwable.getMessage()); } else if (throwable instanceof APIError) { message = getString(R.string.error_api, ((APIError) throwable).message); } else { message = getString(R.string.error_unknown, throwable.getMessage()); } textView.setText(message); }
@Override public synchronized void process(List<WikipediaPage> batch) { if(this.fileChannel == null) return; try { if(batch.size() == 0) { this.fileChannel.write(ByteBuffer.wrap("\n".getBytes("utf-8"))); this.fileChannel.close(); this.fileChannel = null; return; } for (WikipediaPage wikipediaPage : batch) { if(wikipediaPage.getText().length() > 0) { this.fileChannel.write(ByteBuffer.wrap(wikipediaPage.getText().getBytes("utf-8"))); this.fileChannel.write(ByteBuffer.wrap("\n".getBytes("utf-8"))); } } } catch (IOException e) { throw new IOError(e); } }
