Example usage for org.apache.commons.io IOUtils toByteArray

List of usage examples for org.apache.commons.io IOUtils toByteArray

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.io.*
  5. IOUtils
  6. toByteArray

Introduction

In this page you can find the example usage for org.apache.commons.io IOUtils toByteArray.

Prototype

public static byte[] toByteArray(String input) throws IOException

Source Link

Document

Get the contents of a String as a byte[] using the default character encoding of the platform.

Usage

From source file:caarray.client.examples.download_file.grid.GridFileDownload.java

private void downloadContents(CaArraySvcClient client, String fileName) throws Exception {
    CaArrayFile caArrayFile = lookupFile(client, fileName);
    if (caArrayFile == null) {
        System.out.println("Error: Could not find file " + fileName);
        return;// w w w . j  a  va  2 s .co m
    }
    // Create a result handler that converts the input stream to bytes.
    GridTransferResultHandler resultHandler = new GridTransferResultHandler() {
        public java.lang.Object processRetrievedData(InputStream stream) throws IOException {
            return IOUtils.toByteArray(stream);
        }
    };
    byte[] byteArray = readFileUsingGridTransfer(client, caArrayFile, resultHandler);

    if (byteArray != null) {
        System.out.println("Retrieved " + byteArray.length + " bytes.");
    } else {
        System.out.println("Error: Retrieved null byte array.");
    }
}

From source file:com.spartasystems.holdmail.smtp.SMTPHandler.java

@Override
public void data(InputStream is) throws IOException {

    data = IOUtils.toByteArray(is);
}

From source file:eu.europa.ec.markt.dss.signature.FileDocument.java

@Override
public byte[] getBytes() throws DSSException {

    try {/*from  w w w.  j  a  va  2s . c o  m*/
        return IOUtils.toByteArray(openStream());
    } catch (IOException e) {

        throw new DSSException(e);
    }
}

From source file:com.github.restdriver.clientdriver.HttpRealRequest.java

public HttpRealRequest(HttpServletRequest request) {
    this.path = request.getPathInfo();
    this.method = Method.custom(request.getMethod().toUpperCase());
    this.params = HashMultimap.create();

    if (request.getQueryString() != null) {
        MultiMap<String> parameterMap = new MultiMap<String>();
        UrlEncoded.decodeTo(request.getQueryString(), parameterMap, "UTF-8", 0);
        for (Entry<String, String[]> paramEntry : parameterMap.toStringArrayMap().entrySet()) {
            String[] values = paramEntry.getValue();
            for (String value : values) {
                this.params.put(paramEntry.getKey(), value);
            }/*from   w  ww .ja va 2 s. c  om*/
        }
    }

    headers = new HashMap<String, Object>();
    Enumeration<String> headerNames = request.getHeaderNames();
    if (headerNames != null) {
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            headers.put(headerName.toLowerCase(), request.getHeader(headerName));
        }
    }

    try {
        this.bodyContent = IOUtils.toByteArray(request.getInputStream());
    } catch (IOException e) {
        throw new RuntimeException("Failed to read body of request", e);
    }

    this.bodyContentType = request.getContentType();
}

From source file:eu.europa.ejustice.portal.dss.controller.eoss.SigningMethodsTest.java

@Test
public void testReadXmlFile() throws UnsupportedEncodingException, IOException {

    PortalFacade portal = Mockito.mock(PortalFacade.class);
    InputStream is = SigningMethodsTest.class.getClassLoader().getResourceAsStream("TestSigningRepo.xml");

    Mockito.when(portal.getCardProfileXML()).thenReturn(new String(IOUtils.toByteArray(is), "UTF-8"));
    Map<String, List<SigningMethod>> methods = SigningMethodsHome.getInstance().getSigningMethods(portal);
    assertFalse(methods.isEmpty());/*from   ww  w . ja  v a  2  s  . c om*/
}

From source file:com.softlysoftware.jxero.Endpoint.java

private byte[] invoke(Method method, String identifier, List<OAuth.Parameter> params, HttpClient4 httpClient) {
    try {/*  w  ww  .  ja va 2  s  .c o  m*/
        OAuthClient oAuthClient = new OAuthClient(httpClient);
        String url = BASE + getRootElementName() + "/";
        if (identifier != null)
            url = url + identifier;
        if (params == null)
            params = OAuth.newList();
        log.trace("Invoking : " + method + " on " + url);
        log.trace("--------------------------------");
        for (OAuth.Parameter param : params) {
            log.trace(param.getKey() + " : " + param.getValue());
        }
        log.trace("--------------------------------");
        OAuthMessage message = oAuthClient.invoke(xeroClient.getOAuthAccessor(), method.toString(), url,
                params);
        InputStream in = message.getBodyAsStream();
        byte[] build = IOUtils.toByteArray(in);
        in.close();
        return build;
    } catch (URISyntaxException urise) {
        throw new RuntimeException("Should not happen?", urise);
    } catch (IOException ioe) {
        throw new RuntimeException("Something went wrong connecting to the service.", ioe);
    } catch (OAuthException oae) {
        //oae.printStackTrace();
        throw new RuntimeException("Something went wrong with the OAuth connection.", oae);
    }
}

From source file:edu.nyupoly.cs6903.ag3671.FTPClientExample.java

public static void main(String[] args) throws UnknownHostException, Exception {
    // MY CODE/* w ww.  j  av a 2s . c  o m*/
    if (crypto(Collections.unmodifiableList(Arrays.asList(args)))) {
        return;
    }
    ;
    // MY CODE -- END

    boolean storeFile = false, binaryTransfer = true, error = false, listFiles = false, listNames = false,
            hidden = false;
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;
    String username = null;
    String password = null;

    int base = 0;
    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-A")) {
            username = "anonymous";
            password = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
        }
        // Always use binary transfer 
        //            else if (args[base].equals("-b")) {
        //                binaryTransfer = true;
        //            }
        else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (username != null) {
        minParams -= 2;
    }
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        System.err.println(USAGE);
        System.exit(1);
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    if (username == null) {
        username = args[base++];
        password = args[base++];
    }

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = protocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            System.exit(1);
        }
    } catch (IOException e) {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        if (!ftp.login(username, password)) {
            ftp.logout();
            error = true;
            break __main;
        }

        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);
            // MY CODE
            byte[] bytes = IOUtils.toByteArray(input);
            InputStream encrypted = new ByteArrayInputStream(cryptor.encrypt(bytes));
            // MY CODE -- END
            ftp.storeFile(remote, encrypted);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    //                        Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                //                  Command listener has already printed the output
                //                    for(String s : ftp.getReplyStrings()) {
                //                        System.out.println(s);
                //                    }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            // MY CODE
            ByteArrayOutputStream remoteFile = new ByteArrayOutputStream();
            //InputStream byteIn = new ByteArrayInputStream(buf);
            ftp.retrieveFile(remote, remoteFile);
            remoteFile.flush();
            Optional<byte[]> opt = cryptor.decrypt(remoteFile.toByteArray());
            if (opt.isPresent()) {
                output.write(opt.get());
            }
            remoteFile.close();
            // MY CODE -- END
            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    System.exit(error ? 1 : 0);
}

From source file:eu.europa.esig.dss.xades.signature.XAdESLevelBEnvelopingDigestDocumentTest.java

@Before
public void init() throws Exception {
    File file = new File("src/test/resources/sample.xml");
    DigestDocument digestDocument = new DigestDocument(file);
    FileInputStream fis = new FileInputStream(file);
    byte[] bytes = IOUtils.toByteArray(fis);
    IOUtils.closeQuietly(fis);// w  w w  .  j a v  a2  s  .  c o  m
    String computedDigest = Base64.encodeBase64String(DSSUtils.digest(DigestAlgorithm.SHA256, bytes));
    digestDocument.addDigest(DigestAlgorithm.SHA256, computedDigest);
    digestDocument.setBase64Encoded(Base64.encodeBase64String(bytes));

    documentToSign = digestDocument;

    CertificateService certificateService = new CertificateService();
    privateKeyEntry = certificateService.generateCertificateChain(SignatureAlgorithm.RSA_SHA256);

    signatureParameters = new XAdESSignatureParameters();
    signatureParameters.bLevel().setSigningDate(new Date());
    signatureParameters.setSigningCertificate(privateKeyEntry.getCertificate());
    signatureParameters.setCertificateChain(privateKeyEntry.getCertificateChain());
    signatureParameters.setSignaturePackaging(SignaturePackaging.ENVELOPING);
    signatureParameters.setSignatureLevel(SignatureLevel.XAdES_BASELINE_B);

    CertificateVerifier certificateVerifier = new CommonCertificateVerifier();
    service = new XAdESService(certificateVerifier);

}

From source file:net.javacrumbs.mocksocket.SampleTest.java

@Test
public void testConditionalAddress() throws Exception {
    byte[] mockData = new byte[] { 1, 2, 3, 4 };
    expectCall().andWhenRequest(address(is("example.org:1234"))).thenReturn(data(mockData));

    Socket socket = SocketFactory.getDefault().createSocket("example.org", 1234);
    byte[] data = IOUtils.toByteArray(socket.getInputStream());
    socket.close();/*from ww w  .  j a  va  2 s  . co m*/
    assertThat(data, is(mockData));
}

From source file:com.kixeye.chassis.transport.websocket.WebSocketPskFrameProcessor.java

/**
 * @param cipherProvider/*from  w  ww  .  j a  v a2  s. co m*/
 * @param cipherTransformation
 * @param secretKeyProvider
 * @param secretKeyAlgorithm
 * @param secretKeyData
 * @param secretKeyPath
 * @param enabled
 * @param secretKey
 */
@Autowired
public WebSocketPskFrameProcessor(@Value("${websocket.crypto.cipherProvider:}") String cipherProvider,
        @Value("${websocket.crypto.cipherTransformation:}") String cipherTransformation,
        @Value("${websocket.crypto.secretKeyAlgorithm:}") String secretKeyAlgorithm,
        @Value("${websocket.crypto.secretKeyData:}") String secretKeyData,
        @Value("${websocket.crypto.secretKeyPath:}") String secretKeyPath,
        @Value("${websocket.crypto.enabled:false}") boolean enabled) throws Exception {
    if (enabled) {
        byte[] secretKey = null;

        if (StringUtils.isNoneBlank(secretKeyData)) {
            secretKey = BaseEncoding.base16().decode(secretKeyData);
        } else if (StringUtils.isNoneBlank(secretKeyPath)) {
            Resource secretKeyFile = RESOURCE_LOADER.getResource(secretKeyPath);

            secretKey = IOUtils.toByteArray(secretKeyFile.getInputStream());
        } else {
            throw new IllegalArgumentException("Neither secret key data nor path were provided.");
        }

        cipher = new SymmetricKeyCipher(cipherProvider, cipherTransformation, secretKeyAlgorithm, secretKey);
    } else {
        cipher = null;
    }
}