<!DOCTYPE html>
<html lang="en">
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at
      http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<head>
    <meta charset="utf-8" />
    <title>PutAzureDataLakeStorage</title>
    <link rel="stylesheet" href="../../../../../css/component-usage.css" type="text/css" />
</head>

<body>

<p>
    This processor is responsible for uploading files to Azure Data Lake Storage Gen2.
</p>

<h3>File uploading and cleanup process</h3>

<h4>New file upload</h4>

<ol>
    <li>A temporary file is created with random prefix under the given path in '_nifitempdirectory'.</li>
    <li>Content is appended to temp file.</li>
    <li>Temp file is renamed to its original name, the original file is overwritten.</li>
    <li>In case of appending or renaming failure the temp file is deleted, the original file remains intact.</li>
    <li>In case of temporary file deletion failure both temp file and original file remain on the server.</li>
</ol>

<h4>Existing file upload</h4>

<ul>
    <li>Processors with "fail" conflict resolution strategy will be directed to "Failure" relationship.</li>
    <li>Processors with "ignore" conflict resolution strategy will be directed to "Success" relationship.</li>
    <li>Processors with "replace" conflict resolution strategy:</li>

    <ol>
        <li>A temporary file is created with random prefix under the given path in '_nifitempdirectory'.</li>
        <li>Content is appended to temp file.</li>
        <li>Temp file is renamed to its original name, the original file is overwritten.</li>
        <li>In case of appending or renaming failure the temp file is deleted, the original file remains intact.</li>
        <li>In case of temporary file deletion failure both temp file and original file remain on the server.</li>
    </ol>
</ul>

</body>
</html>

