singularityui-tailer/lib/actions/index.js

A robust log tailer

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.httpFetchChunk = exports.blazarLogFetchTail = exports.BLAZAR_LOG_FETCH_TAIL = exports.blazarLogFetchLength = exports.BLAZAR_LOG_FETCH_LENGTH_ERROR = exports.BLAZAR_LOG_FETCH_LENGTH_STARTED = exports.blazarLogFetchChunk = exports.blazarSetApiRoot = exports.BLAZAR_SET_API_ROOT = exports.BLAZAR_LOG_MAX_BYTES = exports.sandboxFetchTail = exports.SANDBOX_FETCH_TAIL = exports.sandboxFetchLength = exports.SANDBOX_FETCH_LENGTH_ERROR = exports.SANDBOX_FETCH_LENGTH_STARTED = exports.sandboxFetchChunk = exports.setAuthorizationHeader = exports.SET_AUTHORIZATION_HEADER = exports.tailIntervalMs = exports.SET_TAIL_INTERVAL_MS = exports.sandboxSetApiRoot = exports.SANDBOX_SET_API_ROOT = exports.SANDBOX_MAX_BYTES = exports.FETCH_CHUNK_ERROR = exports.FETCH_CHUNK_STARTED = exports.renderedLines = exports.RENDERED_LINES = exports.toggleFetchOverscan = exports.TOGGLE_FETCH_OVERSCAN = exports.toggleAnsiColoring = exports.TOGGLE_ANSI_COLORING = exports.setFileSize = exports.SET_FILE_SIZE = exports.unloadFileChunk = exports.UNLOAD_FILE_CHUNK = exports.startTailing = exports.START_TAILING = exports.stopTailing = exports.STOP_TAILING = exports.unloadFile = exports.UNLOAD_FILE = exports.addFileChunk = exports.ADD_FILE_CHUNK = exports.SINGULARITY_TAILER_AJAX_ERROR_EVENT = undefined;

var _textEncoding = require('text-encoding');

var _isomorphicFetch = require('isomorphic-fetch');

var _isomorphicFetch2 = _interopRequireDefault(_isomorphicFetch);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var frameworkName = 'SINGULARITY_TAILER'; // polyfill
var SINGULARITY_TAILER_AJAX_ERROR_EVENT = exports.SINGULARITY_TAILER_AJAX_ERROR_EVENT = 'SingularityTailerAjaxError';

/* GENERIC CHUNK ACTIONS */
var TE = new _textEncoding.TextEncoder();

var ADD_FILE_CHUNK = exports.ADD_FILE_CHUNK = frameworkName + '_ADD_FILE_CHUNK';
// the returned chunk may have a different start and end point than we requested
// but we still want to know what we originally requested so we can mark that
// request done
var addFileChunk = exports.addFileChunk = function addFileChunk(id, chunk, requestedStart, requestedEnd) {
  return {
    type: ADD_FILE_CHUNK,
    id: id,
    chunk: chunk,
    requestedStart: requestedStart,
    requestedEnd: requestedEnd
  };
};

var UNLOAD_FILE = exports.UNLOAD_FILE = frameworkName + '_UNLOAD_FILE';
var unloadFile = exports.unloadFile = function unloadFile(id) {
  return {
    type: UNLOAD_FILE,
    id: id
  };
};

var STOP_TAILING = exports.STOP_TAILING = frameworkName + '_STOP_TAILING';
var stopTailing = exports.stopTailing = function stopTailing(id) {
  return {
    type: STOP_TAILING,
    id: id
  };
};

var START_TAILING = exports.START_TAILING = frameworkName + '_START_TAILING';
var startTailing = exports.startTailing = function startTailing(id) {
  return {
    type: START_TAILING,
    id: id
  };
};

var UNLOAD_FILE_CHUNK = exports.UNLOAD_FILE_CHUNK = frameworkName + '_UNLOAD_FILE_CHUNK';
var unloadFileChunk = exports.unloadFileChunk = function unloadFileChunk(id, index) {
  return {
    type: UNLOAD_FILE_CHUNK,
    id: id,
    index: index
  };
};

var SET_FILE_SIZE = exports.SET_FILE_SIZE = frameworkName + '_SET_FILE_SIZE';
var setFileSize = exports.setFileSize = function setFileSize(id, fileSize) {
  return {
    type: SET_FILE_SIZE,
    id: id,
    fileSize: fileSize
  };
};

/* GENERAL ACTIONS */
var TOGGLE_ANSI_COLORING = exports.TOGGLE_ANSI_COLORING = frameworkName + '_TOGGLE_ANSI_COLORING';
var toggleAnsiColoring = exports.toggleAnsiColoring = function toggleAnsiColoring() {
  return {
    type: TOGGLE_ANSI_COLORING
  };
};

var TOGGLE_FETCH_OVERSCAN = exports.TOGGLE_FETCH_OVERSCAN = frameworkName + '_TOGGLE_FETCH_OVERSCAN';
var toggleFetchOverscan = exports.toggleFetchOverscan = function toggleFetchOverscan() {
  return {
    type: TOGGLE_FETCH_OVERSCAN
  };
};

// Infinite loader actions
var RENDERED_LINES = exports.RENDERED_LINES = frameworkName + '_RENDERED_LINES';
var renderedLines = exports.renderedLines = function renderedLines(id, startIndex, stopIndex, overscanStartIndex, overscanStopIndex) {
  return {
    type: RENDERED_LINES,
    id: id,
    startIndex: startIndex,
    stopIndex: stopIndex,
    overscanStartIndex: overscanStartIndex,
    overscanStopIndex: overscanStopIndex
  };
};

// API independent chunk fetching actions
var FETCH_CHUNK = frameworkName + '_FETCH_CHUNK';

var FETCH_CHUNK_STARTED = exports.FETCH_CHUNK_STARTED = FETCH_CHUNK + '_STARTED';
var fetchChunkStarted = function fetchChunkStarted(apiName, id, start, end) {
  return {
    type: FETCH_CHUNK_STARTED,
    apiName: apiName,
    startedAt: Date.now(),
    id: id,
    start: start,
    end: end
  };
};

var FETCH_CHUNK_ERROR = exports.FETCH_CHUNK_ERROR = FETCH_CHUNK + '_ERROR';
var fetchChunkError = function fetchChunkError(apiName, id, start, end, error) {
  return {
    type: FETCH_CHUNK_ERROR,
    apiName: apiName,
    id: id,
    start: start,
    end: end,
    name: error.name,
    message: error.message
  };
};

/* GENERAL API HELPERS */
var checkStatus = function checkStatus(response, taskId) {
  if (response.status >= 200 && response.status < 300) {
    return response;
  }
  var error = new Error(response.statusText);
  error.response = response;
  if (document && document.dispatchEvent) {
    document.dispatchEvent(new CustomEvent(SINGULARITY_TAILER_AJAX_ERROR_EVENT, { 'detail': { 'response': response, 'taskId': taskId } }));
  }
  throw error;
};

var parseJSON = function parseJSON(response) {
  return response.json();
};

var parseText = function parseText(response) {
  return response.text();
};

/* SINGULARITY SANDBOX API */
var SANDBOX_MAX_BYTES = exports.SANDBOX_MAX_BYTES = 65535;

// must be used before calling a fetch
// this sets the Singularity API root
var SANDBOX_SET_API_ROOT = exports.SANDBOX_SET_API_ROOT = frameworkName + '_SANDBOX_SET_API_ROOT';
var sandboxSetApiRoot = exports.sandboxSetApiRoot = function sandboxSetApiRoot(apiRoot) {
  return {
    type: SANDBOX_SET_API_ROOT,
    apiRoot: apiRoot
  };
};

var SET_TAIL_INTERVAL_MS = exports.SET_TAIL_INTERVAL_MS = frameworkName + '_TAIL_INTERVAL_MS';
var tailIntervalMs = exports.tailIntervalMs = function tailIntervalMs(_tailIntervalMs) {
  return {
    type: SET_TAIL_INTERVAL_MS,
    tailIntervalMs: _tailIntervalMs
  };
};

var SET_AUTHORIZATION_HEADER = exports.SET_AUTHORIZATION_HEADER = frameworkName + '_SET_AUTHORIZATION_HEADER';
var setAuthorizationHeader = exports.setAuthorizationHeader = function setAuthorizationHeader(authorizationHeader) {
  return {
    type: SET_AUTHORIZATION_HEADER,
    authorizationHeader: authorizationHeader
  };
};

var sandboxFetchChunk = exports.sandboxFetchChunk = function sandboxFetchChunk(id, taskId, path, start, end, config) {
  return function (dispatch) {
    dispatch(fetchChunkStarted('SANDBOX', id, start, end));

    var apiRoot = config.singularityApiRoot;
    var query = '?path=' + path + '&offset=' + start + '&length=' + (end - start);
    var apiPath = apiRoot + '/sandbox/' + taskId + '/read' + query;

    var options = { credentials: 'include' };
    if (config.authorizationHeader) {
      options['headers'] = { 'Authorization': config.authorizationHeader };
    }

    return (0, _isomorphicFetch2.default)(apiPath, options).then(function (r) {
      return checkStatus(r, taskId);
    }).then(parseJSON).then(function (_ref) {
      var data = _ref.data,
          offset = _ref.offset;

      // the API lies, so let's just figure out the bytelength ourselves
      // this code can't take lies.
      var encodedData = TE.encode(data);
      var byteLength = encodedData.byteLength;
      return dispatch(addFileChunk(id, {
        text: data,
        start: offset,
        end: offset + byteLength,
        byteLength: byteLength
      }, start, end));
    }).catch(function (error) {
      return dispatch(fetchChunkError('SANDBOX', id, start, end, error));
    });
  };
};

var SANDBOX_FETCH_LENGTH = frameworkName + '_SANDBOX_FETCH_LENGTH';

var SANDBOX_FETCH_LENGTH_STARTED = exports.SANDBOX_FETCH_LENGTH_STARTED = SANDBOX_FETCH_LENGTH + '_STARTED';
var SANDBOX_FETCH_LENGTH_ERROR = exports.SANDBOX_FETCH_LENGTH_ERROR = SANDBOX_FETCH_LENGTH + '_ERROR';

var sandboxFetchLength = exports.sandboxFetchLength = function sandboxFetchLength(id, taskId, path, config) {
  return function (dispatch) {
    dispatch({
      type: SANDBOX_FETCH_LENGTH_STARTED,
      startedAt: Date.now(),
      id: id
    });

    var apiRoot = config.singularityApiRoot;
    var query = '?path=' + path + '&length=' + 0;
    var apiPath = apiRoot + '/sandbox/' + taskId + '/read' + query;

    var options = { credentials: 'include' };
    if (config.authorizationHeader) {
      options['headers'] = { 'Authorization': config.authorizationHeader };
    }

    return (0, _isomorphicFetch2.default)(apiPath, options).then(function (r) {
      return checkStatus(r, taskId);
    }).then(parseJSON).then(function (_ref2) {
      var offset = _ref2.offset;

      return dispatch(setFileSize(id, offset));
    }).catch(function (error) {
      return dispatch({
        type: SANDBOX_FETCH_LENGTH_ERROR,
        name: error.name,
        message: error.message
      });
    });
  };
};

var SANDBOX_FETCH_TAIL = exports.SANDBOX_FETCH_TAIL = frameworkName + '_SANDBOX_FETCH_TAIL';
var sandboxFetchTail = exports.sandboxFetchTail = function sandboxFetchTail(id, taskId, path, config) {
  return function (dispatch) {
    dispatch(sandboxFetchLength(id, taskId, path, config)).then(function (lengthAction) {
      var start = Math.max(lengthAction.fileSize - SANDBOX_MAX_BYTES, 0);
      var end = start + SANDBOX_MAX_BYTES;

      return dispatch(sandboxFetchChunk(id, taskId, path, start, end, config));
    });
  };
};

/* BLAZAR LOG API */
var BLAZAR_LOG_MAX_BYTES = exports.BLAZAR_LOG_MAX_BYTES = 65535;

// must be used before calling a fetch
// this sets the Blazar API root
var BLAZAR_SET_API_ROOT = exports.BLAZAR_SET_API_ROOT = frameworkName + '_BLAZAR_SET_API_ROOT';
var blazarSetApiRoot = exports.blazarSetApiRoot = function blazarSetApiRoot(apiRoot) {
  return {
    type: BLAZAR_SET_API_ROOT,
    apiRoot: apiRoot
  };
};

var blazarLogFetchChunk = exports.blazarLogFetchChunk = function blazarLogFetchChunk(id, buildId, start, end, config) {
  return function (dispatch) {
    if (start === end) {
      console.log('skipping', start, end);
      return Promise.resolve();
    }

    dispatch(fetchChunkStarted('BLAZAR_LOG', id, start, end));

    var apiRoot = config.blazarApiRoot;
    var query = '?offset=' + start + '&length=' + (end - start);
    var apiPath = apiRoot + '/modules/builds/' + buildId + '/log' + query;

    var options = { credentials: 'include' };
    if (config.authorizationHeader) {
      options['headers'] = { 'Authorization': config.authorizationHeader };
    }

    return (0, _isomorphicFetch2.default)(apiPath, options).then(checkStatus).then(parseJSON).then(function (_ref3) {
      var data = _ref3.data,
          offset = _ref3.offset;

      // the API lies, so let's just figure out the bytelength ourselves
      // this code can't take lies.
      var encodedData = TE.encode(data);
      var byteLength = encodedData.byteLength;
      return dispatch(addFileChunk(id, {
        text: data,
        start: offset,
        end: offset + byteLength,
        byteLength: byteLength
      }, start, end));
    }).catch(function (error) {
      return dispatch(fetchChunkError('BLAZAR_LOG', id, start, end, error));
    });
  };
};

var BLAZAR_LOG_FETCH_LENGTH = frameworkName + '_BLAZAR_LOG_FETCH_LENGTH';

var BLAZAR_LOG_FETCH_LENGTH_STARTED = exports.BLAZAR_LOG_FETCH_LENGTH_STARTED = BLAZAR_LOG_FETCH_LENGTH + '_STARTED';
var BLAZAR_LOG_FETCH_LENGTH_ERROR = exports.BLAZAR_LOG_FETCH_LENGTH_ERROR = BLAZAR_LOG_FETCH_LENGTH + '_ERROR';

var blazarLogFetchLength = exports.blazarLogFetchLength = function blazarLogFetchLength(id, buildId, config) {
  return function (dispatch) {
    dispatch({
      type: BLAZAR_LOG_FETCH_LENGTH_STARTED,
      startedAt: Date.now(),
      id: id
    });

    var apiRoot = config.blazarApiRoot;
    var apiPath = apiRoot + '/modules/builds/' + buildId + '/log/size';

    var options = { credentials: 'include' };
    if (config.authorizationHeader) {
      options['headers'] = { 'Authorization': config.authorizationHeader };
    }

    return (0, _isomorphicFetch2.default)(apiPath, options).then(checkStatus).then(parseJSON).then(function (_ref4) {
      var size = _ref4.size;

      return dispatch(setFileSize(id, size));
    }).catch(function (error) {
      return dispatch({
        type: BLAZAR_LOG_FETCH_LENGTH_ERROR,
        name: error.name,
        message: error.message
      });
    });
  };
};

var BLAZAR_LOG_FETCH_TAIL = exports.BLAZAR_LOG_FETCH_TAIL = frameworkName + '_BLAZAR_LOG_FETCH_TAIL';
var blazarLogFetchTail = exports.blazarLogFetchTail = function blazarLogFetchTail(id, buildId, config) {
  return function (dispatch) {
    dispatch(blazarLogFetchLength(id, buildId, config)).then(function (lengthAction) {
      var start = Math.max(lengthAction.fileSize - BLAZAR_LOG_MAX_BYTES, 0);
      var end = start + BLAZAR_LOG_MAX_BYTES;

      return dispatch(blazarLogFetchChunk(id, buildId, start, end, config));
    });
  };
};

/* STANDARD HTTP API */
var httpFetchChunk = exports.httpFetchChunk = function httpFetchChunk(id, path, start, end) {
  return function (dispatch) {
    dispatch(fetchChunkStarted('HTTP', id, start, end));

    var httpHeaders = new Headers();
    if (start) {
      httpHeaders.append('Range', 'bytes=' + start + '-' + (end || ''));
    }

    var fetchInit = {
      method: 'GET',
      headers: httpHeaders
    };

    return (0, _isomorphicFetch2.default)(path, fetchInit).then(checkStatus).then(parseText).then(function (data) {
      // the API lies, so let's just figure out the bytelength ourselves
      // this code can't take lies.
      var encodedData = TE.encode(data);
      var byteLength = encodedData.byteLength;
      return dispatch(addFileChunk(id, {
        text: data,
        start: start,
        end: start + byteLength,
        byteLength: byteLength
      }, start, end));
    }).catch(function (error) {
      return dispatch(fetchChunkError('HTTP', id, start, end, error));
    });
  };
};
;

var _temp = function () {
  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
    return;
  }

  __REACT_HOT_LOADER__.register(frameworkName, 'frameworkName', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SINGULARITY_TAILER_AJAX_ERROR_EVENT, 'SINGULARITY_TAILER_AJAX_ERROR_EVENT', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(TE, 'TE', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(ADD_FILE_CHUNK, 'ADD_FILE_CHUNK', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(addFileChunk, 'addFileChunk', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(UNLOAD_FILE, 'UNLOAD_FILE', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(unloadFile, 'unloadFile', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(STOP_TAILING, 'STOP_TAILING', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(stopTailing, 'stopTailing', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(START_TAILING, 'START_TAILING', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(startTailing, 'startTailing', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(UNLOAD_FILE_CHUNK, 'UNLOAD_FILE_CHUNK', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(unloadFileChunk, 'unloadFileChunk', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SET_FILE_SIZE, 'SET_FILE_SIZE', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(setFileSize, 'setFileSize', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(TOGGLE_ANSI_COLORING, 'TOGGLE_ANSI_COLORING', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(toggleAnsiColoring, 'toggleAnsiColoring', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(TOGGLE_FETCH_OVERSCAN, 'TOGGLE_FETCH_OVERSCAN', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(toggleFetchOverscan, 'toggleFetchOverscan', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(RENDERED_LINES, 'RENDERED_LINES', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(renderedLines, 'renderedLines', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(FETCH_CHUNK, 'FETCH_CHUNK', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(FETCH_CHUNK_STARTED, 'FETCH_CHUNK_STARTED', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(fetchChunkStarted, 'fetchChunkStarted', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(FETCH_CHUNK_ERROR, 'FETCH_CHUNK_ERROR', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(fetchChunkError, 'fetchChunkError', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(checkStatus, 'checkStatus', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(parseJSON, 'parseJSON', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(parseText, 'parseText', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SANDBOX_MAX_BYTES, 'SANDBOX_MAX_BYTES', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SANDBOX_SET_API_ROOT, 'SANDBOX_SET_API_ROOT', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(sandboxSetApiRoot, 'sandboxSetApiRoot', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SET_TAIL_INTERVAL_MS, 'SET_TAIL_INTERVAL_MS', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(tailIntervalMs, 'tailIntervalMs', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SET_AUTHORIZATION_HEADER, 'SET_AUTHORIZATION_HEADER', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(setAuthorizationHeader, 'setAuthorizationHeader', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(sandboxFetchChunk, 'sandboxFetchChunk', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SANDBOX_FETCH_LENGTH, 'SANDBOX_FETCH_LENGTH', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SANDBOX_FETCH_LENGTH_STARTED, 'SANDBOX_FETCH_LENGTH_STARTED', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SANDBOX_FETCH_LENGTH_ERROR, 'SANDBOX_FETCH_LENGTH_ERROR', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(sandboxFetchLength, 'sandboxFetchLength', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(SANDBOX_FETCH_TAIL, 'SANDBOX_FETCH_TAIL', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(sandboxFetchTail, 'sandboxFetchTail', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(BLAZAR_LOG_MAX_BYTES, 'BLAZAR_LOG_MAX_BYTES', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(BLAZAR_SET_API_ROOT, 'BLAZAR_SET_API_ROOT', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(blazarSetApiRoot, 'blazarSetApiRoot', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(blazarLogFetchChunk, 'blazarLogFetchChunk', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(BLAZAR_LOG_FETCH_LENGTH, 'BLAZAR_LOG_FETCH_LENGTH', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(BLAZAR_LOG_FETCH_LENGTH_STARTED, 'BLAZAR_LOG_FETCH_LENGTH_STARTED', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(BLAZAR_LOG_FETCH_LENGTH_ERROR, 'BLAZAR_LOG_FETCH_LENGTH_ERROR', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(blazarLogFetchLength, 'blazarLogFetchLength', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(BLAZAR_LOG_FETCH_TAIL, 'BLAZAR_LOG_FETCH_TAIL', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(blazarLogFetchTail, 'blazarLogFetchTail', 'src/actions/index.js');

  __REACT_HOT_LOADER__.register(httpFetchChunk, 'httpFetchChunk', 'src/actions/index.js');
}();

;