<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  
  
  <title>File Output - Apache Apex Malhar Documentation</title>
  

  <link rel="shortcut icon" href="../../favicon.ico">
  

  
  <link href='https://fonts.googleapis.com/css?family=Lato:400,700|Roboto+Slab:400,700|Inconsolata:400,700' rel='stylesheet' type='text/css'>

  <link rel="stylesheet" href="../../css/theme.css" type="text/css" />
  <link rel="stylesheet" href="../../css/theme_extra.css" type="text/css" />
  <link rel="stylesheet" href="../../css/highlight.css">

  
  <script>
    // Current page data
    var mkdocs_page_name = "File Output";
    var mkdocs_page_input_path = "operators/file_output.md";
    var mkdocs_page_url = "/operators/file_output/";
  </script>
  
  <script src="../../js/jquery-2.1.1.min.js"></script>
  <script src="../../js/modernizr-2.8.3.min.js"></script>
  <script type="text/javascript" src="../../js/highlight.pack.js"></script>
  <script src="../../js/theme.js"></script> 

  
</head>

<body class="wy-body-for-nav" role="document">

  <div class="wy-grid-for-nav">

    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side stickynav">
      <div class="wy-side-nav-search">
        <a href="../.." class="icon icon-home"> Apache Apex Malhar Documentation</a>
        <div role="search">
  <form id ="rtd-search-form" class="wy-form" action="../../search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
  </form>
</div>
      </div>

      <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
        <ul class="current">
          
            <li>
    <li class="toctree-l1 ">
        <a class="" href="../..">Apache Apex Malhar</a>
        
    </li>
<li>
          
            <li>
    <ul class="subnav">
    <li><span>APIs</span></li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../../apis/calcite/">SQL</a>
        
    </li>

        
    </ul>
<li>
          
            <li>
    <ul class="subnav">
    <li><span>Operators</span></li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../block_reader/">Block Reader</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../csvformatter/">CSV Formatter</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../csvParserOperator/">CSV Parser</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../deduper/">Deduper</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../enricher/">Enricher</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../fsInputOperator/">File Input</a>
        
    </li>

        
            
    <li class="toctree-l1 current">
        <a class="current" href="./">File Output</a>
        
            <ul>
            
                <li class="toctree-l3"><a href="#abstractfileoutputoperator">AbstractFileOutputOperator</a></li>
                
                    <li><a class="toctree-l4" href="#persisting-data-to-files">Persisting data to files</a></li>
                
                    <li><a class="toctree-l4" href="#automatic-rotation">Automatic rotation</a></li>
                
                    <li><a class="toctree-l4" href="#fault-tolerance">Fault-tolerance</a></li>
                
            
            </ul>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../file_splitter/">File Splitter</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../filter/">Filter</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../fixedWidthParserOperator/">Fixed Width Parser</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../ftpInputOperator/">FTP Input Operator</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../AbstractJdbcTransactionableOutputOperator/">Jdbc Output Operator</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../jdbcPollInputOperator/">JDBC Poller Input</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../jmsInputOperator/">JMS Input</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../jsonFormatter/">JSON Formatter</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../jsonParser/">JSON Parser</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../kafkaInputOperator/">Kafka Input</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../regexparser/">Regex Parser</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../s3outputmodule/">S3 Output Module</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../transform/">Transformer</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../windowedOperator/">Windowed Operator</a>
        
    </li>

        
            
    <li class="toctree-l1 ">
        <a class="" href="../xmlParserOperator/">XML Parser</a>
        
    </li>

        
    </ul>
<li>
          
        </ul>
      </div>
      &nbsp;
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
        <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
        <a href="../..">Apache Apex Malhar Documentation</a>
      </nav>

      
      <div class="wy-nav-content">
        <div class="rst-content">
          <div role="navigation" aria-label="breadcrumbs navigation">
  <ul class="wy-breadcrumbs">
    <li><a href="../..">Docs</a> &raquo;</li>
    
      
        
          <li>Operators &raquo;</li>
        
      
    
    <li>File Output</li>
    <li class="wy-breadcrumbs-aside">
      
    </li>
  </ul>
  <hr/>
</div>
          <div role="main">
            <div class="section">
              
                <h1 id="abstractfileoutputoperator">AbstractFileOutputOperator</h1>
<p>The abstract file output operator in Apache Apex Malhar library &mdash; <a href="https://github.com/apache/incubator-apex-malhar/blob/master/library/src/main/java/com/datatorrent/lib/io/fs/AbstractFileOutputOperator.java"><code>AbstractFileOutputOperator</code></a> writes streaming data to files. The main features of this operator are:</p>
<ol>
<li>Persisting data to files.</li>
<li>Automatic rotation of files based on:<br />
  a. maximum length of a file.<br />
  b. time-based rotation where time is specified using a count of application windows.</li>
<li>Fault-tolerance.</li>
<li>Compression and encryption of data before it is persisted.</li>
</ol>
<p>In this tutorial we will cover the details of the basic structure and implementation of all the above features in <code>AbstractFileOutputOperator</code>. Configuration items related to each feature are discussed as they are introduced in the section of that feature.</p>
<h2 id="persisting-data-to-files">Persisting data to files</h2>
<p>The principal function of this operator is to persist tuples to files efficiently. These files are created under a specific directory on the file system. The relevant configuration item is:</p>
<p><strong>filePath</strong>: path specifying the directory where files are written.</p>
<p>Different types of file system that are implementations of <code>org.apache.hadoop.fs.FileSystem</code> are supported. The file system instance which is used for creating streams is constructed from the <code>filePath</code> URI.</p>
<pre><code class="java">FileSystem.newInstance(new Path(filePath).toUri(), new Configuration())
</code></pre>

<p>Tuples may belong to different files therefore expensive IO operations like creating multiple output streams, flushing of data to disk, and closing streams are handled carefully.</p>
<h3 id="ports">Ports</h3>
<ul>
<li><code>input</code>: the input port on which tuples to be persisted are received.</li>
</ul>
<h3 id="streamscache"><code>streamsCache</code></h3>
<p>This transient state caches output streams per file in memory. The file to which the data is appended may change with incoming tuples. It will be highly inefficient to keep re-opening streams for a file just because tuples for that file are interleaved with tuples for another file. Therefore, the operator maintains a cache of limited size with open output streams.</p>
<p><code>streamsCache</code> is of type <code>com.google.common.cache.LoadingCache</code>. A <code>LoadingCache</code> has an attached <code>CacheLoader</code> which is responsible to load value of a key when the key is not present in the cache. Details are explained here- <a href="https://github.com/google/guava/wiki/CachesExplained">CachesExplained</a>.</p>
<p>The operator constructs this cache in <code>setup(...)</code>. It is built with the following configuration items:</p>
<ul>
<li><strong>maxOpenFiles</strong>: maximum size of the cache. The cache evicts entries that haven't been used recently when the cache size is approaching this limit. <em>Default</em>: 100</li>
<li><strong>expireStreamAfterAcessMillis</strong>: expires streams after the specified duration has passed since the stream was last accessed. <em>Default</em>: value of attribute- <code>OperatorContext.SPIN_MILLIS</code>.</li>
</ul>
<p>An important point to note here is that the guava cache does not perform cleanup and evict values asynchronously, that is, instantly after a value expires. Instead, it performs small amounts of maintenance during write operations, or during occasional read operations if writes are rare.</p>
<h4 id="cacheloader">CacheLoader</h4>
<p><code>streamsCache</code> is created with a <code>CacheLoader</code> that opens an <code>FSDataOutputStream</code> for a file which is not in the cache. The output stream is opened in either <code>append</code> or <code>create</code> mode and the basic logic to determine this is explained by the simple diagram below.</p>
<p><img alt="Opening an output stream" src="../images/fileoutput/diagram1.png" /></p>
<p>This process gets complicated when fault-tolerance (writing to temporary files)  and rotation is added.</p>
<p>Following are few configuration items used for opening the streams:</p>
<ul>
<li><strong>replication</strong>: specifies the replication factor of the output files. <em>Default</em>: <code>fs.getDefaultReplication(new Path(filePath))</code></li>
<li><strong>filePermission</strong>: specifies the permission of the output files. The permission is an octal number similar to that used by the Unix chmod command. <em>Default</em>: 0777</li>
</ul>
<h4 id="removallistener">RemovalListener</h4>
<p>A <code>Guava</code> cache also allows specification of removal listener which can perform some operation when an entry is removed from the cache. Since <code>streamsCache</code> is of limited size and also has time-based expiry enabled, it is imperative that when a stream is evicted from the cache it is closed properly. Therefore, we attach a removal listener to <code>streamsCache</code> which closes the stream when it is evicted.</p>
<h3 id="setupoperatorcontext-context"><code>setup(OperatorContext context)</code></h3>
<p>During setup the following main tasks are performed:</p>
<ol>
<li>FileSystem instance is created.</li>
<li>The cache of streams is created.</li>
<li>Files are recovered (see Fault-tolerance section).</li>
<li>Stray part files are cleaned (see Automatic rotation section).</li>
</ol>
<h3 id="processtupleinput-tuple"><a name="processTuple"></a><code>processTuple(INPUT tuple)</code></h3>
<p>The code snippet below highlights the basic steps of processing a tuple.</p>
<pre><code class="java">protected void processTuple(INPUT tuple)
{  
  //which file to write to is derived from the tuple.
  String fileName = getFileName(tuple);  

  //streamsCache is queried for the output stream. If the stream is already opened then it is returned immediately otherwise the cache loader creates one.
  FilterOutputStream fsOutput = streamsCache.get(fileName).getFilterStream();

  byte[] tupleBytes = getBytesForTuple(tuple);

  fsOutput.write(tupleBytes);
}
</code></pre>

<h3 id="endwindow"><a name="endWindow"></a>endWindow()</h3>
<p>It should be noted that while processing a tuple we do not flush the stream after every write. Since flushing is expensive it is done periodically for all the open streams in the operator's <code>endWindow()</code>.</p>
<pre><code class="java">Map&lt;String, FSFilterStreamContext&gt; openStreams = streamsCache.asMap();
for (FSFilterStreamContext streamContext: openStreams.values()) {
  ...
  //this flushes the stream
  streamContext.finalizeContext();
  ...
}
</code></pre>

<p><code>FSFilterStreamContext</code> will be explained with compression and encryption.</p>
<h3 id="teardown"><a name="teardown"></a>teardown()</h3>
<p>When any operator in a DAG fails then the application master invokes <code>teardown()</code> for that operator and its downstream operators. In <code>AbstractFileOutputOperator</code> we have a bunch of open streams in the cache and the operator (acting as HDFS client) holds leases for all the corresponding files. It is important to release these leases for clean re-deployment. Therefore, we try to close all the open streams in <code>teardown()</code>.</p>
<h2 id="automatic-rotation">Automatic rotation</h2>
<p>In a streaming application where data is being continuously processed, when this output operator is used, data will be continuously written to an output file. The users may want to be able to take the data from time to time to use it, copy it out of Hadoop or do some other processing. Having all the data in a single file makes it difficult as the user needs to keep track of how much data has been read from the file each time so that the same data is not read again. Also users may already have processes and scripts in place that work with full files and not partial data from a file.</p>
<p>To help solve these problems the operator supports creating many smaller files instead of writing to just one big file. Data is written to a file and when some condition is met the file is finalized and data is written to a new file. This is called file rotation. The user can determine when the file gets rotated. Each of these files is called a part file as they contain portion of the data.</p>
<h3 id="part-filename">Part filename</h3>
<p>The filename for a part file is formed by using the original file name and the part number. The part number starts from 0 and is incremented each time a new part file created. The default filename has the format, assuming origfile represents the original filename and partnum represents the part number,</p>
<p><code>origfile.partnum</code></p>
<p>This naming scheme can be changed by the user. It can be done so by overriding the following method</p>
<pre><code class="java">protected String getPartFileName(String fileName, int part)
</code></pre>

<p>This method is passed the original filename and part number as arguments and should return the part filename.</p>
<h3 id="mechanisms">Mechanisms</h3>
<p>The user has a couple of ways to specify when a file gets rotated. First is based on size and second on time. In the first case the files are limited by size and in the second they are rotated by time.</p>
<h4 id="size-based">Size Based</h4>
<p>With size based rotation the user specifies a size limit. Once the size of the currently file reaches this limit the file is rotated. The size limit can be specified by setting the following property</p>
<p><code>maxLength</code></p>
<p>Like any other property this can be set in Java application code or in the property file.</p>
<h4 id="time-based">Time Based</h4>
<p>In time based rotation user specifies a time interval. This interval is specified as number of application windows. The files are rotated periodically once the specified number of application windows have elapsed. Since the interval is application window based it is not always exactly constant time. The interval can be specified using the following property</p>
<p><code>rotationWindows</code></p>
<h3 id="setupoperatorcontext-context_1"><code>setup(OperatorContext context)</code></h3>
<p>When an operator is being started there may be stray part files and they need to be cleaned up. One common scenario, when these could be present, is in the case of failure, where a node running the operator failed and a previous instance of the operator was killed. This cleanup and other initial processing for the part files happens in the operator setup. The following diagram describes this process</p>
<p><img alt="Rotation setup" src="../images/fileoutput/FileRotation.png" /></p>
<h2 id="fault-tolerance">Fault-tolerance</h2>
<p>There are two issues that should be addressed in order to make the operator fault-tolerant:</p>
<ol>
<li>
<p>The operator flushes data to the filesystem every application window. This implies that after a failure when the operator is re-deployed and tuples of a window are replayed, then duplicate data will be saved to the files. This is handled by recording how much the operator has written to each file every window in a state that is checkpointed and truncating files back to the recovery checkpoint after re-deployment.</p>
</li>
<li>
<p>While writing to HDFS, if the operator gets killed and didn't have the opportunity to close a file, then later when it is redeployed it will attempt to truncate/restore that file. Restoring a file may fail because the lease that the previous process (operator instance before failure) had acquired from namenode to write to a file may still linger and therefore there can be exceptions in acquiring the lease again by the new process (operator instance after failure). This is handled by always writing data to temporary files and renaming these files to actual files when a file is finalized (closed) for writing, that is, we are sure that no more data will be written to it. The relevant configuration item is:  </p>
</li>
<li><strong>alwaysWriteToTmp</strong>: enables/disables writing to a temporary file. <em>Default</em>: true.</li>
</ol>
<p>Most of the complexity in the code comes from making this operator fault-tolerant.</p>
<h3 id="checkpointed-states-needed-for-fault-tolerance">Checkpointed states needed for fault-tolerance</h3>
<ul>
<li>
<p><code>endOffsets</code>: contains the size of each file as it is being updated by the operator. It helps the operator to restore a file during recovery in operator <code>setup(...)</code> and is also used while loading a stream to find out if the operator has seen a file before.</p>
</li>
<li>
<p><code>fileNameToTmpName</code>: contains the name of the temporary file per actual file. It is needed because the name of a temporary file is random. They are named based on the timestamp when the stream is created. During recovery the operator needs to know the temp file which it was writing to and if it needs restoration then it creates a new temp file and updates this mapping.</p>
</li>
<li>
<p><code>finalizedFiles</code>: contains set of files which were requested to be finalized per window id.</p>
</li>
<li>
<p><code>finalizedPart</code>: contains the latest <code>part</code> of each file which was requested to be finalized.</p>
</li>
</ul>
<p>The use of <code>finalizedFiles</code> and <code>finalizedPart</code> are explained in detail under <a href="#requestFinalize"><code>requestFinalize(...)</code></a> method.</p>
<h3 id="recovering-files">Recovering files</h3>
<p>When the operator is re-deployed, it checks in its <code>setup(...)</code> method if the state of a file which it has seen before the failure is consistent with the file's state on the file system, that is, the size of the file on the file system should match the size in the <code>endOffsets</code>. When it doesn't the operator truncates the file.</p>
<p>For example, let's say the operator wrote 100 bytes to test1.txt by the end of window 10. It wrote another 20 bytes by the end of window 12 but failed in window 13. When the operator gets re-deployed it is restored with window 10 (recovery checkpoint) state. In the previous run, by the end of window 10, the size of file on the filesystem was 100 bytes but now it is 120 bytes. Tuples for windows 11 and 12 are going to be replayed. Therefore, in order to avoid writing duplicates to test1.txt, the operator truncates the file to 100 bytes (size at the end of window 10) discarding the last 20 bytes.</p>
<h3 id="requestfinalizestring-filename"><a name="requestFinalize"></a><code>requestFinalize(String fileName)</code></h3>
<p>When the operator is always writing to temporary files (in order to avoid HDFS Lease exceptions), then it is necessary to rename the temporary files to the actual files once it has been determined that the files are closed. This is refered to as <em>finalization</em> of files and the method allows the user code to specify when a file is ready for finalization.</p>
<p>In this method, the requested file (or in the case of rotation &mdash; all the file parts including the latest open part which have not yet been requested for finalization) are registered for finalization. Registration is basically adding the file names to <code>finalizedFiles</code> state and updating <code>finalizedPart</code>.</p>
<p>The process of <em>finalization</em> of all the files which were requested till the window <em>w</em> is deferred till window <em>w</em> is committed. This is because until a window is committed it can be replayed after a failure which means that a file can be open for writing even after it was requested for finalization.</p>
<p>When rotation is enabled, part files as and when they get completed are requested for finalization. However, when rotation is not enabled user code needs to invoke this method as the knowledge that when a file is closed is unknown to this abstract operator.</p>
              
            </div>
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="../file_splitter/" class="btn btn-neutral float-right" title="File Splitter">Next <span class="icon icon-circle-arrow-right"></span></a>
      
      
        <a href="../fsInputOperator/" class="btn btn-neutral" title="File Input"><span class="icon icon-circle-arrow-left"></span> Previous</a>
      
    </div>
  

  <hr/>

  <div role="contentinfo">
    <!-- Copyright etc -->
    
  </div>

  Built with <a href="http://www.mkdocs.org">MkDocs</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
</footer>
	  
        </div>
      </div>

    </section>

  </div>

<div class="rst-versions" role="note" style="cursor: pointer">
    <span class="rst-current-version" data-toggle="rst-current-version">
      
      
        <span><a href="../fsInputOperator/" style="color: #fcfcfc;">&laquo; Previous</a></span>
      
      
        <span style="margin-left: 15px"><a href="../file_splitter/" style="color: #fcfcfc">Next &raquo;</a></span>
      
    </span>
</div>

</body>
</html>
