kd/modules/kite.coffee

_                   = require 'underscore'
fs                  = require "fs-extra"
os                  = require "os"
url                 = require "url"
path                = require "path"
http                = require "http"
https               = require "https"
shell               = require "shelljs"
helpers             = require '../modules/common/helpers'
request             = require "request"
querystring         = require "querystring"
readDirFiles        = require 'read-dir-files'
Processes           = require '../lib/processes'
KDKite              = require '../lib/kdkite'
Controller          = require '../lib/controller'

if process.env['HOME']
  homedir = path.join process.env['HOME'], '.kd'
else
  homedir = '/root/.kd'

kitemanifest        = require "#{homedir}/kd-manifest.json"
kitehelper          = require "kite-amqp/lib/kite-amqp/kite.coffee"

{ask, logger}   = require "../lib/utils"
{manifest, kite}     = require "../lib/common"
{exec, spawn} = require "child_process"
{guard, findFile} = require '../modules/common/helpers'

module.exports = class KiteController extends Controller

  help_txt:"""
  Kites are awesome simple processes that can do amazing things. (go check http://kd.io/kites)
  """

  @set
    commands:
        'create': ['create', 'Creates a kite']
        'run':    ['run', 'Runs the kite and all its dependencies']
        'install': ['install', """
          Installs kites dependencies

          usage:

            kd kite install

        """]

        'listdependencies': ['listDependencies', 
          '''
            kd listdependencies
          '''
        ]
        
        'removedependency': ['removeDependency', 
          '''
            Removes kite dependency:

            usage:
              kd removedependency /projects/mykite
          '''
        ]
        
        'zip': ['createZip', 'creates a zip file from kite']

        'deploy': ['createZip', 'deploys the kite file']

        'list': ['list', 'Lists running kites']

        'cluster': ['cluster', 'Kite cluster related commands']

        'adddependency': ['addDependency', 
            '''Adds a service dependency

               That means when you run this kite, it will run the other kites that this kite depends on.

               You can add another kite as a runtime dependency from a git repo, a zip url or from local filesystem.

               usage:
                kd adddependency git://
                
                kd adddependency /projects/mykite/

                kd adddependency http://example.com/mykite.zip

            ''']

  constructor: (@configuration)->
    {@config} = @configuration
    @config.KODING_ROOT or= "https://koding.com"
    @cwd = process.cwd()

  create: (type, name, kitePath=@cwd)->
    console.log "type", type
    guard (type not in ["worker", "server", "server-express"]), "You have to define a type for your kite: 'worker' or 'server'"
    guard not name, "Please define a name for your kite."
    guard name.match(/[^\w]/), "Please do not use special chars in kite name."

    kiteDir = path.join kitePath, "#{name}.kite"
    console.log "Creating #{name} kite in #{kiteDir}"

    kite = new KDKite(kiteDir)
    kite.name = name
    kite.username = @config.username
    kite.mail = @config.mail
    kite.version = '1.0.1'
    kite.cloneFrom "#{type}.kite", ->
      kite.prepare (err)->
        process.stdout.write os.EOL
        console.log """

        Kite created as #{type} successfully.
        To run, do:

        cd #{path.relative process.cwd(), kiteDir}
        kd kite run
        """
    return kite

  getKiteFromPath: (dir=@cwd)->
    kite = new KDKite(dir)
    kite.processes = @processes
    return kite

  applicationInstalled:(application)->
    exec "which java", (error, stdout, stderr)->
      if error
        return false
      return true

  runMergen:(callback)->
    mergen = spawn('mergen')
    mergen.stdout.on 'data', (d)-> 
      console.log ">>>>", d.toString()
      search = "Mergen Server listening for commands on"
      if d.toString().indexOf(search) > -1 
        callback /([0-9]+)/.exec(d.toString())[1]
    mergen.stderr.on 'data', (d)-> 
      console.log "" + d

  prerun:(callback)->
    if not @applicationInstalled("java")
      console.warn "java is not installed, you wont be able to communicate with other kites, or use datastore"
      console.warn "please install java by visiting http://java.com/download"
    else
      # find if we have mergen
      @runMergen (port)->
        console.log "here comes our port", port
        return callback(port)

    # if fs.existsSync("node_modules")
    #   return cb()
    # cmd = "rm -rf node_modules; mkdir node_modules; npm i coffee-script hat redis underscore && " +
    #       "cd node_modules &&" + 
    #       "wget http://local.koding.com/kite-amqp.tgz && tar zxvf kite-amqp.tgz && cd .. && npm i"

    # exec cmd, (error, stdout, stderr)->
    #   console.log('stdout: ' + stdout)
    #   console.log('stderr: ' + stderr)
    #   if error
    #     console.log('exec error: ' + error)
    #   # npm gives an error because, kite-amqp is not in registry
    #   cb()

  cluster:(cmd)->
    if cmd is "create"
      console.log __dirname
      process.chdir path.join(__dirname, 'resources') 
      vagrant = spawn('vagrant', ['up'])
      vagrant.stdout.on 'data', (d)-> console.log "" + d
      vagrant.stderr.on 'data', (d)-> console.log "" + d

  run:(dir=@cwd)->
    console.log "preparing...."
    process.chdir dir
    @prerun (port)=>
      console.log "here is our port", port
      @run_(dir, port)

  run_:(dir=@cwd, port=6380)->

    @processes = new Processes()
    kite = @getKiteFromPath(dir)    
    kite.prepare ->
      console.log "prepare completed !!!!"
      kite.run(messageBusPort:port)

    net = require 'net'
    server = net.createServer (socket) =>
      cmds =
        'hosts': (args, cb)=>
            @mergenData.hkeys "kd-runner", (err, hosts)->
              console.log hosts
              cb hosts.join("\n")

        'list': (args, cb)=>
            ret = []
            for i of @processes.list
              ret.push "#{@processes.list[i].pid}\t#{i}\t#{ (Date.now() - @processes.list[i].startedAt)/1000 } seconds"
            cb ret.join("\n")

        'status': (name, cb)=>
            if not @processes.list[name]
              return 'no such process'
            p = @processes.list[name]
            cb "running for #{(Date.now() - p.startedAt) / 1000 } seconds \t with pid #{p.pid}"

        'attach': (directory, cb)=>
            kite = new KDKite(directory[0])
            kite.processes = @processes
            kite.prepare ->
              console.log "prepared kite at ", directory
              kite.run()
              cb "attached"

        'kill': (name, cb)->
            cb 'TODO'

        'restart': (name, cb)->
            cb 'TODO'

        'socketwrite': (args, cb)=>
            console.log("socket write called", args)
            socket.write args.join(' ') + "\n"
            cb("") if cb

      socket.on 'data', (data) ->
        cmdline = data.toString().split("\n")
        cmdline = cmdline[0].replace(/\r$/, '')
        k = cmdline.split(' ')
        try
          cmds[k[0]] k[1...], (ret)->
            socket.write ret + "\n"
        catch Error
          console.trace Error
          ret = Error.toString()
          socket.write ret + "\n"

    # server.listen 9001, 'localhost'

  listDependencies: ()->
    kite = @getKiteFromPath(@cwd)
    kite.listDependencies()

  removeDependency: (dep)->
    kite = @getKiteFromPath(@cwd)
    kite.removeDependency dep, ->
      # TODO: remove the dependency folder ??? 
      console.log "Dependency removed"

  addDependency: (dep)->
    kite = @getKiteFromPath(@cwd)
    kite.addDependency dep, ->
      console.log "Dependency added"

  createZip:()=>
    sha1file = (file)->
      crypto = require('crypto')
      shasum = crypto.createHash('sha1')
      s = fs.readFileSync(file)
      return shasum.update(s).digest("hex")

    kite = @getKiteFromPath(@cwd)    
    kite.prepare =>
      console.log "Creating zip file"
      zipfilename = "/tmp/#{kite.name}.zip"

      process.chdir ".."
      zip = spawn('zip', ['-r', zipfilename, "#{kite.name}.kite", '-x', '*/node_modules/*'])
      zip.stdout.on 'data', (d)-> console.log "" + d
      zip.stderr.on 'data', (d)-> console.log "" + d

      zip.on 'exit', (code)=>
        if code isnt 0
            console.log('zip process exited with code ' + code);
        else
          console.log "done zip, now uploading"

          client = require('needle')
            
          url = "#{@config.KODING_ROOT}/-/kd/upload"

          filekey = path.basename(zipfilename)
          data = 
            username: @config.username
            key: @config.publicKey
            hash: sha1file(zipfilename)

          data[filekey] = { file: zipfilename, content_type: 'application/zip' }
          data["#{filekey}-size"] = fs.statSync(zipfilename).size

          console.log "uploading to ", url
          client.post url, data, multipart:true, (err, resp, body)->
            console.log(err)
            console.log("Got status code " + resp.statusCode)
            console.log(body)
            options = JSON.parse body
            fs.unlink(zipfilename)
            console.log "options", options
            # now we can deploy...
            mykite = kitehelper.worker kitemanifest,
              list: ()->
                options['kiteName'] = "#{kite.name}.kite"
                @group "Deployer", "deploy", [options], (err, opts)->
                  console.log "here", err, opts.args[0].id
                  console.log "Deployed to", opts.args[0].id
                  #kites.push reply
                  process.exit 0
            , true

            mykite.start ()->
              mykite.callFunction 'list', [], ()->
                console.log "done"

  install: ()->
    kite = @getKiteFromPath(@cwd)    
    kite.prepare ->
      console.log "Installation complete"

  list: ()->
    kites = []
    listsent = false
    setTimeout ()->
      for i in kites
        console.log ">>>>", i
      process.exit 0
    , 3000

    mykite = kitehelper.worker kitemanifest,
      list: ()->
        @everyone "kite.who", [], (err, reply)->
          kites.push reply.args[1]

    mykite.start ()->
      mykite.callFunction 'list', [], ()->
        console.log "done"