Java Code Examples for java.nio.channels.Channels#newChannel()

EnvelopedRecordSetWriter(int initialBufferSize,
                         CompressionCodec.Type codec) {
    this.buffer = new Buffer(Math.max(initialBufferSize, HEADER_LEN));
    this.promiseList = new LinkedList<Promise<DLSN>>();
    this.codec = codec;
    switch (codec) {
        case LZ4:
            this.codecCode = COMPRESSION_CODEC_LZ4;
            break;
        default:
            this.codecCode = COMPRESSION_CODEC_NONE;
            break;
    }
    this.writer = new DataOutputStream(buffer);
    try {
        this.writer.writeInt((VERSION & METADATA_VERSION_MASK)
                | (codecCode & METADATA_COMPRESSION_MASK));
        this.writer.writeInt(0); // count
        this.writer.writeInt(0); // original len
        this.writer.writeInt(0); // actual len
    } catch (IOException e) {
        logger.warn("Failed to serialize the header to an enveloped record set", e);
    }
    this.writeChannel = Channels.newChannel(writer);
}
 

@Test
    public void testMuxing() throws Exception {
        H264AnnexBTrack b = new H264AnnexBTrack(H264AnnexBTrackTest.class.getResourceAsStream("/org/mp4parser/streaming/input/h264/tos.h264"));
        //H264AnnexBTrack b = new H264AnnexBTrack(new FileInputStream("C:\\dev\\mp4parser\\out.264"));
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        FragmentedMp4Writer writer = new FragmentedMp4Writer(Collections.<StreamingTrack>singletonList(b), Channels.newChannel(baos));
        //MultiTrackFragmentedMp4Writer writer = new MultiTrackFragmentedMp4Writer(new StreamingTrack[]{b}, new ByteArrayOutputStream());
        b.call();
        writer.close();
        IsoFile isoFile = new IsoFile(Channels.newChannel(new ByteArrayInputStream(baos.toByteArray())));
        Walk.through(isoFile);
        List<Sample> s = new Mp4SampleList(1, isoFile, new InMemRandomAccessSourceImpl(baos.toByteArray()));
        for (Sample sample : s) {
//            System.err.println("s: " + sample.getSize());
            sample.asByteBuffer();
        }
    }
 

@Test
public void ChannelWriteFunctionalityTest() throws IOException {
  byte[] buf = new byte[1000];
  new Random().nextBytes(buf);
  ByteBuffer buffer = ByteBuffer.wrap(buf);
  ByteBufferInputStream stream = new ByteBufferInputStream(buffer);
  ByteBuffer output = ByteBuffer.allocate(10000);
  ByteBufferOutputStream outputstream = new ByteBufferOutputStream(output);
  WritableByteChannel channel = Channels.newChannel(outputstream);
  ChannelWriter writer = new ChannelWriter(channel);
  writer.writeInt(1000);
  writer.writeLong(10000);
  writer.writeShort((short) 5);
  writer.writeString("check");
  writer.writeStream(stream, 1000);
  output.flip();
  Assert.assertEquals(1000, output.getInt());
  Assert.assertEquals(10000, output.getLong());
  Assert.assertEquals(5, output.getShort());
  byte[] stringout = new byte[5];
  System.arraycopy(output.array(), 14, stringout, 0, 5);
  // Assert.assertArrayEquals(stringout, "check".getBytes());
  // byte[] streamout = new byte[1000];
  //System.arraycopy(output.array(), 19, streamout, 0, 1000);
  //Assert.assertArrayEquals(streamout, buf);
}
 

/**
 * Downloads required Minecraft server jar from the Minecraft cdn.
 */
public static void downloadMinecraftServer() {
    String fileName = "minecraft_server.1.12.2.jar";
    String downloadLink = "https://launcher.mojang.com/v1/objects/886945bfb2b978778c3a0288fd7fab09d315b25f/server.jar";

    File minecraftServerJar = new File(fileName);
    if (!minecraftServerJar.exists() && !minecraftServerJar.isDirectory()) {
        System.out.println("Downloading Minecraft Server Jar...");
        try {
            URL website = new URL(downloadLink);
            ReadableByteChannel rbc = Channels.newChannel(website.openStream());
            FileOutputStream fos = new FileOutputStream(fileName);
            fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 

@Setup
public void setup() throws IOException {
  dataGenerator = new JsonDataGeneratorImpl();

  Metadata metadata = FileSystems.matchSingleFileSpec(schemaLocation);

  // Copy the schema file into a string which can be used for generation.
  try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
    try (ReadableByteChannel readerChannel = FileSystems.open(metadata.resourceId())) {
      try (WritableByteChannel writerChannel = Channels.newChannel(byteArrayOutputStream)) {
        ByteStreams.copy(readerChannel, writerChannel);
      }
    }

    schema = byteArrayOutputStream.toString();
  }
}
 

protected CryptoOutputStream getCryptoOutputStream(ByteArrayOutputStream baos,
                                                 Cipher cipher,
                                                 int bufferSize, byte[] iv,
                                                 boolean withChannel) throws
    IOException {
  if (withChannel) {
    return new CryptoOutputStream(Channels.newChannel(baos), cipher,
        bufferSize, key, iv);
  } else {
    return new CryptoOutputStream(baos, cipher, bufferSize, key, iv);
  }
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

public ReadableByteChannel getReadableChannel() throws UnsupportedEncodingException {
	byte[] byteArray;
	if (StringUtils.isEmpty(charset)) {
		byteArray = data.getBytes(Defaults.DataFormatter.DEFAULT_CHARSET_ENCODER);
	} else {
		byteArray = data.getBytes(charset);
	}
	
	return Channels.newChannel(new ByteArrayInputStream(byteArray));
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

public static void getJoomlaThemeDB() throws IOException {
    URL website =
            new URL(
                    "https://fuzzdb.googlecode.com/svn/trunk/Discovery/PredictableRes/CMS/joomla_themes.fuzz.txt");
    ReadableByteChannel rbc = Channels.newChannel(website.openStream());
    @SuppressWarnings("resource")
    FileOutputStream fos = new FileOutputStream("resources/pluginEnum/joomla_themes.txt");
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

/**
 * Process a wrapped RPC Request - unwrap the SASL packet and process
 * each embedded RPC request 
 * @param buf - SASL wrapped request of one or more RPCs
 * @throws IOException - SASL packet cannot be unwrapped
 * @throws InterruptedException
 */    
private void unwrapPacketAndProcessRpcs(byte[] inBuf)
    throws WrappedRpcServerException, IOException, InterruptedException {
  if (LOG.isDebugEnabled()) {
    LOG.debug("Have read input token of size " + inBuf.length
        + " for processing by saslServer.unwrap()");
  }
  inBuf = saslServer.unwrap(inBuf, 0, inBuf.length);
  ReadableByteChannel ch = Channels.newChannel(new ByteArrayInputStream(
      inBuf));
  // Read all RPCs contained in the inBuf, even partial ones
  while (true) {
    int count = -1;
    if (unwrappedDataLengthBuffer.remaining() > 0) {
      count = channelRead(ch, unwrappedDataLengthBuffer);
      if (count <= 0 || unwrappedDataLengthBuffer.remaining() > 0)
        return;
    }

    if (unwrappedData == null) {
      unwrappedDataLengthBuffer.flip();
      int unwrappedDataLength = unwrappedDataLengthBuffer.getInt();
      unwrappedData = ByteBuffer.allocate(unwrappedDataLength);
    }

    count = channelRead(ch, unwrappedData);
    if (count <= 0 || unwrappedData.remaining() > 0)
      return;

    if (unwrappedData.remaining() == 0) {
      unwrappedDataLengthBuffer.clear();
      unwrappedData.flip();
      processOneRpc(unwrappedData.array());
      unwrappedData = null;
    }
  }
}
 

/**
 * Write Succinct data structures to a DataOutputStream.
 *
 * @param os Output stream to write data to.
 * @throws IOException
 */
public void writeToStream(DataOutputStream os) throws IOException {
  WritableByteChannel dataChannel = Channels.newChannel(os);

  os.writeInt(getOriginalSize());
  os.writeInt(getSamplingRateSA());
  os.writeInt(getSamplingRateISA());
  os.writeInt(getSamplingRateNPA());
  os.writeInt(getSampleBitWidth());
  os.writeInt(getAlphabetSize());

  for (int i = 0; i < getAlphabetSize(); i++) {
    os.writeInt(alphabet[i]);
  }

  for (int i = 0; i < sa.limit(); i++) {
    os.writeLong(sa.get(i));
  }

  for (int i = 0; i < isa.limit(); i++) {
    os.writeLong(isa.get(i));
  }

  for (int i = 0; i < columnoffsets.limit(); i++) {
    os.writeInt(columnoffsets.get(i));
  }

  for (int i = 0; i < columns.length; i++) {
    os.writeInt(columns[i].limit());
    dataChannel.write(columns[i].order(ByteOrder.BIG_ENDIAN));
    columns[i].rewind();
  }
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

private static void downloadFileFromURL(String urlString, File destination) throws Exception {
    URL website = new URL(urlString);
    ReadableByteChannel rbc;
    rbc = Channels.newChannel(website.openStream());
    FileOutputStream fos = new FileOutputStream(destination);
    fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
    fos.close();
    rbc.close();
}
 

public static void copy( InputStream from, OutputStream to ) throws IOException {
    ReadableByteChannel in = Channels.newChannel( from );
    WritableByteChannel out = Channels.newChannel( to );

    final ByteBuffer buffer = ByteBuffer.allocateDirect( 16 * 1024 );
    while ( in.read( buffer ) != -1 ) {
        buffer.flip();
        out.write( buffer );
        buffer.compact();
    }
    buffer.flip();
    while ( buffer.hasRemaining() ) {
        out.write( buffer );
    }
}
 

/**
 * @return an output wrapped around {@code os}
 */
static DurableOutput from(OutputStream os) {
  return new ByteChannelOutput(Channels.newChannel(os), 16 << 10);
}
 

/**
* Writes the complete contents of this byte buffer output stream to
* the specified output stream argument.
*
* @param      out   the output stream to which to write the data.
* @exception  IOException  if an I/O error occurs.
*/
public void writeTo(OutputStream out) throws IOException {
  WritableByteChannel channel = Channels.newChannel(out);
  ByteBuffer bb = curBuf.duplicate();
  bb.flip();
  channel.write(bb);
}