src/jalview/io/FileParse.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.io;
  22
  23 import jalview.api.AlignExportSettingsI;
  24 import jalview.api.AlignViewportI;
  25 import jalview.api.AlignmentViewPanel;
  26 import jalview.api.FeatureSettingsModelI;
  27 import jalview.util.MessageManager;
  28
  29 import java.io.BufferedReader;
  30 import java.io.ByteArrayInputStream;
  31 import java.io.File;
  32 import java.io.FileInputStream;
  33 import java.io.FileReader;
  34 import java.io.IOException;
  35 import java.io.InputStream;
  36 import java.io.InputStreamReader;
  37 import java.io.Reader;
  38 import java.io.StringReader;
  39 import java.net.MalformedURLException;
  40 import java.net.URL;
  41 import java.util.zip.GZIPInputStream;
  42
  43 /**
  44  * implements a random access wrapper around a particular datasource, for
  45  * passing to identifyFile and AlignFile objects.
  46  */
  47 public class FileParse
  48 {
  49   protected static final String SPACE = " ";
  50
  51   protected static final String TAB = "\t";
  52
  53   /**
  54    * text specifying source of data. usually filename or url.
  55    */
  56   private String dataName = "unknown source";
  57
  58   public File inFile = null;
  59
  60   private byte[] bytes; // from JavaScript
  61
  62   public byte[] getBytes()
  63   {
  64     return bytes;
  65   }
  66   /**
  67    * a viewport associated with the current file operation. May be null. May
  68    * move to different object.
  69    */
  70   private AlignViewportI viewport;
  71
  72   /**
  73    * specific settings for exporting data from the current context
  74    */
  75   private AlignExportSettingsI exportSettings;
  76
  77   /**
  78    * sequence counter for FileParse object created from same data source
  79    */
  80   public int index = 1;
  81
  82   /**
  83    * separator for extracting specific 'frame' of a datasource for formats that
  84    * support multiple records (e.g. BLC, Stockholm, etc)
  85    */
  86   protected char suffixSeparator = '#';
  87
  88   /**
  89    * character used to write newlines
  90    */
  91   protected String newline = System.getProperty("line.separator");
  92
  93   public void setNewlineString(String nl)
  94   {
  95     newline = nl;
  96   }
  97
  98   public String getNewlineString()
  99   {
 100     return newline;
 101   }
 102
 103   /**
 104    * '#' separated string tagged on to end of filename or url that was clipped
 105    * off to resolve to valid filename
 106    */
 107   protected String suffix = null;
 108
 109   protected DataSourceType dataSourceType = null;
 110
 111   protected BufferedReader dataIn = null;
 112
 113   protected String errormessage = "UNINITIALISED SOURCE";
 114
 115   protected boolean error = true;
 116
 117   protected String warningMessage = null;
 118
 119   /**
 120    * size of readahead buffer used for when initial stream position is marked.
 121    */
 122   final int READAHEAD_LIMIT = 2048;
 123
 124   public FileParse()
 125   {
 126   }
 127
 128   /**
 129    * Create a new FileParse instance reading from the same datasource starting
 130    * at the current position. WARNING! Subsequent reads from either object will
 131    * affect the read position of the other, but not the error state.
 132    *
 133    * @param from
 134    */
 135   public FileParse(FileParse from) throws IOException
 136   {
 137     if (from == null)
 138     {
 139       throw new Error(MessageManager
 140               .getString("error.implementation_error_null_fileparse"));
 141     }
 142     if (from == this)
 143     {
 144       return;
 145     }
 146     index = ++from.index;
 147     inFile = from.inFile;
 148     suffixSeparator = from.suffixSeparator;
 149     suffix = from.suffix;
 150     errormessage = from.errormessage; // inherit potential error messages
 151     error = false; // reset any error condition.
 152     dataSourceType = from.dataSourceType;
 153     dataIn = from.dataIn;
 154     if (dataIn != null)
 155     {
 156       mark();
 157     }
 158     dataName = from.dataName;
 159   }
 160
 161   /**
 162    * Attempt to open a file as a datasource. Sets error and errormessage if
 163    * fileStr was invalid.
 164    *
 165    * @param fileStr
 166    * @return this.error (true if the source was invalid)
 167    */
 168   private boolean checkFileSource(String fileStr) throws IOException
 169   {
 170     error = false;
 171     this.inFile = new File(fileStr);
 172     // check to see if it's a Jar file in disguise.
 173     if (!inFile.exists())
 174     {
 175       errormessage = "FILE NOT FOUND";
 176       error = true;
 177     }
 178     if (!inFile.canRead())
 179     {
 180       errormessage = "FILE CANNOT BE OPENED FOR READING";
 181       error = true;
 182     }
 183     if (inFile.isDirectory())
 184     {
 185       // this is really a 'complex' filetype - but we don't handle directory
 186       // reads yet.
 187       errormessage = "FILE IS A DIRECTORY";
 188       error = true;
 189     }
 190     if (!error)
 191     {
 192       if (fileStr.toLowerCase().endsWith(".gz"))
 193       {
 194         try
 195         {
 196           dataIn = tryAsGzipSource(new FileInputStream(fileStr));
 197           dataName = fileStr;
 198           return error;
 199         } catch (Exception x)
 200         {
 201           warningMessage = "Failed  to resolve as a GZ stream ("
 202                   + x.getMessage() + ")";
 203           // x.printStackTrace();
 204         }
 205         ;
 206       }
 207
 208       dataIn = new BufferedReader(new FileReader(fileStr));
 209       dataName = fileStr;
 210     }
 211     return error;
 212   }
 213
 214   private BufferedReader tryAsGzipSource(InputStream inputStream)
 215           throws Exception
 216   {
 217     BufferedReader inData = new BufferedReader(
 218             new InputStreamReader(new GZIPInputStream(inputStream)));
 219     inData.mark(2048);
 220     inData.read();
 221     inData.reset();
 222     return inData;
 223   }
 224
 225   private boolean checkURLSource(String fileStr)
 226           throws IOException, MalformedURLException
 227   {
 228     errormessage = "URL NOT FOUND";
 229     URL url = new URL(fileStr);
 230     //
 231     // GZIPInputStream code borrowed from Aquaria (soon to be open sourced) via
 232     // Kenny Sabir
 233     Exception e = null;
 234     if (fileStr.toLowerCase().endsWith(".gz"))
 235     {
 236       try
 237       {
 238         InputStream inputStream = url.openStream();
 239         dataIn = tryAsGzipSource(inputStream);
 240         dataName = fileStr;
 241         return false;
 242       } catch (Exception ex)
 243       {
 244         e = ex;
 245       }
 246     }
 247
 248     try
 249     {
 250       dataIn = new BufferedReader(new InputStreamReader(url.openStream()));
 251     } catch (IOException q)
 252     {
 253       if (e != null)
 254       {
 255         throw new IOException(MessageManager
 256                 .getString("exception.failed_to_resolve_gzip_stream"), e);
 257       }
 258       throw q;
 259     }
 260     // record URL as name of datasource.
 261     dataName = fileStr;
 262     return false;
 263   }
 264
 265   /**
 266    * sets the suffix string (if any) and returns remainder (if suffix was
 267    * detected)
 268    *
 269    * @param fileStr
 270    * @return truncated fileStr or null
 271    */
 272   private String extractSuffix(String fileStr)
 273   {
 274     // first check that there wasn't a suffix string tagged on.
 275     int sfpos = fileStr.lastIndexOf(suffixSeparator);
 276     if (sfpos > -1 && sfpos < fileStr.length() - 1)
 277     {
 278       suffix = fileStr.substring(sfpos + 1);
 279       // System.err.println("DEBUG: Found Suffix:"+suffix);
 280       return fileStr.substring(0, sfpos);
 281     }
 282     return null;
 283   }
 284
 285   /**
 286    * not for general use, creates a fileParse object for an existing reader with
 287    * configurable values for the origin and the type of the source
 288    */
 289   public FileParse(BufferedReader source, String originString,
 290           DataSourceType sourceType)
 291   {
 292     dataSourceType = sourceType;
 293     error = false;
 294     inFile = null;
 295     dataName = originString;
 296     dataIn = source;
 297     try
 298     {
 299       if (dataIn.markSupported())
 300       {
 301         dataIn.mark(READAHEAD_LIMIT);
 302       }
 303     } catch (IOException q)
 304     {
 305
 306     }
 307   }
 308
 309   /**
 310    * Create a datasource for input to Jalview. See AppletFormatAdapter for the
 311    * types of sources that are handled.
 312    *
 313    * @param file
 314    *          - datasource locator/content as File or String
 315    * @param sourceType
 316    *          - protocol of source
 317    * @throws MalformedURLException
 318    * @throws IOException
 319    */
 320   public FileParse(Object file, DataSourceType sourceType)
 321           throws MalformedURLException, IOException
 322   {
 323     if (file instanceof File)
 324     {
 325       parse((File) file, ((File) file).getPath(), sourceType, true);
 326     }
 327     else
 328     {
 329       parse(null, file.toString(), sourceType, false);
 330     }
 331   }
 332
 333   private void parse(File file, String fileStr, DataSourceType sourceType,
 334           boolean isFileObject) throws MalformedURLException, IOException
 335   {
 336     /**
 337      * @j2sNative
 338      *
 339      *            this.bytes = file && file._bytes;
 340      *
 341      */
 342     this.dataSourceType = sourceType;
 343     error = false;
 344
 345     if (sourceType == DataSourceType.FILE)
 346     {
 347
 348       if (bytes != null)
 349       {
 350         // this will be from JavaScript
 351         inFile = file;
 352         dataIn = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(bytes)));
 353         dataName = fileStr;
 354       }
 355       else if (checkFileSource(fileStr))
 356       {
 357         String suffixLess = extractSuffix(fileStr);
 358         if (suffixLess != null)
 359         {
 360           if (checkFileSource(suffixLess))
 361           {
 362             throw new IOException(MessageManager.formatMessage(
 363                     "exception.problem_opening_file_also_tried",
 364                     new String[]
 365                     { inFile.getName(), suffixLess, errormessage }));
 366           }
 367         }
 368         else
 369         {
 370           throw new IOException(MessageManager.formatMessage(
 371                   "exception.problem_opening_file", new String[]
 372                   { inFile.getName(), errormessage }));
 373         }
 374       }
 375     }
 376     else if (sourceType == DataSourceType.RELATIVE_URL)
 377     {
 378       /**
 379        * BH 2018 hack for no support for access-origin
 380        *
 381        * @j2sNative
 382        *
 383        * this.bytes = swingjs.JSUtil.getFileAsBytes$O(fileStr);
 384        *
 385        */
 386
 387       dataIn = new BufferedReader(new java.io.InputStreamReader(new ByteArrayInputStream(bytes)));
 388       dataName = fileStr;
 389
 390     }
 391     else if (sourceType == DataSourceType.URL)
 392     {
 393       try
 394       {
 395         try
 396         {
 397           checkURLSource(fileStr);
 398           if (suffixSeparator == '#')
 399           {
 400             extractSuffix(fileStr); // URL lref is stored for later reference.
 401           }
 402         } catch (IOException e)
 403         {
 404           String suffixLess = extractSuffix(fileStr);
 405           if (suffixLess == null)
 406           {
 407             throw (e);
 408           }
 409           else
 410           {
 411             try
 412             {
 413               checkURLSource(suffixLess);
 414             } catch (IOException e2)
 415             {
 416               errormessage = "BAD URL WITH OR WITHOUT SUFFIX";
 417               throw (e); // just pass back original - everything was wrong.
 418             }
 419           }
 420         }
 421       } catch (Exception e)
 422       {
 423         errormessage = "CANNOT ACCESS DATA AT URL '" + fileStr + "' ("
 424                 + e.getMessage() + ")";
 425         error = true;
 426       }
 427     }
 428     else if (sourceType == DataSourceType.PASTE)
 429     {
 430       errormessage = "PASTE INACCESSIBLE!";
 431       dataIn = new BufferedReader(new StringReader(fileStr));
 432       dataName = "Paste";
 433     }
 434     else if (sourceType == DataSourceType.CLASSLOADER)
 435     {
 436       errormessage = "RESOURCE CANNOT BE LOCATED";
 437       java.io.InputStream is = getClass()
 438               .getResourceAsStream("/" + fileStr);
 439       if (is == null)
 440       {
 441         String suffixLess = extractSuffix(fileStr);
 442         if (suffixLess != null)
 443         {
 444           is = getClass().getResourceAsStream("/" + suffixLess);
 445         }
 446       }
 447       if (is != null)
 448       {
 449         dataIn = new BufferedReader(new java.io.InputStreamReader(is));
 450         dataName = fileStr;
 451       }
 452       else
 453       {
 454         error = true;
 455       }
 456     }
 457     else
 458     {
 459       errormessage = "PROBABLE IMPLEMENTATION ERROR : Datasource Type given as '"
 460               + (sourceType != null ? sourceType : "null") + "'";
 461       error = true;
 462     }
 463     if (dataIn == null || error)
 464     {
 465       // pass up the reason why we have no source to read from
 466       throw new IOException(MessageManager.formatMessage(
 467               "exception.failed_to_read_data_from_source",
 468               new String[]
 469               { errormessage }));
 470     }
 471     error = false;
 472     dataIn.mark(READAHEAD_LIMIT);
 473   }
 474
 475   /**
 476    * mark the current position in the source as start for the purposes of it
 477    * being analysed by IdentifyFile().identify
 478    *
 479    * @throws IOException
 480    */
 481   public void mark() throws IOException
 482   {
 483     if (dataIn != null)
 484     {
 485       dataIn.mark(READAHEAD_LIMIT);
 486     }
 487     else
 488     {
 489       throw new IOException(
 490               MessageManager.getString("exception.no_init_source_stream"));
 491     }
 492   }
 493
 494   public String nextLine() throws IOException
 495   {
 496     if (!error)
 497     {
 498       return dataIn.readLine();
 499     }
 500     throw new IOException(MessageManager
 501             .formatMessage("exception.invalid_source_stream", new String[]
 502             { errormessage }));
 503   }
 504
 505   /**
 506    *
 507    * @return true if this FileParse is configured for Export only
 508    */
 509   public boolean isExporting()
 510   {
 511     return !error && dataIn == null;
 512   }
 513
 514   /**
 515    *
 516    * @return true if the data source is valid
 517    */
 518   public boolean isValid()
 519   {
 520     return !error;
 521   }
 522
 523   /**
 524    * closes the datasource and tidies up. source will be left in an error state
 525    */
 526   public void close() throws IOException
 527   {
 528     errormessage = "EXCEPTION ON CLOSE";
 529     error = true;
 530     dataIn.close();
 531     dataIn = null;
 532     errormessage = "SOURCE IS CLOSED";
 533   }
 534
 535   /**
 536    * Rewinds the datasource to the marked point if possible
 537    *
 538    * @param bytesRead
 539    *
 540    */
 541   public void reset(int bytesRead) throws IOException
 542   {
 543     if (bytesRead >= READAHEAD_LIMIT)
 544     {
 545       System.err.println(String.format(
 546               "File reset error: read %d bytes but reset limit is %d",
 547               bytesRead, READAHEAD_LIMIT));
 548     }
 549     if (dataIn != null && !error)
 550     {
 551       dataIn.reset();
 552     }
 553     else
 554     {
 555       throw new IOException(MessageManager.getString(
 556               "error.implementation_error_reset_called_for_invalid_source"));
 557     }
 558   }
 559
 560   /**
 561    *
 562    * @return true if there is a warning for the user
 563    */
 564   public boolean hasWarningMessage()
 565   {
 566     return (warningMessage != null && warningMessage.length() > 0);
 567   }
 568
 569   /**
 570    *
 571    * @return empty string or warning message about file that was just parsed.
 572    */
 573   public String getWarningMessage()
 574   {
 575     return warningMessage;
 576   }
 577
 578   public String getInFile()
 579   {
 580     if (inFile != null)
 581     {
 582       return inFile.getAbsolutePath() + " (" + index + ")";
 583     }
 584     else
 585     {
 586       return "From Paste + (" + index + ")";
 587     }
 588   }
 589
 590   /**
 591    * @return the dataName
 592    */
 593   public String getDataName()
 594   {
 595     return dataName;
 596   }
 597
 598   /**
 599    * set the (human readable) name or URI for this datasource
 600    *
 601    * @param dataname
 602    */
 603   protected void setDataName(String dataname)
 604   {
 605     dataName = dataname;
 606   }
 607
 608   /**
 609    * get the underlying bufferedReader for this data source.
 610    *
 611    * @return null if no reader available
 612    * @throws IOException
 613    */
 614   public Reader getReader()
 615   {
 616     if (dataIn != null) // Probably don't need to test for readiness &&
 617                         // dataIn.ready())
 618     {
 619       return dataIn;
 620     }
 621     return null;
 622   }
 623
 624   public AlignViewportI getViewport()
 625   {
 626     return viewport;
 627   }
 628
 629   public void setViewport(AlignViewportI viewport)
 630   {
 631     this.viewport = viewport;
 632   }
 633
 634   /**
 635    * @return the currently configured exportSettings for writing data.
 636    */
 637   public AlignExportSettingsI getExportSettings()
 638   {
 639     return exportSettings;
 640   }
 641
 642   /**
 643    * Set configuration for export of data.
 644    *
 645    * @param exportSettings
 646    *          the exportSettings to set
 647    */
 648   public void setExportSettings(AlignExportSettingsI exportSettings)
 649   {
 650     this.exportSettings = exportSettings;
 651   }
 652
 653   /**
 654    * method overridden by complex file exporter/importers which support
 655    * exporting visualisation and layout settings for a view
 656    *
 657    * @param avpanel
 658    */
 659   public void configureForView(AlignmentViewPanel avpanel)
 660   {
 661     if (avpanel != null)
 662     {
 663       setViewport(avpanel.getAlignViewport());
 664     }
 665     // could also set export/import settings
 666   }
 667
 668   /**
 669    * Returns the preferred feature colour configuration if there is one, else
 670    * null
 671    *
 672    * @return
 673    */
 674   public FeatureSettingsModelI getFeatureColourScheme()
 675   {
 676     return null;
 677   }
 678
 679   public DataSourceType getDataSourceType()
 680   {
 681     return dataSourceType;
 682   }
 683 }