Exabyter Lite 매뉴얼

<웹 루트>/innorix/
├── innorix.js        (라이선스 포함)
├── innorix.css
├── config.js         (화면 프리셋)
├── install/          (에이전트 설치 페이지, 파일)
└── exam/             (샘플, 운영 배포 제외)

<웹 애플리케이션>/WEB-INF/lib/
└── InnorixJAVA.jar (+ 의존 jar)

mkdir -p /data/innorix/upload
chown -R tomcat:tomcat /data/innorix/upload
chmod 750 /data/innorix/upload

<link rel="stylesheet" href="/innorix/innorix.css">
<script src="/innorix/innorix.js"></script>
<script src="/innorix/config.js"></script>

box = innorix.create({
  el: '#fileBox',
  uploadURL: '/innorix/exam/upload.jsp',
  boxConfig: box_config.upload_basic,
  boxWidth: 800   // 프리셋 값(600)을 덮어씀
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  boxStyle: 'list'          // list, icon, preview, html
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  transferWindowStyle: 'mini'   // default, mini, list, compact
});

파일 선택 대화상자 ─┐
폴더 선택 대화상자 ─┤
드래그 앤 드롭 ─────┼→ 업로드 목록 → 검증 → 전송
프로그램 경로 지정 ─┘

<div id="fileBox"></div>
<input type="button" value="파일 추가"      onclick="box.openFileDialog();">
<input type="button" value="단일 파일 추가" onclick="box.openFileDialogSingle();">
<input type="button" value="폴더 추가"      onclick="box.openFolderDialog();">
<input type="button" value="업로드"         onclick="box.upload();">

<script>
  var box;
  window.onload = function () {
    box = innorix.create({
      el: '#fileBox',
      uploadURL: './upload.jsp',
      installURL: '../install/install.html',
      folderAttach: true,
      addFolder: true
    });
  };
</script>

var started = false;  // 연속 첨부 시 upload()가 두 번 호출되지 않게 막음
box.on('afterAddFiles', function (files) {
  if (started) return;
  started = true;
  box.setPostData({ resourceId: document.getElementById('resourceId').value });
  box.upload();
});

선택한 파일 → 중복 → 개수 → 전체 용량 → 차단 확장자 → 허용 확장자 → 개별 용량 → 원본 존재 → 목록 추가
                                  (처음 실패한 항목에서 거부, addFileError)

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  maxFileCount: 5,
  maxFileSize: 10 * 1024 * 1024,    // 파일당 10MB
  maxTotalSize: 50 * 1024 * 1024,   // 합계 50MB
  allowType: ['jpg', 'png', 'pdf'],
  denyType: ['exe', 'msi', 'bat'],
  useSignature: true
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  maxFileSize: 10 * 1024 * 1024,
  denyType: ['zip'],
  showNotificationLayer: false
});

var MESSAGES = {
  maxFileSize:      '파일당 10MB까지 첨부할 수 있습니다.',
  denyType:         'ZIP 파일은 첨부할 수 없습니다.',
  addDuplicateFile: '이미 첨부된 파일입니다.'
};

box.on('addFileError', function (p) {
  var list = Array.isArray(p) ? p : [p];
  var e = list[0];
  alert(MESSAGES[e.type] || e.message);
});

var batchFailed = false;

box.on('addFileError', function (p) {
  batchFailed = true;
  var e = (Array.isArray(p) ? p : [p])[0];
  alert(e.message);
});

box.on('afterAddFiles', function (added) {
  if (batchFailed) {
    added.forEach(function (f) { box.removeFileById(f.id); });
  }
  batchFailed = false;
});

upload() → uploadBefore 확인 → 전송 (진행률 uploadProgress) → uploadComplete
                                     │
                          일시 정지 / 재개 / 취소 / 오류 재시도

<div id="fileBox"></div>
<input type="button" value="파일 추가" onclick="box.openFileDialog();">
<input type="button" value="업로드"    onclick="box.upload();">

<script>
  var box;
  window.onload = function () {
    box = innorix.create({
      el: '#fileBox',
      uploadURL: './upload.jsp'
    });
    box.on('uploadBefore', function () {
      if (!document.getElementById('agree').checked) {
        alert('약관에 동의해야 업로드할 수 있습니다.');
        return false;   // 시작 취소
      }
    });
    box.on('uploadComplete', function (p) { console.log(p.files); });
  };
</script>

function uploadSelectedOnly() {
  var selected = box.getSelectedFiles();
  if (selected.length === 0) { alert('선택한 파일이 없습니다.'); return; }

  box.getUploadFiles().forEach(function (f) {
    if (!f.selected) box.removeFileById(f.id);
  });
  box.upload();
}

<input type="button" value="일시 정지" onclick="box.transferPause();">
<input type="button" value="재개"      onclick="box.transferResume();">
<input type="button" value="취소"      onclick="box.transferCancel();">

<script>
  box.on('uploadPause',  function (p) { console.log('정지', p.progress + '%'); });
  box.on('uploadResume', function (p) { console.log('재개'); });
  box.on('uploadCancel', function (p) { console.log('취소'); });
</script>

요청 수신 → getFileInfo (저장 경로, 파일명 결정) → attachFile (구간 저장, 반복)
         → attachFileCompleted (파일 한 개 완료) → isUploadDone() 후처리

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="com.innorix.transfer.InnorixUpload" %>
<%
if (request.getMethod().equals("POST")) {
    String directory = InnorixUpload.getServletAbsolutePath(request);
    directory = directory.substring(0, directory.lastIndexOf("/") + 1) + "data";
    int maxPostSize = 2147482624;   // bytes

    InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, directory);
    String result = uploader.run();

    if (uploader.isUploadDone()) {
        // 파일 한 개의 저장이 끝난 시점
    }
}
response.setHeader("Access-Control-Allow-Origin", "*");
response.setHeader("Access-Control-Allow-Credentials", "true");
response.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
%>

String _action        = uploader.getParameter("_action");
String _orig_filename = uploader.getParameter("_orig_filename");
String _filesize      = uploader.getParameter("_filesize");
String _el            = uploader.getParameter("el");

if ("getFileInfo".equals(_action)) {
    // 사전 검사, 저장 경로, 파일명 결정
}

String result = uploader.run();

String _action        = uploader.getParameter("_action");
String _orig_filename = uploader.getParameter("_orig_filename");
String userId         = (String) session.getAttribute("userId");   // 서버 세션 값 사용

if ("getFileInfo".equals(_action) && _orig_filename != null) {
    String sub = new java.text.SimpleDateFormat("yyyyMMdd").format(new java.util.Date());
    uploader.setDirectory(directory + "/" + userId + "/" + sub);

    String ext = _orig_filename.contains(".")
        ? _orig_filename.substring(_orig_filename.lastIndexOf(".")) : "";
    uploader.setFileName(java.util.UUID.randomUUID().toString() + ext);
}
String result = uploader.run();

String _run_retval = uploader.run();

if (uploader.isUploadDone()) {
    String orig  = uploader.getParameter("_orig_filename");
    String saved = uploader.getParameter("_new_filename");
    String size  = uploader.getParameter("_filesize");
    String board = uploader.getParameter("boardId");   // setPostData로 보낸 값

    // INSERT INTO attach(board_id, orig_name, saved_name, size) ...
}

box.on('uploadComplete', function (p) {
  // p.files: 이번 전송에서 올라간 파일 전체
  $.post('/board/attach/commit', { files: JSON.stringify(p.files) });
});

화면 → setPostData / setFilePostDataByIndex / setCustomHeader → 서버 getParameter / getHeader
서버 → setCustomValue + sendCustomValue → 화면 uploadComplete의 customValue

function upload() {
  box.setPostData({ boardId: '1024' });

  var files = box.getAllFiles();
  for (var i = 0; i < files.length; i++) {
    box.setFilePostDataByIndex(i, { customValue: files[i].fileSize });
  }

  box.setCustomHeader({ value: 'test' });   // 인증 토큰 등
  box.upload();
}

String boardId     = uploader.getParameter("boardId");
String customValue = uploader.getParameter("customValue");   // 값이 없으면 null
String headerValue = request.getHeader("value");

String _run_retval = uploader.run();

if (uploader.isUploadDone()) {
    uploader.setCustomValue("attachId", String.valueOf(newAttachId));
    uploader.sendCustomValue();
}

box.on('uploadComplete', function (p) {
  p.files.forEach(function (f) {
    console.log(f.customValue.attachId);
  });
});

오류 발생 (uploadError)
   ├ 복구 불가 → 일시 정지 (uploadPause) → 사용자가 재개
   └ 복구 가능 → 자동 재시도 (uploadRetry) → 이어올리기
서버 거부 → InnorixCustomError → 전송창에 사유 표시

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  retryCount: 3,
  autoRecovery: true,
  maxErrorCount: 10,
  skipErrorFile: true
});

box.on('uploadRetry', function (p) { console.log('재시도', p.retries); });
box.on('uploadError', function (p) { console.log(p.statusMessage); });

InnorixCustomError err = new InnorixCustomError(response);
err.set("1006", "PathTooLong", "경로가 너무 깁니다.", false);
err.run();
return;

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  installURL: '../install/install.html',
  uploadDuplicate: true,        // 이어올리기
  attachIncompleteFiles: true,  // 로드 시 이전 전송 조회
  autoLoadTransfer: false       // false이면 사용자에게 확인
});

box.on('uploadError', function (p) {
  setTimeout(function () { box.closeTransferWindow(); }, 3000);
});

서버 목록 API → 파일 목록 JSON → presetDownloadFiles() → 컨트롤 목록 → 다운로드 실행

box.on('loadComplete', function () {
  $.getJSON('/board/1024/attachments', function (rows) {
    var list = rows.map(function (r) {
      return {
        printFileName: r.originalName,
        fileSize: r.size,   // 바이트 단위 숫자
        downloadUrl: '/download.jsp?fileID=' + encodeURIComponent(r.id)
      };
    });
    box.presetDownloadFiles(list);
  });
});

box.presetDownloadFiles([{
  printFileName: '계약서 최종.pdf',
  fileSize: 4952305,
  downloadUrl: 'download.jsp?fileID=2&name=' + encodeURIComponent('계약서 최종.pdf')
}]);

box = innorix.create({
  el: '#fileBox',
  addFolder: true,   // rootName을 하위 폴더로 저장
  boxConfig: box_config.download_agent
});

box.on('loadComplete', function () {
  box.presetDownloadFiles([
    { rootName: 'FolderA',         printFileName: 'Exabyter and Exchanger.png',
      fileSize: 281624,  downloadUrl: 'download.jsp?fileID=1' },
    { rootName: 'FolderA/FolderB', printFileName: 'Exabyter Brochure.pdf',
      fileSize: 4952305, downloadUrl: 'download.jsp?fileID=2' },
    // 빈 폴더
    { downloadUrl: 'test', printFileName: 'empty', fileSize: 0, isFile: false, isFolder: true }
  ]);
});

컨트롤 → downloadUrl 요청 → 서버(권한 검사 → 파일 조회 → 구간 응답) → Agent 저장

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*" %>
<%
String szStart = request.getParameter("_StartOffset");
String szEnd   = request.getParameter("_EndOffset");
String fileID  = request.getParameter("fileID");

// fileID로 파일을 조회하고, 이 지점에서 권한을 검사합니다.
File file = lookupFile(fileID);
String orgFileName = lookupName(fileID);
orgFileName = java.net.URLEncoder.encode(orgFileName, "UTF-8").replaceAll("\\+", "%20");

response.setContentType("application/octet-stream");
response.setHeader("Accept-Ranges", "bytes");
response.setHeader("Content-Disposition", "attachment; filename=\"" + orgFileName + "\"");

long start = (szStart != null) ? Long.parseLong(szStart) : 0;
long end   = (szEnd   != null) ? Long.parseLong(szEnd)   : 0;
long length = (szStart != null || szEnd != null)
        ? end - start + 1      // 컨트롤 요청: 지정 구간
        : file.length();       // 브라우저 직접 요청: 전체
response.setHeader("Content-Length", String.valueOf(length));

InputStream in = null;
OutputStream outStream = null;
try {
    in = new BufferedInputStream(new FileInputStream(file));
    outStream = new BufferedOutputStream(response.getOutputStream());
    if (start > 0) in.skip(start);

    byte[] buf = new byte[8192];
    while (length > 0) {
        int read = in.read(buf, 0, (int) Math.min(buf.length, length));
        if (read == -1) break;
        outStream.write(buf, 0, read);
        length -= read;
    }
} finally {
    if (outStream != null) { outStream.flush(); outStream.close(); }
    if (in != null) in.close();
}
%>

<%@ page import="com.innorix.transfer.InnorixDownload" %>
<%
InnorixDownload d = new InnorixDownload(request, response, "UTF-8", directory);   // directory는 / 로 끝남
d.setFileName(sysFileName);        // 서버의 저장 파일명
d.setPrintFileName(orgFileName);   // Content-Disposition 파일명
d.run();
%>

목록 구성 → downloadBefore(차단 가능) → 전송 시작 → 진행 → 완료

box.on('loadComplete', function () {
  box.presetDownloadFiles(filesFromServer);
  box.download();
});

box.on('downloadBefore', function () {
  return window.confirm('다운로드를 시작할까요?');
});

저장 경로 결정 → 동일 파일명 확인 → 폴더 구조 반영 → 파일 저장

box = innorix.create({
  el: '#fileBox',
  savePath: 'C:\\Downloads\\exabyter',   // 백슬래시를 두 번 씀
  downloadDuplicate: 'numbering',
  boxConfig: box_config.download_agent
});

function downloadToChosenFolder() {
  box.setDownloadPath(function (response) {
    if (response.result == true) {
      box.download();
    }
  });
}

오류 발생 → downloadError → (autoRecovery 켜짐) 잠시 후 이어받기 → downloadRetry
                         → (autoRecovery 꺼짐) 일시중지 → 사용자 재개

box.on('downloadError',  function (p) { console.log(p.statusMessage); });
box.on('downloadRetry',  function (p) { console.log('retry', p.retries); });
box.on('downloadPause',  function (p) { console.log('paused'); });
box.on('downloadCancel', function (p) { console.log('canceled'); });

<%@ page import="com.innorix.transfer.InnorixCustomError" %>
<%
InnorixCustomError customError = new InnorixCustomError(response);
customError.set("1600", "customErrorTitle", "customErrorMessage", false);
customError.run();
return;
%>

전송 완료 → downloadComplete 이벤트(페이지) + 완료 알림 URL 호출(서버) → 후속 처리

box = innorix.create({
  el: '#fileBox',
  downloadCompletedEvent: { use: true, url: '/innorix/download-complete.jsp' },
  boxConfig: box_config.download_agent
});

box.on('downloadComplete', function (p) {
  console.log(p.files);
});

<%
String action = request.getParameter("_Action");
if ("DownloadComplete".equals(action)) {
    // 이력 기록
    response.setStatus(200);
    return;
}
%>

create(el) → loadComplete → 파일 추가, 전송, 이벤트 수신 → destroy()
   └ 컨트롤 A (업로드)   ─┐
   └ 컨트롤 B (업로드)   ─┼→ 화면 하나, 목록, 이벤트는 컨트롤마다 독립
   └ 컨트롤 C (다운로드) ─┘

<div id="fileBox1"></div>
<div id="fileBox2"></div>

<script>
  var box1, box2;
  window.onload = function () {
    box1 = innorix.create({ el: '#fileBox1', uploadURL: './upload.jsp', allowType: ['pdf', 'mp4'] });
    box2 = innorix.create({ el: '#fileBox2', uploadURL: './upload.jsp', allowType: ['jpg'] });

    box1.on('afterAddFiles', function () { box1.setPostData({ slot: 'doc' });   box1.upload(); });
    box2.on('afterAddFiles', function () { box2.setPostData({ slot: 'photo' }); box2.upload(); });
  };
</script>

String slot = uploader.getParameter("slot");

function upload() {
  box3.addFiles(box1.getAllFiles());
  box3.addFiles(box2.getAllFiles());
  box3.upload();
}

var all = innorix.group(box1, box2);
all.removeAllFiles();            // 두 컨트롤의 목록을 모두 비움
var counts = all.getFileCount(); // [box1의 개수, box2의 개수]

var box = null;

function openUploader() {
  box = innorix.create({
    el: '#fileBox',
    uploadURL: '/innorix/upload.jsp',
    boxWidth: 600,
    boxHeight: 300,
    boxConfig: box_config.upload_basic
  });
  box.on('uploadComplete', function (p) { console.log(p.files); });
}

function closeUploader() {
  if (box) {
    box.destroy();
    box = null;
  }
}

<div id="dropZone" style="width:500px; height:200px; border:1px dashed #999;">
  여기에 파일을 끌어놓으세요
</div>
<div id="fileControl" style="display:none"></div>

<script>
  var innoJquery = innorix._load('innoJquery');
  var control;

  innoJquery(document).ready(function () {
    control = innorix.create({ el: '#fileControl', uploadURL: './upload.jsp' });

    innoJquery('#dropZone').on({
      dragenter: function (evt) {
        control.setDropZone(evt, this);   // 이 요소를 드롭 영역으로 지정
      }
    });
  });
</script>

box = innorix.create({
  el: '#fileBox',
  uploadURL: '/innorix/upload.jsp',
  hostTransferWindow: true,
  hostTransferWindowTarget: 'top',
  hostTransferWindowCssURL: '<link rel="stylesheet" href="/css/innorix.css">',
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  useContextMenu: false   // 컨텍스트 메뉴 비활성
});

function onDelKey(e) {
  if (e.key === 'Delete' && box.getSelectedFileCount() > 0) {
    box.removeSelectedFiles();
  }
}
document.addEventListener('keydown', onDelKey);       // Del 키 삭제 활성
// document.removeEventListener('keydown', onDelKey); // 비활성

box.on('loadComplete', function () { console.log('컨트롤 준비 완료'); });
box.on('onSelectRows',   function (p) { console.log('선택', p); });
box.on('onUnSelectRows', function (p) { console.log('해제', p); });
box.on('removeFiles',    function (p) { console.log('삭제됨', p); });

function syncButtons() {
  document.getElementById('delBtn').disabled = box.getSelectedFileCount() === 0;
}
box.on('onSelectRows', syncButtons);
box.on('onUnSelectRows', syncButtons);
box.on('removeFiles', syncButtons);

컨트롤 생성 → 리스트(boxStyle, 크기, 폴더) → 전송 시작 → 전송창(transferWindowStyle)
                                                       └→ (또는) 숨김 + 이벤트 → 자체 진행 화면

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  transferWindowStyle: 'default',        // 기본 전송창
  transferWindowTitle: '첨부파일 업로드',
  transferStart: { upload: 'manual' },   // 시작 버튼으로 시작
  cancelConfirmation: true,              // 닫을 때 취소 확인
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  hostTransferWindow: true,            // 전송창을 호스트 페이지에 출력
  hostTransferWindowTarget: 'top',     // 'top' 최상위 호스트, 'parent' 직전 상위 호스트
  draggableTransferWindow: true,       // 제목 줄을 끌어 이동
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  transferWindowStyle: 'mini',   // 레이어로 출력하는 작은 전송창
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  transferWindowStyle: 'list',   // 레이어로 출력, 진행도 위에 파일 목록 표시
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  transferWindowStyle: 'compact',   // 레이어 없이 리스트 하단에 표시
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  showTransferWindow: false,   // 기본 전송창을 열지 않음
  boxConfig: box_config.upload_basic
});

box.on('uploadProgress', function (s) {
  document.getElementById('pg').value = s.progress;
  document.getElementById('st').innerText = s.state;
  document.getElementById('sp').innerText = Math.round(s.speed / 1024);
});

box.on('uploadComplete', function (p) {
  console.log(p.files);
});

<div id="transferPanel" style="border:1px solid #c0c0c0; padding:8px; width:400px;">
  <div>상태: <span id="st">대기</span> / 속도: <span id="sp">0</span> KB/s</div>
  <progress id="pg" value="0" max="100" style="width:100%"></progress>
  <input type="button" value="일시정지" onclick="box.transferPause();"/>
  <input type="button" value="재개" onclick="box.transferResume();"/>
  <input type="button" value="취소" onclick="box.transferCancel();"/>
</div>

box = innorix.create({
  el: '#fileBox',
  boxStyle: 'list',
  boxWidth: 980,
  boxHeight: 465,
  uploadURL: './upload.jsp',
  folderAttach: true,           // 폴더 첨부 허용
  showFolderItems: true,        // 폴더 안의 항목을 표시
  maxMassFileListCount: 500,    // 500개까지만 행으로 표시
  boxConfig: box_config.upload_basic
});

// 생성 후 크기 변경
box.setSize(700, 300);

box = innorix.create({
  el: '#fileBox',
  boxStyle: 'icon',
  boxWidth: 550,
  boxHeight: 200,
  uploadURL: './upload.jsp',
  boxConfig: box_config.upload_basic
});

<div id="previewBox"></div>
<div id="fileBox"></div>

<script>
  box = innorix.create({
    el: '#fileBox',
    uploadURL: './upload.jsp',
    boxStyle: 'preview',
    setPreviewDiv: ['previewBox', 240, 180]   // [요소 ID, 너비, 높이]
  });
</script>

<div id="dropZone" style="overflow:auto; width:500px; height:200px; border:1px solid #c0c0c0;">
  <table id="fileTable">
    <thead>
      <tr><th>파일명</th><th>용량</th><th>구분</th><th>삭제</th></tr>
    </thead>
    <tbody></tbody>
  </table>
</div>
<div id="fileControl" style="display:none"></div>

<input type="button" value="파일추가" onclick="control.openFileDialog();">
<input type="button" value="업로드" onclick="control.upload();">

<script src="../innorix.js"></script>
<script>
  var innoJquery = innorix._load('innoJquery');
  var control;

  innoJquery(document).ready(function () {
    control = innorix.create({
      el: '#fileControl',
      boxStyle: 'html',
      uploadURL: './upload.jsp'
    });

    // 파일 추가 후 표에 행을 만든다
    control.on('afterAddFiles', function (p) {
      for (var i = 0; i < p.length; i++) {
        var name = p[i].filePath.replace(/\\/g, '/').split('/').pop();
        innoJquery('#fileTable > tbody').append(
          '<tr><td>' + name + '</td><td>' + p[i].fileSize + '</td><td>일반</td>' +
          '<td><input type="button" value="삭제" onclick="deleteRow(this, \'' + p[i].id + '\')"></td></tr>');
      }
    });
  });

  // 표 행과 컨트롤의 파일을 함께 삭제한다
  function deleteRow(btn, id) {
    var row = btn.parentNode.parentNode;
    row.parentNode.removeChild(row);
    control.removeFileById(id);
  }
</script>

이미지 첨부 → appendThumbnailProperty / appendWatermarkProperty → upload()
            → 원본 + 썸네일 파일이 각각 서버에 저장

box.appendThumbnailProperty('ALL', 300, 200, 'HORIZONTAL');
box.upload();

if (uploader.isUploadDone()) {
    String saved = uploader.getParameter("_new_filename");
    boolean isThumb = saved != null && saved.contains("_thumb_");
}

var r = box.appendWatermarkProperty('ALL', './logo.png', 'LEFT|BOTTOM');
if (r === 'not_supported') alert('워터마크 이미지 형식을 확인하세요.');
box.upload();

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload-crypt.jsp',
  installURL: '../install/install.html',
  limitRate: 2000,
  useCompress: true,
  useEncrypt: true,
  useEncryptMeta: true
});

InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, "UTF-8",
        directory, true, ENCRYPT_KEY, ENCRYPT_IV);   // 32자 키, 16자 IV
uploader.setAutoDecompress(true, true);              // 압축 해제 후 원본 삭제
String result = uploader.run();

[마운트, NAS]  컨트롤 → upload 엔드포인트 → 마운트 경로(저장 디렉터리)

[S3]          컨트롤 → 서버 엔드포인트(사전 서명 URL 발급) → S3 직접 전송

<%@ page import="com.innorix.transfer.InnorixUpload" %>
<%
if (request.getMethod().equals("POST")) {
    String directory = "/usr/local/mount/upload";   // 마운트 경로
    int maxPostSize = 2147482624; // bytes

    InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, directory);
    String result = uploader.run();
}
%>

box = innorix.create({
  el: '#fileBox',
  transferMode: 'both',
  downloadType: 'direct',
  isPresignedUrl: true,
  uploadURL: './s3_upload.jsp',
  installURL: '../install/install.html'
});

<%@ page import="com.innorix.transfer.InnorixS3Upload" %>
<%
if (request.getMethod().equals("POST")) {
    String S3_URI = "https://s3.amazonaws.com";
    String S3_REGION = "ap-northeast-2";
    String S3_ACCESS_KEY_ID = System.getenv("S3_ACCESS_KEY_ID");
    String S3_SECRET_KEY = System.getenv("S3_SECRET_KEY");
    String S3_BUCKET = "my-bucket";
    String directory = "upload";
    int maxPostSize = 2147482624; // bytes

    InnorixS3Upload uploader = new InnorixS3Upload(request, response, maxPostSize, "UTF-8",
        S3_URI, S3_REGION, S3_BUCKET, S3_ACCESS_KEY_ID, S3_SECRET_KEY, directory);
    uploader.setExpirationTimeSecond(60 * 60);   // URL 유효 시간(초)

    String result = uploader.run();
}
%>

box.on('loadComplete', function () {
  box.presetDownloadFiles([{
    printFileName: 'test4.zip',
    fileSize: 2147484672,
    downloadUrl: './s3_download.jsp?_filePath=' + encodeURIComponent('test4.zip')
  }]);
});

<%@ page import="com.innorix.transfer.AwsS3" %>
<%
String filePath = "upload/";
String name = java.net.URLDecoder.decode(request.getParameter("_filePath"));

AwsS3 awsS3 = new AwsS3();
awsS3.GetAmazonS3("https://s3.amazonaws.com", "ap-northeast-2",
    System.getenv("S3_ACCESS_KEY_ID"), System.getenv("S3_SECRET_KEY"));

String downloadUrl = awsS3.GetDownloadUrl("my-bucket", filePath + name, 60 * 60);
response.getWriter().write(downloadUrl);
%>

// 이어올리기 정보를 DB 등 공유 저장소에 기록 (UploadInfoCallBack 구현체)
InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, directory, new MyUploadInfoCallBack());

// S3 호환 스토리지에 저장 (접근 키는 환경 변수 등에서 읽어 사용)
InnorixS3Upload s3Uploader = new InnorixS3Upload(
    request, response, maxPostSize, "UTF-8",
    S3_URI, S3_REGION, S3_BUCKET, S3_ACCESS_KEY_ID, S3_SECRET_KEY, directory);
s3Uploader.setExpirationTimeSecond(60 * 60);
String result = s3Uploader.run();

box = innorix.create({
  el: '#filebox',
  uploadURL: './s3_upload.jsp',
  isPresignedUrl: true
});

사용자 → [HTTPS] → 컨트롤(쿠키, 토큰 전달) → 서버(인증, 권한, 형식 검사) → 저장소

<%@ page contentType="application/octet-stream" trimDirectiveWhitespaces="true" %>
<%@ page import="java.io.*, java.net.URLEncoder" %>
<%
// 1. 로그인 확인
Long userId = (Long) session.getAttribute("userId");
if (userId == null) { response.sendError(401); return; }

// 2. 파일 ID로 조회하고 소유권 확인 (없거나 권한 없으면 null)
DownloadInfo info = findDownloadable(userId, request.getParameter("fileID"));
if (info == null) { response.sendError(404); return; }

File file = info.storedFile;   // 서버가 정한 경로
long size = file.length();

// 3. 범위 검증
long start = 0, end = size - 1;
try {
    String szStart = request.getParameter("_StartOffset");
    String szEnd   = request.getParameter("_EndOffset");
    if (szStart != null) start = Long.parseLong(szStart);
    if (szEnd   != null) end   = Long.parseLong(szEnd);
} catch (NumberFormatException e) { response.sendError(400); return; }

if (start < 0 || end < start || end >= size) {
    response.setHeader("Content-Range", "bytes */" + size);
    response.sendError(416);
    return;
}
long length = end - start + 1;

// 4. 헤더
String encoded = URLEncoder.encode(info.printName, "UTF-8").replaceAll("\\+", "%20");
response.setHeader("Accept-Ranges", "bytes");
response.setHeader("Content-Disposition", "attachment; filename=\"" + encoded + "\"");
response.setHeader("Content-Length", String.valueOf(length));
response.setHeader("Cache-Control", "private, no-store");

// 5. 해당 구간만 출력
RandomAccessFile raf = new RandomAccessFile(file, "r");
try {
    raf.seek(start);
    OutputStream os = response.getOutputStream();
    byte[] buf = new byte[8192];
    long remain = length;
    while (remain > 0) {
        int n = raf.read(buf, 0, (int) Math.min(buf.length, remain));
        if (n == -1) break;
        os.write(buf, 0, n);
        remain -= n;
    }
    os.flush();
} finally {
    raf.close();
}
%>

<script>
  box.on('loadComplete', function () {
    box.setCookie('JSESSIONID=<%= session.getId() %>');
  });
</script>

var keepAliveTimer = null;

function startKeepAlive() {
  stopKeepAlive();
  keepAliveTimer = setInterval(function () {
    fetch('/session/ping', { credentials: 'same-origin', cache: 'no-store' });
  }, 5 * 60 * 1000);
}
function stopKeepAlive() {
  if (keepAliveTimer) { clearInterval(keepAliveTimer); keepAliveTimer = null; }
}

box.on('uploadStart',    startKeepAlive);
box.on('uploadComplete', stopKeepAlive);
box.on('uploadError',    stopKeepAlive);
box.on('uploadCancel',   stopKeepAlive);

<meta name="_csrf"        content="${_csrf.token}">
<meta name="_csrf_header" content="${_csrf.headerName}">

box = innorix.create({
  el: '#fileBox',
  uploadURL: '/innorix/upload.jsp',
  customHeader: { 'X-Auth-Token': authToken },
  postData: { boardId: '1024' },
  useCsrf: true,
  boxConfig: box_config.upload_basic
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  allowType: ['jpg', 'png', 'pdf'],
  useSignature: true,
  boxConfig: box_config.upload_basic
});

box.on('addFileError', function (p) {
  if (p.type == 'allowType') {
    alert('허용되지 않는 형식입니다.');
  }
});

<%@ page import="com.innorix.transfer.InnorixUpload" %>
<%!
static final java.util.Set<String> ALLOW =
    new java.util.HashSet<String>(java.util.Arrays.asList("jpg", "png", "pdf"));

static String ext(String name) {
    if (name == null) return "";
    int dot = name.lastIndexOf('.');
    return dot < 0 ? "" : name.substring(dot + 1).toLowerCase();
}
%>
<%
if (request.getMethod().equals("POST")) {
    String directory = "/data/upload";   // 웹 루트 밖의 경로
    int maxPostSize = 2147482624; // bytes

    InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, directory);
    String action = uploader.getParameter("_action");
    String orig   = uploader.getParameter("_orig_filename");

    if ("getFileInfo".equals(action)) {
        if (!ALLOW.contains(ext(orig))) {
            uploader.showCustomError("1700", "허용되지 않는 형식", ext(orig), false);
            return;
        }
        uploader.setFileName(java.util.UUID.randomUUID() + "." + ext(orig));
    }
    String result = uploader.run();
}
%>

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload-crypt.jsp',
  useEncrypt: true,
  useEncryptMeta: true,
  useSignature: true,
  denyType: ['zip'],
  installURL: '../install/install.html'
});

<%@ page import="com.innorix.transfer.InnorixUpload" %>
<%
if (request.getMethod().equals("POST")) {
    String directory = "/data/upload";
    int maxPostSize = 2147482624; // bytes
    String key = System.getenv("INNORIX_CRYPT_KEY");   // 16, 24, 32자
    String iv  = System.getenv("INNORIX_CRYPT_IV");    // 16자

    InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, "UTF-8",
        directory, true, key, iv);   // true: 메타정보 암호화(useEncryptMeta와 일치)

    uploader.setAutoDecryption(false);      // 복호화하지 않고 암호화된 상태로 저장
    uploader.setHideServerPathInfo(true);   // 응답에서 서버 경로 제외

    String result = uploader.run();
}
%>

업로드 완료 → 서버 훅에서 외부 모듈 호출 → customValue로 결과 응답 → uploadComplete에서 결과 표시

<%
InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, directory);
String result = uploader.run();

if (uploader.isUploadDone()) {
    File saved = new File(directory, uploader.getParameter("_new_filename"));

    ScanResult r = scanner.scan(saved);   // 백신, DRM 등 외부 모듈 호출
    if (!r.clean) {
        saved.delete();
        uploader.setCustomValue("scan", "infected");
    } else {
        uploader.setCustomValue("scan", "clean");
    }
    uploader.sendCustomValue();
}
%>

box.on('uploadComplete', function (p) {
  p.files.forEach(function (f) {
    if (f.customValue.scan == 'infected') {
      alert(f.clientFileName + ': 차단된 파일입니다.');
    }
  });
});

<%@ page import="com.innorix.transfer.InnorixCustomError" %>
<%@ page import="com.innorix.transfer.InnorixCustomValue" %>
<%
String action = request.getParameter("_Action");
String fileID = request.getParameter("fileID");

if ("DownloadStart".equals(action)) {
    if (!canDownload(userId, fileID)) {   // 애플리케이션이 구현
        InnorixCustomError err = new InnorixCustomError(response);
        err.set("1600", "권한 없음", "이 파일을 다운로드할 권한이 없습니다.", false);
        err.run();
        return;
    }
    InnorixCustomValue customValue = new InnorixCustomValue();
    customValue.setCustomValue("fileSize", String.valueOf(releasedSize));   // 해제 후 크기
    customValue.run(response);
    return;
}
if ("DownloadComplete".equals(action)) {
    response.setStatus(200);
    return;
}
%>

if ("getFileInfo".equals(_action)) {
    long need = Long.parseLong(uploader.getParameter("_filesize"));
    long free = new java.io.File(directory).getUsableSpace();

    if (free < need + 1024L * 1024 * 1024) {      // 1GB 여유 확보
        InnorixCustomError err = new InnorixCustomError(response);
        err.set("1700", "NoSpace", "서버 저장 공간이 부족합니다.", false);
        err.run();
        return;
    }
}
String result = uploader.run();

if (uploader.isUploadDone()) {
    // 외부 검사 엔진 호출 (오래 걸리면 별도 큐로 넘김)
    uploader.setCustomValue("scan", "clean");
    uploader.sendCustomValue();
}

웹 페이지(컨트롤) → Agent 설치 확인 → (미설치) 설치 페이지 → Agent ↔ 서버 직접 전송

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  installURL: '../install/install.html',
  boxConfig: box_config.upload_agent
});

box = innorix.create({
  el: '#fileBox',
  boxStyle: 'list',
  skipPluginCheck: true,
  downloadDuplicate: 'numbering',
  installURL: '../install/install.html',
  boxConfig: box_config.download_agent
});

box.on('loadComplete', function () {
  box.presetDownloadFiles([{
    printFileName: '5GB.mp4',
    fileSize: 5393874944,
    downloadUrl: 'download.jsp?fileID=7'
  }]);
});

box = innorix.create({
  el: '#fileBox',
  uploadURL: './upload.jsp',
  installURL: '../install/install.html',
  boxWidth: 980,                          // 프리셋 값을 덮어씀
  boxConfig: box_config.upload_agent
});

<input type="button" value="파일 추가" onclick="box.openFileDialog();"/>
<input type="button" value="폴더 추가" onclick="box.openFolderDialog();"/>
<input type="button" value="업로드" onclick="box.upload();"/>

box.on('loadComplete', function () {
  box.presetDownloadFiles([{
    printFileName: 'Exabyter Brochure.pdf',
    fileSize: 1048576,
    downloadUrl: 'download.jsp?fileID=2'
  }]);
});

box.on('loadComplete', function () {
  console.log('컨트롤 준비 완료');
});

box.on('addFileError', function (p) {
  console.log(p.type);
});

box.on('uploadComplete', function (p) {
  console.log(p.files);
});

box.on('uploadComplete', function (p) {
  var form = document.getElementById('f_write');
  p.files.forEach(function (f) {
    var input = document.createElement('input');
    input.type = 'hidden';
    input.name = 'serverFileName';
    input.value = f.serverFileName;
    form.appendChild(input);
  });
  form.submit();
});

<%@ page import="com.innorix.transfer.InnorixUpload" %>
<%
if (request.getMethod().equals("POST")) {
    String directory = InnorixUpload.getServletAbsolutePath(request);
    directory = directory.substring(0, directory.lastIndexOf("/") + 1) + "data";
    int maxPostSize = 2147482624; // bytes

    InnorixUpload uploader = new InnorixUpload(request, response, maxPostSize, directory);

    String action = uploader.getParameter("_action");
    if ("getFileInfo".equals(action)) {
        uploader.setFileName("new-" + uploader.getParameter("_orig_filename"));   // run() 전에 호출
    }

    String result = uploader.run();

    if (uploader.isUploadDone()) {
        // 파일 1개 저장 완료
    }
}
%>