node_task 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa1be3ec14616f90bb984d79d5a640c62cf90019
+  data.tar.gz: 70950fdd92e3f1232467045782572dec5d1a76b1
+SHA512:
+  metadata.gz: ee53d8c32c41ecfe33d18fb326654aeb419b8ed6a0d6e697625141d6baaea80b145063a57fa9f2873ffcb4f6bb462bbd552b79fb444413eb3dbb69f745dd7574
+  data.tar.gz: ea631053a8531cc1d100da7dd34c35eec85a7739aa2dcebf162fe9a6c6a43339020860abc2664bfce929b23bfba8900f6c46d320b67960f8b05f2c0b102636ed

data/lib/node_task/index.js

@@ -0,0 +1,136 @@
+var fs = require('fs')
+var path = require('path')
+var net = require('net')
+var winston = require('winston')
+var ndjson = require('ndjson')
+
+var workingDir = path.resolve(process.env.NODE_TASK_CWD || __dirname)
+var errorLogPath = path.join(workingDir, 'ruby_node_task-error.log')
+
+// write pidfile
+fs.writeFileSync(path.join(workingDir, 'ruby_node_task.pid'), process.pid+'')
+
+var logger = makeLogger(workingDir, process.env.NODE_TASK_DEBUG)
+
+var sockPath = process.env.NODE_TASK_SOCK_PATH || makeSockPath(
+  workingDir,
+  process.env.NODE_TASK_DAEMON_ID || 'ruby_node_task'
+)
+
+var server = net.createServer(onClientConnect)
+  .on('error', function (err) { logger.error('server error: '+err.toString()) })
+  .listen(sockPath, function() { logger.debug('listening on '+sockPath) })
+
+process.on('exit', onExit)
+process.on('uncaughtException', onUncaughtException)
+
+// the important part
+function onClientConnect(socket) {
+  logger.debug('client connected')
+
+  var busy = false
+  socket
+    .on('error', function(err) { logger.error('socket error: '+err.toString()) })
+    .on('end', function() { logger.debug('client finished') })
+    .on('close', function() { logger.debug('client disconnect') })
+    .pipe(ndjson.parse())
+    .on('error', sendError)
+    .on('data', receiveMsg)
+  
+  function sendMsg(msg) { socket.end(serialiseMsg(msg)) }
+  function sendError(err) { socket.end(serialiseMsg(errorMsg(err))) }
+  function receiveMsg(msg) {
+    if (busy) {
+      return sendError(new Error('only one task can be run per connection'))
+    }
+
+    if (msg.status) {
+      return server.getConnections(function(err, count) {
+        sendMsg({clients: count-1}) // minus this connection
+      })
+    }
+
+    if (!msg.task) {
+      return sendError(new Error('msg.task not defined'))
+    }
+
+    var runTask = loadTaskModule(path.join(workingDir, msg.task))
+
+    var opts = msg.opts || {}
+    busy = true
+    runTask(opts, function(err, result) {
+      busy = false
+      if (err) {
+        logger.error('task error: '+err)
+        sendError(err)
+      } else {
+        logger.debug('task complete: '+msg.task)
+        sendMsg({result: result})
+      }
+    })
+  }
+  
+  function loadTaskModule(taskModule) {
+    try {
+      return require(taskModule)
+    } catch (err) {
+      return sendError(new Error('Encountered "'+err+'" while attempting to load task "'+taskModule+'"'))
+    }
+  }
+}
+
+function onUncaughtException(err) {
+  logger.error('uncaught exception: '+err.toString(), function () {
+    try {
+      fs.writeFileSync(errorLogPath, err.stack)
+    } catch (err) {
+      return logger.error('logging error: '+err.toString(), function () {
+        process.exit()
+      })
+    }
+    process.exit()
+  })
+}
+
+function onExit() {
+  try {
+    fs.unlinkSync(sockPath)
+    logger.debug('removed '+sockPath)
+  } catch (err) {
+    // already removed
+  }
+}
+
+function makeLogger(workingDir, debug) {
+  return new winston.Logger({
+    transports: [
+      debug ? new winston.transports.File({
+        filename: path.join(workingDir, 'ruby_node_task-debug.log'),
+        level: 'debug',
+      }) : new winston.transports.Console(),
+    ],
+  })
+}
+
+// make a path for a cross platform compatible socket path
+function makeSockPath(dir, name) {
+  if (process.platform === 'win32') {
+    return '\\\\.\\pipe\\'+name+'\\' + path.resolve(dir)
+  } else {
+    return path.join(dir, name+'.sock')
+  }
+}
+
+function serialiseMsg(msg) {
+  return JSON.stringify(msg)+'\n'
+}
+
+function errorMsg(err) {
+  return {
+    error: {
+      message: err.message,
+      code: err.code,
+      stack: err.stack,
+    }
+  }
+}

data/lib/node_task/node_task.rb

@@ -0,0 +1,278 @@
+require 'socket'
+require 'json'
+require 'daemon_controller'
+require 'timeout'
+require 'logger'
+
+class NodeTask
+  RESPONSE_TIMEOUT = 20
+  START_MAX_RETRIES = 1
+
+  class Error < StandardError
+    def initialize(js_error)
+      @js_error = js_error
+      super(js_error[:message])
+    end
+
+    def to_s
+      @js_error[:stack] || @js_error[:message]
+    end
+  end
+
+  class << self
+    attr_writer :node_command
+    attr_writer :logger
+    attr_writer :working_dir
+
+    def windows?
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    def logger
+      return @logger unless @logger.nil?
+      @logger = Logger.new(STDERR)
+      @logger.level = ENV["NODE_TASK_DEBUG"] ? Logger::DEBUG : Logger::INFO 
+      @logger
+    end
+
+    def working_dir
+      @working_dir || Dir.pwd
+    end
+
+    def error_log_file
+      File.join(working_dir, "#{daemon_identifier}-error.log")
+    end
+
+    def pid_file
+      File.join(working_dir, "#{daemon_identifier}.pid")
+    end
+
+    def gem_dir
+      @gem_dir ||= File.dirname(File.expand_path(__FILE__))
+    end
+
+    def daemon_identifier
+      'ruby_node_task'
+    end
+
+    def socket_path
+      @socket_path ||= _make_sock_path(working_dir, daemon_identifier)
+    end
+
+    def node_command
+      @node_command || ENV["NODE_COMMAND"] || ENV["NODE_TASK_DEBUG"] ? 'node --debug' : 'node'
+    end
+
+    def npm_command
+      @npm_command || ENV["NPM_COMMAND"] || 'npm'
+    end
+
+    def daemon_start_script
+      File.join(gem_dir, 'index.js').to_s
+    end
+
+    def npm_install
+      system("cd #{gem_dir}; #{npm_command} install")
+    end
+
+    # get configured daemon controller for daemon, and start it
+    def server
+      npm_install unless Dir.exists? File.join(gem_dir, 'node_modules')
+      @controller ||= _make_daemon_controller
+
+      begin
+        @controller.start
+        logger.debug "spawned server #{@controller.pid}"
+      rescue DaemonController::AlreadyStarted => e
+        logger.debug "server already running #{@controller.pid}"
+      end
+
+      @controller
+    end
+
+    # really try to successfully connect, starting the daemon if required
+    def ensure_connection
+      attempt = 0
+      begin
+        server # make sure daemon is running
+
+        socket = server.connect do
+          begin
+            _make_connection
+          rescue Errno::ENOENT => e 
+            # daemon_controller doesn't understand ENOENT
+            raise Errno::ECONNREFUSED, e.message
+          end
+        end
+      rescue DaemonController::StartTimeout, DaemonController::StartError => e
+        logger.error e.message
+        if attempt < START_MAX_RETRIES
+          attempt += 1
+          logger.error "retrying attempt #{attempt}"
+          retry
+        else
+          raise e
+        end
+      end
+
+      socket
+    end
+
+    def check_error
+      if File.exist? error_log_file
+        # TODO: raise error
+        logger.error File.open(error_log_file).read
+        File.unlink error_log_file
+        true
+      end
+    end
+
+    # get a json response from socket
+    def parse_response(socket)
+      # only take one message - the result
+      # response terminated by newline
+      response_text = nil
+      loop do
+        response_text = socket.gets("\n")
+        break if response_text
+        break if check_error
+      end
+      if response_text
+        JSON.parse(response_text, symbolize_names: true)
+      else
+        logger.error 'no response for message'
+        nil
+      end
+    end
+
+    # make a single request, get a response and close the connection
+    def request(socket, message)
+      socket.write(message.to_json+"\n")
+
+      result = nil
+      begin
+        Timeout::timeout(RESPONSE_TIMEOUT) do
+          result = parse_response(socket)
+        end
+      rescue Timeout::Error, Exception => e
+        logger.error e.message
+      ensure
+        # disconnect after receiving response
+        socket.close
+      end
+
+      result
+    end
+
+    # number of connections active to the daemon
+    def clients_active
+      socket = _make_connection # might fail
+      message = {status: true} # special message type
+      result = request(socket, message)
+      return 0 if result.nil?
+      result[:clients]
+    end
+
+    # stop the daemon if no one else is using it
+    def release
+      begin
+        # this doesn't really work as intended right now
+        # as no connections are maintained when tasks aren't running
+        return if clients_active > 0
+      rescue Errno::ENOENT => e
+        # socket file probably doesn't exist
+        # maybe we should just return here?
+      end
+
+      pid = nil
+      begin
+        pid = @controller.pid
+      rescue Errno::ENOENT => e
+        # presumably no pid file exists and the daemon is not running
+        logger.debug "daemon already stopped"
+        return
+      end
+
+      logger.debug "stopping daemon #{pid}"
+      @controller.stop
+
+      begin
+        File.unlink socket_path
+      rescue Errno::ENOENT => e
+        # socket file's already gone
+      end
+    end
+
+    private
+
+    def _make_connection
+      UNIXSocket.new socket_path
+    end
+
+    def _make_sock_path(dir, name)
+      if windows?
+        "\\\\.\\pipe\\#{name}\\#{File.expand_path(dir)}"
+      else
+        File.join(dir, "#{name}.sock")
+      end
+    end
+
+    # TODO:
+    # - some server errors not reported
+    def _make_daemon_controller
+      logger.debug "socket_path #{socket_path}"
+
+      controller = DaemonController.new(
+        identifier: daemon_identifier,
+        start_command: "#{node_command} #{daemon_start_script}",
+        # ping_command: [:unix, socket_path],
+        ping_command: Proc.new{
+          begin
+            _make_connection
+          rescue Errno::ENOENT => e 
+            # daemon_controller doesn't understand ENOENT
+            raise Errno::ECONNREFUSED, e.message
+          end
+        },
+        pid_file: pid_file,
+        log_file: error_log_file,
+        env: {
+          "NODE_TASK_SOCK_PATH" => socket_path,
+          "NODE_TASK_CWD" => working_dir,
+          "NODE_TASK_DAEMON_ID" => daemon_identifier,
+          "NODE_ENV" => ENV["RACK_ENV"],
+        },
+        start_timeout: 5,
+        daemonize_for_me: true,
+      )
+
+      at_exit { release }
+
+      controller
+    end
+  end
+
+  attr_accessor :task
+
+  def initialize(_task)
+    @task = _task
+  end
+
+  def run(opts = nil)
+    socket = self.class.ensure_connection
+
+    message = {
+      task: task,
+      opts: opts,
+    }
+
+    response = self.class.request(socket, message)
+    if response
+      if response[:error]
+        raise NodeTask::Error, response[:error]
+      else
+        response[:result]
+      end
+    end
+  end
+end

data/lib/node_task/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "ruby_node_task",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "James Friend <james@jsdf.co> (http://jsdf.co/)",
+  "license": "ISC",
+  "dependencies": {
+    "ndjson": "^1.3.0",
+    "winston": "^1.0.0"
+  }
+}

data/lib/node_task.rb

@@ -0,0 +1 @@
+require_relative './node_task/node_task'

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: node_task
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Friend
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: daemon_controller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Much longer explanation of the node_task!
+email: james@jsdf.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/node_task.rb
+- lib/node_task/index.js
+- lib/node_task/node_task.rb
+- lib/node_task/package.json
+homepage: https://rubygems.org/gems/node_task
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: This is an node_task!
+test_files: []