X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fio%2FFileParse.java;h=1f51d8c8ad1a0c3cf93628793bab09c40f56b79c;hb=a9177efb4097815d9a8031aa22700c61a7d6260a;hp=d20b4681c298f9392a6ba18ddf045ad14e6d4b87;hpb=7ab5d6b0ba5fec1ea4a4239e79c476d841622485;p=jalview.git diff --git a/src/jalview/io/FileParse.java b/src/jalview/io/FileParse.java index d20b468..1f51d8c 100755 --- a/src/jalview/io/FileParse.java +++ b/src/jalview/io/FileParse.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -20,16 +20,41 @@ */ package jalview.io; -import java.io.*; -import java.net.*; +import java.io.BufferedInputStream; +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; +import java.io.StringReader; +import java.net.HttpURLConnection; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLConnection; import java.util.zip.GZIPInputStream; +import jalview.api.AlignExportSettingsI; +import jalview.api.AlignViewportI; +import jalview.api.AlignmentViewPanel; +import jalview.api.FeatureSettingsModelI; +import jalview.bin.Console; +import jalview.util.MessageManager; +import jalview.util.Platform; + /** * implements a random access wrapper around a particular datasource, for * passing to identifyFile and AlignFile objects. */ public class FileParse { + protected static final String SPACE = " "; + + protected static final String TAB = "\t"; + /** * text specifying source of data. usually filename or url. */ @@ -37,10 +62,33 @@ public class FileParse public File inFile = null; - public int index = 1; // sequence counter for FileParse object created from + private byte[] bytes; // from JavaScript + + public byte[] getBytes() + { + return bytes; + } + + /** + * a viewport associated with the current file operation. May be null. May + * move to different object. + */ + private AlignViewportI viewport; + + /** + * specific settings for exporting data from the current context + */ + private AlignExportSettingsI exportSettings; - // same data source + /** + * sequence counter for FileParse object created from same data source + */ + public int index = 1; + /** + * separator for extracting specific 'frame' of a datasource for formats that + * support multiple records (e.g. BLC, Stockholm, etc) + */ protected char suffixSeparator = '#'; /** @@ -64,11 +112,11 @@ public class FileParse */ protected String suffix = null; - protected String type = null; + protected DataSourceType dataSourceType = null; protected BufferedReader dataIn = null; - protected String errormessage = "UNITIALISED SOURCE"; + protected String errormessage = "UNINITIALISED SOURCE"; protected boolean error = true; @@ -94,18 +142,20 @@ public class FileParse { if (from == null) { - throw new Error( - "Implementation error. Null FileParse in copy constructor"); + throw new Error(MessageManager + .getString("error.implementation_error_null_fileparse")); } if (from == this) + { return; + } index = ++from.index; inFile = from.inFile; suffixSeparator = from.suffixSeparator; suffix = from.suffix; errormessage = from.errormessage; // inherit potential error messages error = false; // reset any error condition. - type = from.type; + dataSourceType = from.dataSourceType; dataIn = from.dataIn; if (dataIn != null) { @@ -145,76 +195,175 @@ public class FileParse } if (!error) { - if (fileStr.toLowerCase().endsWith(".gz")) + try { - try - { - dataIn = tryAsGzipSource(new FileInputStream(fileStr)); - dataName = fileStr; - return error; - } catch (Exception x) - { - warningMessage = "Failed to resolve as a GZ stream (" - + x.getMessage() + ")"; - x.printStackTrace(); - } - ; + dataIn = checkForGzipStream(new FileInputStream(fileStr)); + dataName = fileStr; + } catch (Exception x) + { + warningMessage = "Failed to resolve " + fileStr + + " as a data source. (" + x.getMessage() + ")"; + // x.printStackTrace(); + error = true; } - - dataIn = new BufferedReader(new FileReader(fileStr)); - dataName = fileStr; + ; } return error; } - private BufferedReader tryAsGzipSource(InputStream inputStream) + /** + * Recognise the 2-byte magic header for gzip streams + * + * https://recalll.co/ask/v/topic/java-How-to-check-if-InputStream-is-Gzipped/555aadd62bd27354438b90f6 + * + * @param bytes + * - at least two bytes + * @return + * @throws IOException + */ + public static boolean isGzipStream(InputStream input) throws IOException + { + if (!input.markSupported()) + { + Console.error( + "FileParse.izGzipStream: input stream must support mark/reset"); + return false; + } + input.mark(4); + + // get first 2 bytes or return false + byte[] bytes = new byte[2]; + int read = input.read(bytes); + input.reset(); + if (read != bytes.length) + { + return false; + } + + int header = (bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00); + return (GZIPInputStream.GZIP_MAGIC == header); + } + + /** + * Returns a Reader for the given input after wrapping it in a buffered input + * stream, and then checking if it needs to be wrapped by a GZipInputStream + * + * @param input + * @return + */ + private BufferedReader checkForGzipStream(InputStream input) + throws Exception + { + // NB: stackoverflow + // https://stackoverflow.com/questions/4818468/how-to-check-if-inputstream-is-gzipped + // could use a PushBackInputStream rather than a BufferedInputStream + if (!input.markSupported()) + { + input = new BufferedInputStream(input, 16); + } + if (isGzipStream(input)) + { + return getGzipReader(input); + } + // return a buffered reader for the stream. + InputStreamReader isReader = new InputStreamReader(input); + BufferedReader toReadFrom = new BufferedReader(isReader); + return toReadFrom; + } + + /** + * Returns a {@code BufferedReader} which wraps the input stream with a + * GZIPInputStream. Throws a {@code ZipException} if a GZIP format error + * occurs or the compression method used is unsupported. + * + * @param inputStream + * @return + * @throws Exception + */ + private BufferedReader getGzipReader(InputStream inputStream) throws Exception { - BufferedReader inData = new BufferedReader(new InputStreamReader( - new GZIPInputStream(inputStream))); + BufferedReader inData = new BufferedReader( + new InputStreamReader(new GZIPInputStream(inputStream))); inData.mark(2048); inData.read(); inData.reset(); return inData; } - private boolean checkURLSource(String fileStr) throws IOException, - MalformedURLException + /** + * Tries to read from the given URL. If successful, saves a reader to the + * response in field {@code dataIn}, otherwise (on exception, or HTTP response + * status not 200), throws an exception. + *
+ * If the response status includes + * + *
+ * Content-Type : application/x-gzip + *+ * + * then tries to read as gzipped content. + * + * @param urlStr + * @throws IOException + * @throws MalformedURLException + */ + private void checkURLSource(String urlStr) + throws IOException, MalformedURLException { errormessage = "URL NOT FOUND"; - URL url = new URL(fileStr); - // - // GZIPInputStream code borrowed from Aquaria (soon to be open sourced) via - // Kenny Sabir - Exception e = null; - if (fileStr.toLowerCase().endsWith(".gz")) + URL url = new URL(urlStr); + URLConnection _conn = url.openConnection(); + if (_conn instanceof HttpURLConnection) + { + HttpURLConnection conn = (HttpURLConnection) _conn; + int rc = conn.getResponseCode(); + if (rc != HttpURLConnection.HTTP_OK) + { + throw new IOException( + "Response status from " + urlStr + " was " + rc); + } + } + else { try { - InputStream inputStream = url.openStream(); - dataIn = tryAsGzipSource(inputStream); - dataName = fileStr; - return false; + dataIn = checkForGzipStream(_conn.getInputStream()); + dataName = urlStr; + } catch (IOException ex) + { + throw new IOException("Failed to handle non-HTTP URI stream", ex); } catch (Exception ex) { - e = ex; + throw new IOException( + "Failed to determine type of input stream for given URI", + ex); } + return; } - - try - { - dataIn = new BufferedReader(new InputStreamReader(url.openStream())); - } catch (IOException q) + String encoding = _conn.getContentEncoding(); + String contentType = _conn.getContentType(); + boolean isgzipped = "application/x-gzip".equalsIgnoreCase(contentType) + || contentType.endsWith("gzip") || "gzip".equals(encoding); + Exception e = null; + InputStream inputStream = _conn.getInputStream(); + if (isgzipped) { - if (e != null) + try + { + dataIn = getGzipReader(inputStream); + dataName = urlStr; + } catch (Exception e1) { - throw new IOException("Failed to resolve GZIP stream", e); + throw new IOException(MessageManager + .getString("exception.failed_to_resolve_gzip_stream"), e); } - throw q; + return; } - // record URL as name of datasource. - dataName = fileStr; - return false; + + dataIn = new BufferedReader(new InputStreamReader(inputStream)); + dataName = urlStr; + return; } /** @@ -231,50 +380,109 @@ public class FileParse if (sfpos > -1 && sfpos < fileStr.length() - 1) { suffix = fileStr.substring(sfpos + 1); - // System.err.println("DEBUG: Found Suffix:"+suffix); + // jalview.bin.Console.errPrintln("DEBUG: Found Suffix:"+suffix); return fileStr.substring(0, sfpos); } return null; } /** + * not for general use, creates a fileParse object for an existing reader with + * configurable values for the origin and the type of the source + */ + public FileParse(BufferedReader source, String originString, + DataSourceType sourceType) + { + dataSourceType = sourceType; + error = false; + inFile = null; + dataName = originString; + dataIn = source; + try + { + if (dataIn.markSupported()) + { + dataIn.mark(READAHEAD_LIMIT); + } + } catch (IOException q) + { + + } + } + + /** * Create a datasource for input to Jalview. See AppletFormatAdapter for the * types of sources that are handled. * - * @param fileStr - * - datasource locator/content - * @param type + * @param file + * - datasource locator/content as File or String + * @param sourceType * - protocol of source * @throws MalformedURLException * @throws IOException */ - public FileParse(String fileStr, String type) + public FileParse(Object file, DataSourceType sourceType) throws MalformedURLException, IOException { - this.type = type; + if (file instanceof File) + { + parse((File) file, ((File) file).getPath(), sourceType, true); + } + else + { + parse(null, file.toString(), sourceType, false); + } + } + + private void parse(File file, String fileStr, DataSourceType sourceType, + boolean isFileObject) throws IOException + { + bytes = Platform.getFileBytes(file); + dataSourceType = sourceType; error = false; - if (type.equals(AppletFormatAdapter.FILE)) + if (sourceType == DataSourceType.FILE) { - if (checkFileSource(fileStr)) + + if (bytes != null) + { + // this will be from JavaScript + inFile = file; + dataIn = new BufferedReader( + new InputStreamReader(new ByteArrayInputStream(bytes))); + dataName = fileStr; + } + else if (checkFileSource(fileStr)) { String suffixLess = extractSuffix(fileStr); if (suffixLess != null) { if (checkFileSource(suffixLess)) { - throw new IOException("Problem opening " + inFile - + " (also tried " + suffixLess + ") : " + errormessage); + throw new IOException(MessageManager.formatMessage( + "exception.problem_opening_file_also_tried", + new String[] + { inFile.getName(), suffixLess, errormessage })); } } else { - throw new IOException("Problem opening " + inFile + " : " - + errormessage); + throw new IOException(MessageManager.formatMessage( + "exception.problem_opening_file", new String[] + { inFile.getName(), errormessage })); } } } - else if (type.equals(AppletFormatAdapter.URL)) + else if (sourceType == DataSourceType.RELATIVE_URL) + { + // BH 2018 hack for no support for access-origin + bytes = Platform.getFileAsBytes(fileStr); + dataIn = new BufferedReader( + new InputStreamReader(new ByteArrayInputStream(bytes))); + dataName = fileStr; + + } + else if (sourceType == DataSourceType.URL) { try { @@ -282,7 +490,9 @@ public class FileParse { checkURLSource(fileStr); if (suffixSeparator == '#') + { extractSuffix(fileStr); // URL lref is stored for later reference. + } } catch (IOException e) { String suffixLess = extractSuffix(fileStr); @@ -309,26 +519,27 @@ public class FileParse error = true; } } - else if (type.equals(AppletFormatAdapter.PASTE)) + else if (sourceType == DataSourceType.PASTE) { errormessage = "PASTE INACCESSIBLE!"; dataIn = new BufferedReader(new StringReader(fileStr)); dataName = "Paste"; } - else if (type.equals(AppletFormatAdapter.CLASSLOADER)) + else if (sourceType == DataSourceType.CLASSLOADER) { errormessage = "RESOURCE CANNOT BE LOCATED"; - java.io.InputStream is = getClass() - .getResourceAsStream("/" + fileStr); + InputStream is = getClass().getResourceAsStream("/" + fileStr); if (is == null) { String suffixLess = extractSuffix(fileStr); if (suffixLess != null) + { is = getClass().getResourceAsStream("/" + suffixLess); + } } if (is != null) { - dataIn = new BufferedReader(new java.io.InputStreamReader(is)); + dataIn = new BufferedReader(new InputStreamReader(is)); dataName = fileStr; } else @@ -339,14 +550,15 @@ public class FileParse else { errormessage = "PROBABLE IMPLEMENTATION ERROR : Datasource Type given as '" - + (type != null ? type : "null") + "'"; + + (sourceType != null ? sourceType : "null") + "'"; error = true; } if (dataIn == null || error) { // pass up the reason why we have no source to read from - throw new IOException("Failed to read data from source:\n" - + errormessage); + throw new IOException(MessageManager.formatMessage( + "exception.failed_to_read_data_from_source", new String[] + { errormessage })); } error = false; dataIn.mark(READAHEAD_LIMIT); @@ -366,17 +578,35 @@ public class FileParse } else { - throw new IOException("Unitialised Source Stream"); + throw new IOException( + MessageManager.getString("exception.no_init_source_stream")); } } public String nextLine() throws IOException { if (!error) + { return dataIn.readLine(); - throw new IOException("Invalid Source Stream:" + errormessage); + } + throw new IOException(MessageManager + .formatMessage("exception.invalid_source_stream", new String[] + { errormessage })); + } + + /** + * + * @return true if this FileParse is configured for Export only + */ + public boolean isExporting() + { + return !error && dataIn == null; } + /** + * + * @return true if the data source is valid + */ public boolean isValid() { return !error; @@ -395,19 +625,27 @@ public class FileParse } /** - * rewinds the datasource the beginning. + * Rewinds the datasource to the marked point if possible + * + * @param bytesRead * */ - public void reset() throws IOException + public void reset(int bytesRead) throws IOException { + if (bytesRead >= READAHEAD_LIMIT) + { + jalview.bin.Console.errPrintln(String.format( + "File reset error: read %d bytes but reset limit is %d", + bytesRead, READAHEAD_LIMIT)); + } if (dataIn != null && !error) { dataIn.reset(); } else { - throw new IOException( - "Implementation Error: Reset called for invalid source."); + throw new IOException(MessageManager.getString( + "error.implementation_error_reset_called_for_invalid_source")); } } @@ -474,4 +712,121 @@ public class FileParse } return null; } + + public AlignViewportI getViewport() + { + return viewport; + } + + public void setViewport(AlignViewportI viewport) + { + this.viewport = viewport; + } + + /** + * @return the currently configured exportSettings for writing data. + */ + public AlignExportSettingsI getExportSettings() + { + return exportSettings; + } + + /** + * Set configuration for export of data. + * + * @param exportSettings + * the exportSettings to set + */ + public void setExportSettings(AlignExportSettingsI exportSettings) + { + this.exportSettings = exportSettings; + } + + /** + * method overridden by complex file exporter/importers which support + * exporting visualisation and layout settings for a view + * + * @param avpanel + */ + public void configureForView(AlignmentViewPanel avpanel) + { + if (avpanel != null) + { + setViewport(avpanel.getAlignViewport()); + } + // could also set export/import settings + } + + /** + * Returns the preferred feature colour configuration if there is one, else + * null + * + * @return + */ + public FeatureSettingsModelI getFeatureColourScheme() + { + return null; + } + + public DataSourceType getDataSourceType() + { + return dataSourceType; + } + + /** + * Returns a buffered reader for the input object. Returns null, or throws + * IOException, on failure. + * + * @param file + * a File, or a String which is a name of a file + * @param sourceType + * @return + * @throws IOException + */ + public BufferedReader getBufferedReader(Object file, + DataSourceType sourceType) throws IOException + { + BufferedReader in = null; + byte[] bytes; + + switch (sourceType) + { + case FILE: + if (file instanceof String) + { + return new BufferedReader(new FileReader((String) file)); + } + bytes = Platform.getFileBytes((File) file); + if (bytes != null) + { + return new BufferedReader( + new InputStreamReader(new ByteArrayInputStream(bytes))); + } + return new BufferedReader(new FileReader((File) file)); + case URL: + URL url = new URL(file.toString()); + in = new BufferedReader(new InputStreamReader(url.openStream())); + break; + case RELATIVE_URL: // JalviewJS only + bytes = Platform.getFileAsBytes(file.toString()); + if (bytes != null) + { + in = new BufferedReader( + new InputStreamReader(new ByteArrayInputStream(bytes))); + } + break; + case PASTE: + in = new BufferedReader(new StringReader(file.toString())); + break; + case CLASSLOADER: + InputStream is = getClass().getResourceAsStream("/" + file); + if (is != null) + { + in = new BufferedReader(new InputStreamReader(is)); + } + break; + } + + return in; + } }