zillabyte-cli 0.1.44 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd7cb56d0054ad1929f4dc26d00e1568c4498fe8
-  data.tar.gz: 86e93f77eed5d448aeb652846f39e37630adf4c9
+  metadata.gz: eea29081785924f4123050342b0106d98355f0c8
+  data.tar.gz: 9e5e777aa135171b8230ced0011622519e450539
 SHA512:
-  metadata.gz: 7af6a6ad15a31a5cf0bc7648f8595c63c0dfd9bebdec751dc391bc3f5ff6d1c72328127f45f74a424e050895a023f89c3a7d6d1638b527c598623629d3d79573
-  data.tar.gz: b738c1423fe2ccfa2f4e587e1faa264948efa172ec9e8bd831d333fe3ed68234437808c56dd5a3672ca3370629e6b4bd903fe27550732781a21d45246510d592
+  metadata.gz: 9b6441517bb14bd08ce83ddc6502e99287434f80403e6a1ee634c9880546ac772c32ea49bffe320737d72b7c70f1135e65862026df7ae89df3542f61447d5788
+  data.tar.gz: ad27686e26e9ebe20d2a4e38879449108dc2f8df4be5c70fecd97617cd409ec2f457dc337a09f3b4772144d5cf586d0e71533150a3551d7d5b5e4537e73e7924

data/lib/#zillabyte-cli.rb#

@@ -0,0 +1,5 @@
+require "zillabyte-cli/version"
+require "zillabyte/api"
+require "zillabyte/cli"
+require "zillabyte/common"
+require "zillabyte/queries"

data/lib/zillabyte-cli/version.rb

@@ -1,5 +1,5 @@
 module Zillabyte
   module CLI
-    VERSION = "0.1.44"
+    VERSION = "0.9.0"
   end
 end

data/lib/zillabyte/api/components.rb

@@ -26,12 +26,12 @@ class Zillabyte::API::Components < Zillabyte::API::Flows
 
       nodes = component["schema"]["nodes"]
       nodes.each do |node|
-        if node["type"] == "source"
+        if node["type"] == "input" or node["type"] == "source"
           inputs += "#{node["name"]}:\n"
           node["fields"].each do |field|
             inputs += "  (#{field.keys[0]}, #{field.values[0].upcase})\n"
           end
-        elsif node["type"] == "sink"
+        elsif node["type"] == "output" or node["type"] == "sink"
           outputs += "#{node["name"]}:\n"
           node["columns"].each do |field|
             outputs += "  (#{field.keys[0]}, #{field.values[0].upcase})\n"

data/lib/zillabyte/api/flows.rb

@@ -197,66 +197,8 @@ class Zillabyte::API::Flows < Zillabyte::API::Base
     res.body
 
   end
- 
-####################################################IMPORTANT####################################################
-#                                                                                                               #
-# get_rich_meta_info_from_script only works with zillabyte apps:push now! The pipe "info_to_ruby.in" is        #
-# hardcoded as the meta info passing pipe, so if 2 processes are trying to access it simultaneously there might #
-# be problems since it gets created/destroyed within this script (attempting to create a fifo that already      #
-# exists or deleting a fifo that still has information in it may occur).                                        #
-#                                                                                                               #
-####################################################IMPORTANT####################################################
-  def self.get_rich_meta_info_from_script(dir, session = nil, options = {})
-    require("zillabyte/cli/config")
-    hash = Zillabyte::CLI::Config.get_config_info(dir, session, options)
-    if hash.nil?
-      return {"status" => "error", "error" => "invalid_directory", "error_message" => "The specified directory (#{dir}) does not appear to contain a valid Zillabyte configuration file."}
-    end
-    hash["flow_type"] = "app" if hash["flow_type"].nil? # default to app
 
-    type = options[:output_type]
-    
-    full_script = File.join(dir, hash['script'])
-    command = nil
-    
-    require("securerandom")
-    info_file = "#{dir}/#{SecureRandom.uuid}"
-    arg = "--info --file \"#{info_file}\""
-
-
-    case hash["language"]
-    when "ruby"
-      command = "cd \"#{dir}\"; unset BUNDLE_GEMFILE; ZILLABYTE_HARNESS=1 bundle exec ruby \"#{full_script}\" #{arg}"
-      command = "cd \"#{dir}\"; unset BUNDLE_GEMFILE; ZILLABYTE_HARNESS=1 bundle exec ruby \"#{full_script}\" #{arg}"
-    when "python"
-      if(File.directory?("#{dir}/vEnv"))
-        command = "cd \"#{dir}\"; PYTHONPATH=~/zb1/multilang/python/Zillabyte #{dir}/vEnv/bin/python \"#{full_script}\" #{arg}"
-      else
-        command = "cd \"#{dir}\"; PYTHONPATH=~/zb1/multilang/python/Zillabyte python \"#{full_script}\" #{arg}"
-      end
-    when "js"
-      require("zillabyte/api/settings")
-      #command = "#{Zillabyte::API::CASPERJS_BIN} #{Zillabyte::API::API_CLIENT_JS}  \"#{full_script}\" --info"
-      command = "cd \"#{dir}\"; NODE_PATH=~/zb1/multilang/js/src/lib #{Zillabyte::API::NODEJS_BIN} \"#{full_script}\" #{arg}"
-    else
-      session.error "unsupported language: #{hash["language"]}" if session
-      return nil
-    end
 
-    require("zillabyte/cli/flows")
-    results = Zillabyte::Command::Flows.get_info(command, info_file, dir, options)
 
-    begin
-      meta = JSON.parse(results.split("\n").first.strip)   # Throws error if invalid json
-    rescue Exception => e
-      session.error("the underlying app did not return a valid result.  command: #{command} error: #{e.message}", type) if session
-      exit
-    end
-     
-    # Merge with the new info
-    return hash.merge(meta)
-    
-  end
-  
 
 end

data/lib/zillabyte/cli/#logs.rb#

@@ -0,0 +1,12 @@
+require "zillabyte/cli/base"
+
+# manage custom logs
+#
+class Zillabyte::Command::Logs < Zillabyte::Command::Base
+
+
+
+  
+  
+
+end

data/lib/zillabyte/cli/#repl.rb#

@@ -0,0 +1,43 @@
+require "zillabyte/cli/base"
+require 'readline'
+# REPL console for zillabyte commands
+#
+class Zillabyte::Command::Repl < Zillabyte::Command::Base
+
+  # repl
+  #
+  # start a console session for zillabyte
+  # --quiet # HIDDEN
+  # --history HISTORY# HIDDEN hack to allow history for readline
+  def index
+    if !options[:quiet]
+      v = `zillabyte version`
+      display "\n#{v}Type q,exit or Ctrl+D to quit\n\n"
+    end
+    server = `echo $ZILLABYTE_API_HOST` || ""
+    prompt = ""
+    if server && server.chomp.length > 0
+      prompt = "#{server.chomp} " 
+    end
+    prompt += "zillabyte $ "
+    if options[:history]
+      #p options[:history]
+      history = JSON.parse(options[:history])
+      history.last(50).each do |his|
+        # TODO: Handle single quotes ??
+        Readline::HISTORY << his
+      end
+    end
+    # TODO: Add tab completion for basic commands, app/relation names etc.
+    while cmd = Readline.readline(prompt, true)
+      if cmd && cmd.length > 0
+        if cmd.downcase == "exit" || cmd.downcase == "q"
+          display "" # TODO Make Ctrl+D print a newline too
+          return
+        else
+          exec "zillabyte #{cmd}; zillabyte repl --quiet --history '#{Readline::HISTORY.to_a.to_json}'"
+        end
+      end
+    end
+  end
+end

data/lib/zillabyte/cli/data.rb

@@ -449,7 +449,7 @@ class Zillabyte::Command::Data < Zillabyte::Command::Base
       aliases = []
     end
 
-    valid_types=["string", "integer", "float"]
+    valid_types=["string", "integer", "float", "double", "boolean", "array", "map"]
     meta_names=["id", "confidence", "since", "source"]
 
     if description.nil?
@@ -484,7 +484,7 @@ class Zillabyte::Command::Data < Zillabyte::Command::Base
   def get_dataset_properties(schema, is_public, description = "", aliases = nil)
     
     description ||= ""
-    valid_types=["string", "integer", "float"]
+    valid_types=["string", "integer", "float", "double", "boolean", "array", "map"]
     meta_names=["id", "confidence", "since", "source"]
     if schema.nil?
       schema = ""
@@ -545,13 +545,19 @@ class Zillabyte::Command::Data < Zillabyte::Command::Base
     n_columns = dataset["columns"].size
     float_cols = []
     int_cols = []
+    array_cols = []
+    map_cols = []
     (0...n_columns).each do |i|
       value = dataset["columns"][i].values[0].downcase
       # use integer instead of numeric to be consistent with multilang type declarations
       if(value == 'integer')
         int_cols << i
-      elsif(value == "float")
+      elsif(value == "float" or value == "double")
         float_cols << i
+      elsif(value == "array")
+        array_cols << i
+      elsif(value == "map")
+        map_cols << i
       end
     end
 
@@ -561,18 +567,42 @@ class Zillabyte::Command::Data < Zillabyte::Command::Base
         require("csv")
         CSV.foreach(file) do |row|
           if row.size != n_columns
-            error("dataset expects #{n_columns} column(s). Found a row with #{row.size}::\n #{row}", type)
+            error("Dataset expects #{n_columns} column(s). Found a row with #{row.size}::\n #{row}", type)
           end
 
           float_cols.each do |i|
             if (!(row[i] =~ /^[+-]?(\d+(.\d+)?)$/))
-            error("column #{i+1} should be an INTEGER in row ::\n #{row}", type)
+              error("Column #{i+1} should be a FLOAT or DOUBLE in row ::\n #{row}", type)
             end
           end
 
           int_cols.each do |i|
             if (!(row[i] =~ /^[+-]?(\d+)$/))
-             error("column #{i+1} should be an INTEGER in row #{row}::\n #{row}", type)
+              error("Column #{i+1} should be an INTEGER in row ::\n #{row}", type)
+            end
+          end
+
+          array_cols.each do |i|
+            err = "Column #{i+1} should be an ARRAY (i.e. [v0,v1,...]) in row ::\n #{row}\n Please remember to escape strings in the array!"
+            begin
+              array = JSON.parse(row[i])
+            rescue
+              error(err, type)
+            end
+            if !array.instance_of?(Array)
+              error(err, type)
+            end
+          end
+
+          map_cols.each do |i|
+            err = "Column #{i+1} should be a MAP (i.e. {\"k1\":v1,\"k2\":v2,...}) in row ::\n #{row}\n Please remember to escape strings in the map!"
+            begin
+              map = JSON.parse(row[i])
+            rescue
+              error(err, type)
+            end
+            if !map.instance_of?(Hash)
+              error(err, type)
             end
           end
           rows << row

data/lib/zillabyte/cli/flows.rb

@@ -78,7 +78,7 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     # Get the meta info
     require('zillabyte/api/flows')
     options[:local_flag] = 1
-    hash = Zillabyte::API::Flows.get_rich_meta_info_from_script(dir, session, options)
+    hash = get_rich_info(dir, session, options)
     if hash.nil?
       session.error("unable to extract #{flow_type} meta information", type) if session
     end
@@ -332,7 +332,12 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     instances = res.body["instances"].select do |instance|
       !instance.nil?
     end
-    return if instances.empty?
+    if instances.empty?
+      if type
+        display res.body.to_json
+      end
+      return
+    end
 
     # a nested hash so can't map directly
     # instead i'll map separately and then merge the arrays
@@ -445,9 +450,11 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
   #
   # Runs a local flow with live data.
   # 
-  # --config CONFIG_FILE                        # Use the given config file
-  # --dir DIR                                   # Flow directory
-  # --output_type OUTPUT_TYPE                   # Specify an output type i.e. json #HIDDEN
+  # --config CONFIG_FILE         # Use the given config file
+  # --dir DIR                    # Flow directory
+  # --output_type OUTPUT_TYPE    # Specify an output type i.e. json #HIDDEN
+  # --host HOST                  # #HIDDEN
+  # --port PORT                  # #HIDDEN
   #
   # HIDDEN:
   def live_run
@@ -455,7 +462,9 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     name = options[:name] || shift_argument
     type = options[:output_type]
 
-    thread_id = options[:thread] || shift_argument || ""
+    host = options[:host]
+    port = options[:port]
+    
     dir = options[:dir] || shift_argument
     if dir.nil?
       dir = Dir.pwd
@@ -469,10 +478,10 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
       error("could not find meta information for: #{dir}", type)
     end
    
-    if(thread_id == "")
-      exec(command("--execute_live --name #{name.to_s}",type, dir))
+    if(host && port)
+      exec(Zillabyte::Helpers.command("--execute_live --name #{name.to_s} --host \"#{host}\" --port #{port}",type, dir))      
     else 
-      exec(command("--execute_live --name #{name.to_s} --pipe #{dir}/#{thread_id}",type, dir))
+      exec(Zillabyte::Helpers.command("--execute_live --name #{name.to_s}",type, dir))
     end
   end 
   alias_command "live_run", "flows:live_run"
@@ -481,37 +490,47 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
   # 
   # Outputs the info for the flow in the dir.
   # 
-  # --pretty                                    # Pretty prints the info output
-  # --dir DIR                                   # Flow directory
-  # --output_type OUTPUT_TYPE                   # Specify an output type i.e. json #HIDDEN
+  # --pretty                     # Pretty prints the info output
+  # --dir DIR                    # Flow directory
+  # --output_type OUTPUT_TYPE    # Specify an output type i.e. json #HIDDEN
+  # --host HOST                  # #HIDDEN
+  # --port PORT                  # #HIDDEN
   #
   def info
+    
+    # Init 
+    require 'socket'
+    type = options[:output_type]
     dir = options[:dir] || shift_argument
     if dir.nil?
       dir = Dir.pwd
     else
       dir = File.expand_path(dir)
     end
-
-    require("securerandom")
-    info_file = "#{dir}/#{SecureRandom.uuid}"
-    type = options[:output_type]
-
-    cmd = command("--info --file \"#{info_file}\"", type, dir)
-    require("zillabyte/cli/apps")
-    flow_info = Zillabyte::Command::Apps.get_info(cmd, info_file, dir, options)
-
-    if type == "json"
-      puts flow_info
+    host = options[:host]
+    port = options[:port]
+    
+    if (host && port)
+      
+      # Do we have a host, port? If so, delegate to the multilang...
+      flow_info = Zillabyte::Helpers.get_info(dir, options)
+      socket = TCPSocket.new(host, port)
+      socket.write(flow_info.to_json)
+      socket.close()
+      exit
+      
     else
+      
+      # Otherwise, start our own tcp socket and get the info, print to stdout 
+      flow_info = Zillabyte::Helpers.get_info(dir, options)
       if options[:pretty]
         puts JSON.pretty_generate(JSON.parse(flow_info))
       else
-        puts flow_info
+        puts flow_info.to_json
       end
+      exit 
+      
     end
-
-    exit
   end
   alias_command "info", "flows:info"
 
@@ -595,46 +614,6 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
   end
 
 
-  def self.get_info(cmd, info_file, dir, options = {})
-    type = options[:output_type]
-    response = `#{cmd}`
-    if($?.exitstatus == 1)
-
-      File.delete("#{info_file}") if File.exists?(info_file)
-
-      if options[:output_type].nil?
-        exit(1)
-      else
-        Zillabyte::Helpers.error("error: #{response}", type)
-      end
-    end
-
-    flow_info = {}
-    File.open("#{info_file}", "r+").each do |line|
-      line = JSON.parse(line)
-      if(line["class"] == "node")
-        flow_info["nodes"] << line["info"]
-      elsif(line["class"] == "arc")
-        flow_info["arcs"] << line["info"]
-      else
-        flow_info = line
-        flow_info["nodes"] = []
-        flow_info["arcs"] = []
-      end
-    end
-    File.delete("#{info_file}")
-
-    flow_info = flow_info.to_json
-    if(File.exists?("#{dir}/info_to_java.in"))
-      java_pipe = open("#{dir}/info_to_java.in","w+")
-      java_pipe.puts(flow_info+"\n")
-      java_pipe.flush
-      java_pipe.close()
-    end
-
-    flow_info
-  end
-
 
   # flows:local
   #
@@ -657,7 +636,7 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     
     # Get the flow_type
     require("zillabyte/api/flows")
-    meta = Zillabyte::API::Flows.get_rich_meta_info_from_script(dir, session, {:test => true})
+    meta = get_rich_info(dir, session, {:test => true})
     if meta.nil? || meta["nodes"].nil?
       error "this is not a valid zillabyte flow directory"
       exit
@@ -755,46 +734,11 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
 
 
   private 
-  
-
-  def command(arg="--execute_live", type = nil, dir = Dir.pwd, ignore_stderr = false)
-    require("zillabyte/cli/config")
-    meta = Zillabyte::CLI::Config.get_config_info(dir, self, options)
-
-    #meta = Zillabyte::API::Functions.get_rich_meta_info_from_script(dir, self)
-    error("could not extract meta information. missing zillabyte.conf.yml?", type) if meta.nil?
-    error(meta["error_message"], type) if meta['status'] == "error"
-    full_script = File.join(dir, meta["script"])
-    stderr_opt = "2> /dev/null" if ignore_stderr
-
-    case meta["language"]
-    when "ruby"
-      # Execute in the bundler context
-      cmd = "cd \"#{dir}\"; unset BUNDLE_GEMFILE; ZILLABYTE_HARNESS=1 bundle exec ruby \"#{full_script}\" #{arg}  #{stderr_opt}"
-      
-    when "python"#{
-      if(File.directory?("#{dir}/vEnv"))
-        cmd = "cd \"#{dir}\"; PYTHONPATH=~/zb1/multilang/python/Zillabyte #{dir}/vEnv/bin/python \"#{full_script}\" #{arg}  #{stderr_opt}"
-      else
-        cmd = "cd \"#{dir}\"; PYTHONPATH=~/zb1/multilang/python/Zillabyte python \"#{full_script}\" #{arg}  #{stderr_opt}"
-      end
- 
-    when "js"
-#      cmd = "#{Zillabyte::API::CASPERJS_BIN} #{Zillabyte::API::API_CLIENT_JS}  \"#{full_script}\" #{arg}"
-      cmd = "cd \"#{dir}\"; NODE_PATH=~/zb1/multilang/js/src/lib #{Zillabyte::API::NODEJS_BIN}  \"#{full_script}\" #{arg} #{stderr_opt}"
-
-    else
-      error("no language specified", type)
-    end
-    
-    return cmd
-
-  end
 
   def read_name_from_conf(options = {})
     type = options[:output_type]
     require("zillabyte/api/apps")
-    hash = Zillabyte::API::Apps.get_rich_meta_info_from_script Dir.pwd, options
+    hash = get_rich_info(Dir.pwd, options)
     error("No id given and current directory does not contain a valid Zillabyte configuration file. Please specify a flow id or run command from the directory containing the flow.",type) if hash["error"]
     hash["name"]
   end

data/lib/zillabyte/cli/templates/python/#simple_function.py#

@@ -0,0 +1,27 @@
+import zillabyte
+
+def prep(controller):
+  return
+
+# This is the heart of your algorithm.  It's processed on every
+# web page.  This algorithm is run in parallel on possibly hundreds
+# of machines.
+def execute(controller, tup):
+  if("hello world" in tup.values["html"]):
+    controller.emit("has_hello_world",{"url":tup.values["url"]})
+  return
+
+zillabyte.simple_function(\
+  # This directive instructs zillabyte to give your function every
+  # web page in our known universe.  Your function will have access
+  # to two fields: URL and HTML
+  matches = "select * from web_pa", \
+
+  # This directive tells Zillabyte what kind of data your function
+  # produces.  In this case, we're saying we will emit a tuple that
+  # is one-column wide and contains the field 'URL' 
+  emits = [["has_hello_world", [{"url":"string"}]]], \
+
+  prepare = prep, \
+  execute = execute\
+)

data/lib/zillabyte/common/log_fetcher.rb

@@ -23,7 +23,13 @@ class LogFetcher
 
     @color_map = {}
 
-    cmd = "curl -G http://#{hash["flow"]}:#{hash["token"]}@#{ip}:#{hash["port"]}/getLogs?flow=#{hash["flow"]}"
+    local_file = "/tmp/flows/f#{hash["flow"]}/flow_logs/flow_#{hash["flow"]}.log"
+    if(hash["server"] == "localhost" && File.exists?(local_file))
+      cmd = "tail -n 500 -F \"#{local_file}\""
+    else
+      cmd = "curl -G http://#{hash["flow"]}:#{hash["token"]}@#{ip}:#{hash["port"]}/getLogs?flow=#{hash["flow"]}"
+    end
+    
 
     begin  
       PTY.spawn( cmd ) do |r, w, pid|

data/lib/zillabyte/helpers.rb

@@ -151,12 +151,12 @@ module Zillabyte
     end
     
     
-    def get_flow_name(dir = Dir.pwd)
-      require("zillabyte/api/flows")
-      meta = Zillabyte::API::Flows.get_rich_meta_info_from_script(dir)
-      return meta["name"] if meta
-      return nil
-    end
+    # def get_flow_name(dir = Dir.pwd)
+    #   require("zillabyte/api/flows")
+    #   meta = Zillabyte::API::Flows.get_rich_meta_info_from_script(dir)
+    #   return meta["name"] if meta
+    #   return nil
+    # end
     
 
     # Format a message for display
@@ -190,6 +190,118 @@ module Zillabyte
         error "expected remote server to return file manifest"
       end
     end
+    
+    
+
+
+    # Formerly: get_rich_meta_info_from_script. 
+    # Combines the zilabyte.conf.yaml with 'zillabyte info' 
+    def get_rich_info(dir, session = nil, options = {})
+      require("zillabyte/cli/config")
+      hash = Zillabyte::CLI::Config.get_config_info(dir, session, options)
+      if hash.nil?
+        return {"status" => "error", "error" => "invalid_directory", "error_message" => "The specified directory (#{dir}) does not appear to contain a valid Zillabyte configuration file."}
+      end
+    
+      hash["flow_type"] = "app" if hash["flow_type"].nil? # default to app
+      flow_info = get_info(dir, options)
+
+      return hash.merge(flow_info)
+
+    end
+
+
+    def get_info(dir, options = {})
+    
+      require 'socket'
+      host = "0.0.0.0"
+      type = options[:output_type]
+      raw_lines = []
+      server = TCPServer.new(0)
+      port = server.addr[1]
+    
+      server_thread = Thread.new do 
+      
+        client = server.accept()
+        loop do
+          raw_line = client.gets()
+          break if raw_line.nil?
+          raw_lines << raw_line
+        end
+        client.close()
+      end
+    
+      cmd = command("--info --host \"#{host}\" --port #{port}", type, dir)
+      system(cmd)
+      server_thread.join()
+    
+      if($?.exitstatus == 1)
+        if options[:output_type].nil?
+          exit(1)
+        else
+          Zillabyte::Helpers.error("error: #{response}", type)
+        end
+      end
+      if (raw_lines.size == 0)
+        if options[:output_type].nil?
+          exit(1)
+        else
+          Zillabyte::Helpers.error("process did not emit any information", type)
+        end
+      end
+    
+      flow_info = {}
+      raw_lines.each do |raw_line|
+        line = JSON.parse(raw_line)
+        if(line["class"] == "node")
+          flow_info["nodes"] << line["info"]
+        elsif(line["class"] == "arc")
+          flow_info["arcs"] << line["info"]
+        else
+          flow_info = line
+          flow_info["nodes"] = []
+          flow_info["arcs"] = []
+        end
+      end
+
+      flow_info
+    
+    end
+    
+    def command(arg="--execute_live", type = nil, dir = Dir.pwd, ignore_stderr = false, options = {})
+      require("zillabyte/cli/config")
+      meta = Zillabyte::CLI::Config.get_config_info(dir, self, options)
+
+    #meta = Zillabyte::API::Functions.get_rich_meta_info_from_script(dir, self)
+      error("could not extract meta information. missing zillabyte.conf.yml?", type) if meta.nil?
+      error(meta["error_message"], type) if meta['status'] == "error"
+      full_script = File.join(dir, meta["script"])
+      stderr_opt = "2> /dev/null" if ignore_stderr
+
+      case meta["language"]
+      when "ruby"
+      # Execute in the bundler context
+        cmd = "cd \"#{dir}\"; unset BUNDLE_GEMFILE; ZILLABYTE_HARNESS=1 bundle exec ruby \"#{full_script}\" #{arg}  #{stderr_opt}"
+
+      when "python"#{
+        if(File.directory?("#{dir}/vEnv"))
+          cmd = "cd \"#{dir}\"; PYTHONPATH=~/zb1/multilang/python/Zillabyte #{dir}/vEnv/bin/python \"#{full_script}\" #{arg}  #{stderr_opt}"
+        else
+          cmd = "cd \"#{dir}\"; PYTHONPATH=~/zb1/multilang/python/Zillabyte python \"#{full_script}\" #{arg}  #{stderr_opt}"
+        end
+
+      when "js"
+#      cmd = "#{Zillabyte::API::CASPERJS_BIN} #{Zillabyte::API::API_CLIENT_JS}  \"#{full_script}\" #{arg}"
+        cmd = "cd \"#{dir}\"; NODE_PATH=~/zb1/multilang/js/src/lib #{Zillabyte::API::NODEJS_BIN}  \"#{full_script}\" #{arg} #{stderr_opt}"
+
+      else
+        error("no language specified", type)
+      end
+
+      return cmd
+
+    end
+ 
 
   end
 end

data/zillabyte-cli.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bundler", "~> 1.3"
   spec.add_dependency "colorize", "~> 0.6"
   spec.add_dependency "indentation", "~> 0.1"
-  spec.add_dependency "mkfifo"
+  spec.add_dependency "eventmachine"
 
   spec.post_install_message = """
 Getting Started with Zillabyte

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zillabyte-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.44
+  version: 0.9.0
 platform: ruby
 authors:
 - zillabyte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2014-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -151,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: mkfifo
+  name: eventmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -179,6 +179,7 @@ files:
 - bin/zb
 - bin/zbd
 - bin/zillabyte
+- lib/#zillabyte-cli.rb#
 - lib/zillabyte-cli.rb
 - lib/zillabyte-cli/version.rb
 - lib/zillabyte/api.rb
@@ -197,6 +198,8 @@ files:
 - lib/zillabyte/api/zillalogs.rb
 - lib/zillabyte/auth.rb
 - lib/zillabyte/cli.rb
+- lib/zillabyte/cli/#logs.rb#
+- lib/zillabyte/cli/#repl.rb#
 - lib/zillabyte/cli/apps.rb
 - lib/zillabyte/cli/auth.rb
 - lib/zillabyte/cli/base.rb
@@ -233,6 +236,7 @@ files:
 - lib/zillabyte/cli/templates/components/ruby/Gemfile
 - lib/zillabyte/cli/templates/components/ruby/component.rb.erb
 - lib/zillabyte/cli/templates/components/ruby/zillabyte.conf.yaml
+- lib/zillabyte/cli/templates/python/#simple_function.py#
 - lib/zillabyte/cli/untitled.md
 - lib/zillabyte/cli/version.rb
 - lib/zillabyte/cli/zillalogs.rb