Java Code Examples for java.io.IOError

final protected Path getJFRInputFile(Deque<String> options) throws UserSyntaxException, UserDataException {
    if (options.isEmpty()) {
        throw new UserSyntaxException("missing file");
    }
    String file = options.removeLast();
    if (file.startsWith("--")) {
        throw new UserSyntaxException("missing file");
    }
    try {
        Path path = Paths.get(file).toAbsolutePath();
        ensureAccess(path);
        ensureJFRFile(path);
        return path;
    } catch (IOError ioe) {
        throw new UserDataException("i/o error reading file '" + file + "', " + ioe.getMessage());
    } catch (InvalidPathException ipe) {
        throw new UserDataException("invalid path '" + file + "'");
    }
}
 

public static ObjectNode rollupToJson(Rollup rollup) {
    if (rollup instanceof BluefloodCounterRollup)
        return handleCounterRollup((BluefloodCounterRollup)rollup);
    else if (rollup instanceof BluefloodTimerRollup)
        return handleTimerRollup((BluefloodTimerRollup)rollup);
    else if (rollup instanceof BluefloodSetRollup)
        return handleSetRollup((BluefloodSetRollup)rollup);
    else if (rollup instanceof BluefloodGaugeRollup)
        return handleGaugeRollup((BluefloodGaugeRollup)rollup);
    else if (rollup instanceof BasicRollup)
        return handleBasicRollup((BasicRollup)rollup, JsonNodeFactory.instance.objectNode());
    else {
        log.error("Error encountered while serializing the rollup "+rollup);
        throw new IOError(new IOException("Cannot serialize the Rollup : "+rollup));
    }
}
 

@Override
public void shutdown()
{
    if (titanGraph == null)
    {
        return;
    }
    try
    {
        titanGraph.shutdown();
    }
    catch (IOError e)
    {
        // TODO Fix issue in shutting down titan-cassandra-embedded
        System.err.println("Failed to shutdown titan graph: " + e.getMessage());
    }

    titanGraph = null;
}
 

private static Map<String, String> readProperties(final InputStream is) {
    if (is == null) {
        return Collections.emptyMap();
    }
    try (Closeable ignored = is) {
        try (InputStreamReader isr = new InputStreamReader(is, StandardCharsets.UTF_8)) {
            try (BufferedReader br = new BufferedReader(isr)) {
                final Properties properties = new Properties();
                properties.load(br);
                return (Map<String, String>) (Map) properties;
            }
        }
    } 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 Throwable generateException() {
    try {
        try {
            Integer.parseInt("23.23232");
        } catch (NumberFormatException nfe) {
            throw new IllegalArgumentException("Incorrect param", nfe);
        }
    } catch (IllegalArgumentException iae) {
        try {
            throw new IOException("Request processing failed", iae);
        } catch (IOException e) {
            try {
                throw new IOError(e);
            } catch (IOError ie) {
                return new RuntimeException("Unexpected exception", ie);
            }
        }
    }
    throw new RuntimeException("Should not reach here");
}
 

final protected Path getJFRInputFile(Deque<String> options) throws UserSyntaxException, UserDataException {
    if (options.isEmpty()) {
        throw new UserSyntaxException("missing file");
    }
    String file = options.removeLast();
    if (file.startsWith("--")) {
        throw new UserSyntaxException("missing file");
    }
    try {
        Path path = Paths.get(file).toAbsolutePath();
        ensureAccess(path);
        ensureJFRFile(path);
        return path;
    } catch (IOError ioe) {
        throw new UserDataException("i/o error reading file '" + file + "', " + ioe.getMessage());
    } catch (InvalidPathException ipe) {
        throw new UserDataException("invalid path '" + file + "'");
    }
}
 

@Override
public final URI toUri() {
    try {
        String p = toAbsolutePath().path;
        if (!p.startsWith("/modules") || p.contains("..")) {
            throw new IOError(new RuntimeException(p + " cannot be represented as URI"));
        }

        p = p.substring("/modules".length());
        if (p.isEmpty()) {
            p = "/";
        }
        return new URI("jrt", p, null);
    } catch (URISyntaxException ex) {
        throw new AssertionError(ex);
    }
}
 

@Override
public Iterator<String> iterator() {
  final List<String> entries = new ArrayList<>();
  try (Stream<Path> paths = Files.walk(root)) {
    paths.forEach(
        new Consumer<Path>() {
          @Override
          public void accept(Path t) {
            if (Files.isRegularFile(t)) {
              // Internally, we use '/' as a common package separator in filename to abstract
              // that filename can comes from a zip or a directory.
              entries.add(root.relativize(t).toString().replace(File.separatorChar, '/'));
            }
          }
        });
  } catch (IOException e) {
    throw new IOError(e);
  }
  return entries.iterator();
}
 

@Override
protected Attribute read(
    ClassReader classReader,
    int offset,
    int length,
    char[] charBuffer,
    int codeAttributeOffset,
    Label[] labels) {
  byte[] classAttrBytes = new byte[length];
  for (int i = 0; i < length; i++) {
    classAttrBytes[i] = (byte) classReader.readByte(i + offset);
  }
  try {
    return new DesugarMethodAttribute(
        DesugarMethodInfo.parseFrom(classAttrBytes, ExtensionRegistryLite.getEmptyRegistry()));
  } catch (InvalidProtocolBufferException e) {
    throw new IOError(e);
  }
}
 

private static Map<String, String> readProperties(final InputStream is) {
    if (is == null) {
        return Collections.emptyMap();
    }
    try (Closeable ignored = is) {
        try (InputStreamReader isr = new InputStreamReader(is, StandardCharsets.UTF_8)) {
            try (BufferedReader br = new BufferedReader(isr)) {
                final Properties properties = new Properties();
                properties.load(br);
                return transform((Map<String, String>) (Map) properties);
            }
        }
    } catch (IOException e) {
        throw new IOError(e);
    }
}
 

default ImmutableList<FileContentProvider<? extends InputStream>> toInputFileStreams() {
  ImmutableList.Builder<FileContentProvider<? extends InputStream>> inputClassFileContents =
      ImmutableList.builder();
  for (String inputFileName : this) {
    inputClassFileContents.add(
        new FileContentProvider<>(
            inputFileName,
            () -> {
              try {
                return getInputStream(inputFileName);
              } catch (IOException e) {
                throw new IOError(e);
              }
            }));
  }
  return inputClassFileContents.build();
}
 

@Override
public void close() {
    growLock.lock();
    try{
        fileChannel.close();
        raf.close();
        if(!readOnly)
            sync();
        for(ByteBuffer b:buffers){
            if(b!=null && (b instanceof MappedByteBuffer)){
                unmap((MappedByteBuffer) b);
            }
        }
        buffers = null;
    } catch (IOException e) {
        throw new IOError(e);
    }finally{
        growLock.unlock();
    }

}
 

@Override
protected ByteBuffer makeNewBuffer(long offset) {
    try {
        long newBufSize =  offset% BUF_SIZE;
        newBufSize = newBufSize + newBufSize%BUF_SIZE_INC; //round to BUF_SIZE_INC
        return fileChannel.map(
                mapMode,
                offset - offset% BUF_SIZE, newBufSize );
    } catch (IOException e) {
        if(e.getCause()!=null && e.getCause() instanceof OutOfMemoryError){
            throw new RuntimeException("File could not be mapped to memory, common problem on 32bit JVM. Use `DBMaker.newRandomAccessFileDB()` as workaround",e);
        }

        throw new IOError(e);
    }
}
 

protected static String loadJson(JarFile jar, JarEntry je) {
    try (InputStream is = jar.getInputStream(je)) {
        return PackageHelper.loadText(is);
    } catch (IOException e) {
        throw new IOError(e);
    }
}
 

private void getAllChildDirectories(File parentDir) {

        try {
            File[] allFiles = parentDir.listFiles();
            logFiles(allFiles);
        } catch (IOError e) {
            Log.e(TAG, "error " + e);
        }
    }
 

@Test
public void testAddStatusEventForIOErrorWithFailOnLoggerIOErrorDisabled()
{
    Status event = createEvent(new IOError(new IOException("Mocked: No disk space left")), Status.ERROR);
    when(_fileLogger.getContextValue(Boolean.class, BrokerFileLogger.BROKER_FAIL_ON_LOGGER_IO_ERROR)).thenReturn(false);
    _statusListener.addStatusEvent(event);

    verify(_systemConfig, never()).closeAsync();
}
 

public File asFile() {
    try {
        return new File(url.toURI());
    } catch (URISyntaxException e) {
        throw new IOError(e);
    }
}
 

@Override
public FileContentProvider<InputStream> getContent(ClassName className) {
  String inArchiveBinaryPathName = className.classFilePathName();
  return new FileContentProvider<>(
      inArchiveBinaryPathName,
      () -> {
        try {
          return Resources.getResource(inArchiveBinaryPathName).openStream();
        } catch (IOException e) {
          throw new IOError(e);
        }
      });
}
 

/**
 * Returns the source text for the node.
 */
static String getSourceForNode(Tree node, TreePath path) {
    CharSequence source;
    try {
        source = path.getCompilationUnit().getSourceFile().getCharContent(false);
    } catch (IOException e) {
        throw new IOError(e);
    }
    return source.subSequence(getStartPosition(node), getEndPosition(node, path)).toString();
}
 

public static Stream<Path> safeWalk(Path p) {
    try {
        return Files.walk(p);
    } catch (IOException e) {
        throw new IOError(e);
    }
}
 

@Test
public void updateExtension() throws IOError {
    LoadFlowParameters parameters = new LoadFlowParameters();
    DummyExtension extension = new DummyExtension();
    extension.setParameterDouble(2.5);
    extension.setParameterBoolean(false);
    extension.setParameterString("Hello World !");
    DummyExtension oldExtension = new DummyExtension(extension);
    parameters.addExtension(DummyExtension.class, extension);
    JsonLoadFlowParameters.update(parameters, getClass().getResourceAsStream("/LoadFlowParametersUpdate.json"));
    extension = parameters.getExtension(DummyExtension.class);
    assertEquals(oldExtension.isParameterBoolean(), extension.isParameterBoolean());
    assertNotEquals(oldExtension.getParameterDouble(), extension.getParameterDouble());
    assertNotEquals(oldExtension.getParameterString(), extension.getParameterString());
}
 

public static <T> void assertJsonConversion(T value, Class<T> valueType, String json) {
    assertThatJson(json).isEqualTo(value);
    try {
        assertThat(Jackson.readValue(json, valueType)).isEqualTo(value);
    } catch (IOException e) {
        throw new IOError(e);
    }
}
 

@Test
public void read_beyond_end_raf_byte(){
    try{
        Volume v = new Volume.RandomAccessFileVol(Utils.tempDbFile(), false);
        v.getByte(1000000);
        fail();
    }catch(IOError e){
        assertTrue(e.getCause() instanceof  EOFException);
    }
}
 

@Override
public <A> A get(long recid, Serializer<A> serializer) {
    assert(recid>0);
    final long ioRecid = IO_USER_START + recid*8;
    final Lock lock  = locks[Store.lockPos(ioRecid)].readLock();
    lock.lock();
    try{
        return get2(ioRecid, serializer);
    }catch(IOException e){
        throw new IOError(e);
    }finally{
        lock.unlock();
    }
}
 

public void test4() {
    Context context = new Context();
    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
    context.put(DiagnosticListener.class, diagnostics);
    Options.instance(context).put("allowStringFolding", "false");
    JCTree.JCCompilationUnit unit;
    JavacFileManager fileManager = new JavacFileManager(context, true, UTF_8);
    try {
        fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, ImmutableList.<File>of());
    } catch (IOException e) {
        // impossible
        throw new IOError(e);
    }
    SimpleJavaFileObject source =
            new SimpleJavaFileObject(URI.create("source"), JavaFileObject.Kind.SOURCE) {
                @Override
                public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
                    return src;
                }
            };
    Log.instance(context).useSource(source);
    ParserFactory parserFactory = ParserFactory.instance(context);
    Parser parser =
            parserFactory.newParser(
                    src,
        /*keepDocComments=*/ true,
        /*keepEndPos=*/ true,
        /*keepLineMap=*/ true);
    unit = parser.parseCompilationUnit();
    unit.sourcefile = source;
}
 

private static JCCompilationUnit parse(Context context, String javaInput)
    throws FormatterException {
  DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
  context.put(DiagnosticListener.class, diagnostics);
  Options.instance(context).put("--enable-preview", "true");
  Options.instance(context).put("allowStringFolding", "false");
  JCCompilationUnit unit;
  JavacFileManager fileManager = new JavacFileManager(context, true, UTF_8);
  try {
    fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, ImmutableList.of());
  } catch (IOException e) {
    // impossible
    throw new IOError(e);
  }
  SimpleJavaFileObject source =
      new SimpleJavaFileObject(URI.create("source"), JavaFileObject.Kind.SOURCE) {
        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
          return javaInput;
        }
      };
  Log.instance(context).useSource(source);
  ParserFactory parserFactory = ParserFactory.instance(context);
  JavacParser parser =
      parserFactory.newParser(
          javaInput, /*keepDocComments=*/ true, /*keepEndPos=*/ true, /*keepLineMap=*/ true);
  unit = parser.parseCompilationUnit();
  unit.sourcefile = source;
  Iterable<Diagnostic<? extends JavaFileObject>> errorDiagnostics =
      Iterables.filter(diagnostics.getDiagnostics(), Formatter::errorDiagnostic);
  if (!Iterables.isEmpty(errorDiagnostics)) {
    // error handling is done during formatting
    throw FormatterException.fromJavacDiagnostics(errorDiagnostics);
  }
  return unit;
}
 

/**
 * Returns the source text for the node.
 */
static String getSourceForNode(Tree node, TreePath path) {
    CharSequence source;
    try {
        source = path.getCompilationUnit().getSourceFile().getCharContent(false);
    } catch (IOException e) {
        throw new IOError(e);
    }
    return source.subSequence(getStartPosition(node), getEndPosition(node, path)).toString();
}
 

@Override
public Optional<URI> find(String name) throws IOException {
    ensureOpen();
    Path path = Resources.toFilePath(dir, name);
    if (path != null) {
        try {
            return Optional.of(path.toUri());
        } catch (IOError e) {
            throw (IOException) e.getCause();
        }
    } else {
        return Optional.empty();
    }
}
 

@Override
public String readLine(String fmt, Object... args) throws IOError {
    if (hasConsole()) {
        return theConsole.readLine(fmt, args);
    } else {
        throw ROOT_LOGGER.noConsoleAvailable();
    }
}