zillabyte-cli 0.0.16 → 0.0.17

data/lib/zillabyte/cli/{flows.rb → apps.rb}

@@ -8,26 +8,31 @@ require 'securerandom'
 require 'colorize'
 require 'time_difference'
 
-# manage custom flows
+# manage custom apps
 #
-class Zillabyte::Command::Flows < Zillabyte::Command::Base
+class Zillabyte::Command::Apps < Zillabyte::Command::Base
 
-  # flows
+  MAX_POLL_SECONDS = 60 * 5
+  POLL_SLEEP = 0.5
+
+  # apps
   #
-  # list custom flows
+  # list custom apps
+  # --type TYPE     # specify an output type i.e. json
   #
   def index
     self.list
   end
 
-  # flows
-  #
-  # list custom flows
+  # apps
   #
+  # list custom apps
+  # --type TYPE # specify an output type i.e. json
   def list
+    type = options[:type]
     
     headings = ["id", "name", "state", "cycles"]
-    rows = api.flow.list.map do |row|
+    rows = api.app.list.map do |row|
       if headings.size == 0
         headings = row.keys 
         headings.delete("rel_dir")
@@ -35,137 +40,164 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
       v = row.values_at *headings
       v
     end
-    display "flows:\n" + Terminal::Table.new(:headings => headings, :rows => rows).to_s
-    display "Total number of flows: "+rows.length.to_s
+
+    display "apps:\n" if type.nil?
+    display TableOutputBuilder.build_table(headings, rows, type)
+    display "Total number of apps: "+rows.length.to_s if type.nil?
   end
 
 
-  # flows:push [DIR]
+  # apps:push [DIR]
   #
-  # uploads a flow
+  # uploads an app
   # 
   # --config CONFIG_FILE # use the given config file
+  # --type TYPE # specify an output type i.e. json
   #
   #Examples:
   #
-  # $ zillabyte flows:push . 
+  # $ zillabyte apps:push . 
   #
   def push
     
     since = Time.now.utc.to_s
     dir = options[:directory] || shift_argument || Dir.pwd
-    res = api.flows.push_directory dir, progress, options
+    type = options[:type]
+
+    res = api.apps.push_directory dir, session, options
     
     if res['error']
-      display "error: #{res['error_message']}"
+      error("error: #{res['error_message']}", type)
     else
-      display "flow ##{res['id']} #{res['action']}"
+      display "app ##{res['id']} #{res['action']}" if type.nil?
     end
 
-    display "Starting up your flow...please wait..."
+    display "Starting up your app...please wait..." if type.nil?
     sleep(2) # wait for kill command 
     
     lf = LogFormatter::Startup.new
     api.logs.get_startup(res['id'], "_ALL_", {:push => true}) do |hash|
       
       # Error?
-      error hash['error_message'] if hash['error']
+      error(hash['error_message'], type) if hash['error']
       
       # Print it
-      lf.print_log_line(hash)
+      lf.print_log_line(hash) if type.nil?
       
       # Exit when we get the 'done' message
-      # exit(0)  if (hash['line'] || '').downcase.include?("flow deployed")
+      # exit(0)  if (hash['line'] || '').downcase.include?("app deployed")
       
     end
+
+    display {}.to_json if type == "json"
       
   end
-  alias_command "push", "flows:push"
+  alias_command "push", "apps:push"
   
   
   
-  # flows:pull ID DIR
+  # apps:pull ID DIR
   #
-  # pulls a flow source to a directory.
+  # pulls an app source to a directory.
   #
   # --force # pulls even if the directory exists
+  # --type TYPE # specify an output type i.e. json
   #
   #Examples:
   #
-  # $ zillabyte flows:pull . 
+  # $ zillabyte apps:pull . 
   #
   def pull
     
     id = options[:id] || shift_argument 
     dir = options[:directory] || shift_argument
+    type = options[:type]
+
     
-    error "no id given" if id.nil?
-    error "no directory given" if dir.nil?
+    error("no id given", type) if id.nil?
+    error("no directory given", type) if dir.nil?
     
     # Create if not exists..
     if File.exists?(dir)
       if Dir.entries(dir).size != 2 and options[:force].nil?
-        error "target directory not empty. use --force to override" 
+        error("target directory not empty. use --force to override", type)
       end
     else
       FileUtils.mkdir_p(dir)
     end
     
-    res = api.flows.pull_to_directory id, dir, progress
+    res = api.apps.pull_to_directory id, dir, session
     
     if res['error']
-      display "error: #{res['error_message']}"
+      error("error: #{res['error_message']}", type)
     else
-      display "flow ##{res['id']} pulled to #{dir}"
+      if type == "json"
+        display {}.to_json
+      else
+        display "app ##{res['id']} pulled to #{dir}"
+      end
     end
     
   end
-  alias_command "pull", "flows:pull"
+  alias_command "pull", "apps:pull"
 
 
-  # flows:delete ID
+  # apps:delete ID
   #
-  # deletes a flow. if the flow is running, this command will kill it. 
+  # deletes an app. if the app is running, this command will kill it. 
   #
   # -f, --force # don't ask for confirmation
+  # --type TYPE # specify an output type i.e. json
+  #
   def delete
     id = options[:id] || shift_argument
     if id.nil?
       id = read_name_from_conf(options)
       options[:flow_name] = true
     end
-
     forced = options[:force]
+    type = options[:type]
+
     if not forced
+
+      if !type.nil?
+        error("specify -f, --force to confirm deletion", type)
+      end
+
       while true
         
-        display "This operation cannot be undone. Are you sure you want to delete this flow? (yes/no):", false
+        display "This operation cannot be undone. Are you sure you want to delete this app? (yes/no):", false
         confirm = ask
         break if confirm == "yes" || confirm == "no"
-        display "Please enter 'yes' to delete the flow or 'no' to exit"
+        display "Please enter 'yes' to delete the app or 'no' to exit"
       end
     end
 
     confirmed = forced || confirm == "yes"
 
     if confirmed
-      response = api.flows.delete(id, options)
-      display response["body"]
-
+      response = api.apps.delete(id, options)
+      if type == "json"
+        display {}.to_json
+      else
+        display response["body"]
+      end
     end
 
   end
 
   
-  # flows:prep [DIR]
+  # apps:prep [DIR]
+  #
+  # prepares an app for execution
   #
-  # prepares a flow for execution
   #
   def prep
     
     dir = options[:directory] || shift_argument || Dir.pwd
+
     meta = Zillabyte::CLI::Config.get_config_info(dir)
-    
+
     case meta["language"]
     when "ruby"
       
@@ -192,29 +224,33 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     end
     
   end
-  alias_command "prep", "flows:prep"
+  alias_command "prep", "apps:prep"
 
 
 
   
-  # flows:init [LANG] [DIR]
+  # apps:init [LANG] [DIR]
   #
   # initializes a new executable in DIR
   # [LANG] defaults to ruby, and [DIR] to the current directory
   #
+  # --type TYPE # specify an output type i.e. json
+  #
   #Examples:
   #
-  # $ zillabyte flows:init python contact_extractor
+  # $ zillabyte apps:init python contact_extractor
   #
   def init
     
     lang = options[:lang] || shift_argument || "ruby"
     dir = options[:dir] || shift_argument || Dir.pwd
+    type = options[:type]
+
     languages = ["ruby","python", "js"]
 
-    error "Unsupported language #{lang}. We only support #{languages.join(', ')}." if not languages.include? lang
+    error("Unsupported language #{lang}. We only support #{languages.join(', ')}.", type) if not languages.include? lang
 
-    display "initializing empty #{lang} flow in #{dir}"
+    display "initializing empty #{lang} app in #{dir}" if type.nil?
     FileUtils.cp_r( File.expand_path("../templates/#{lang}", __FILE__) + "/." , dir )
     
     
@@ -222,66 +258,133 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
 
 
 
-  # flows:logs FLOW_ID [OPERATION_NAME]
+  # apps:logs APP_ID [OPERATION_NAME]
   #
   # streams logs from the distributed workers
   # 
+  # --type TYPE # specify an output type i.e. json
   # -v, --verbose LEVEL  # sets the verbosity (error, info, debug) (default: info)
   #
   def logs
 
-    flow_id = options[:flow] || shift_argument
+    app_id = options[:app] || shift_argument
     operation_id = options[:operation] || shift_argument || '_ALL_'
     category = options[:verbose] || '_ALL_'
+    type = options[:type]
+
     carry_settings = {
       :category => category
     }
     api_options = {}
 
-    if flow_id.nil?
-      flow_id = read_name_from_conf(options)
-      api_options["flow_name"] = true
+    if app_id.nil?
+      app_id = read_name_from_conf(options)
+      api_options[:flow_name] = true
     end
    
-    display "Retrieving logs for flow ##{flow_id}...please wait..." 
+    display "Retrieving logs for app ##{app_id}...please wait..." if type.nil?
     lf = LogFormatter::Operation.new
-    self.api.logs.get(flow_id, operation_id, api_options) do |line|
+    self.api.logs.get(app_id, operation_id, api_options) do |line|
       
-      error line['error_message'] if line['error']
-      lf.print_log_line(line)
+      error(line['error_message'], type) if line['error']
+      lf.print_log_line(line) if type.nil?
       
     end
 
   end  
-  alias_command "logs", "flows:logs"
+  alias_command "logs", "apps:logs"
 
 
-  # flows:cycles ID [OPTIONS]
+
+  # apps:errors ID
+  #
+  # Show recent errors generated by the app
+  # --type TYPE           # specify an output type i.e. json
+  #
+  def errors
+    
+    # Init
+    app_id = options[:id] || shift_argument
+    
+    # No name?
+    if app_id.nil?
+      app_id = read_name_from_conf(options)
+      options[:flow_name] = true
+    end
+
+    type = options[:type]
+
+    # Make the request
+    res = api.request(
+      :expects => 200, 
+      :method => :get,
+      :body    => options.to_json,
+      :path => "/flows/#{CGI.escape(app_id)}/errors"
+    )
+    
+    # Render
+    display "Recent errors:" if type.nil?
+    headings = ["operation", "date", "error"]
+    rows = (res.body["recent_errors"] || []).map do |row|
+      if row['date'] 
+        d = Time.at(row['date']/1000)
+      else
+        d = nil
+      end
+      [row['name'], d, row['message']]
+    end
+    rows.sort! do |a,b|
+      a[1] <=> b[1]
+    end
+    color_map = {}
+    colors = LogFormatter::COLORS.clone
+    rows.each do |row|
+      name = row[0]
+      time = row[1]
+      message = row[2].strip
+      color_map[name] ||= colors.shift
+      if time 
+        display "#{"* #{name} - #{time_ago_in_words(time)} ago".colorize(color_map[name])}:" if type.nil?
+      else
+        display "#{"* #{name}".colorize(color_map[name])}:" if type.nil?
+      end
+      message.split('\n').each do |sub_line|
+        display "    #{sub_line}" if type.nil?
+      end
+    end
+    
+  end
+
+  # apps:cycles ID [OPTIONS]
   #  
-  # operations on the flow's cycles (batches).
-  # with no options, the command lists the flows cycles
-  # -n, --next # request the flow to move to the next cycle
-  # -f, --forever # don't wait on cycles any more
+  # operations on the app's cycles (batches).
+  # with no options, the command lists the apps cycles
+  # -n, --next            # request the app to move to the next cycle
+  # -f, --forever         # don't wait on cycles any more
+  # --type TYPE           # specify an output type i.e. json
+  #
   def cycles
-    flow_id = options[:id] || shift_argument
+    app_id = options[:id] || shift_argument
+    type = options[:type]
+
     trigger_next = options[:next] || false
     trigger_forever = options[:forever] || false
 
-    if flow_id.nil?
-      flow_id = read_name_from_conf(options)
+    if app_id.nil?
+      app_id = read_name_from_conf(options)
       options[:flow_name] = true
     end
 
     if trigger_next
-      # Trigger the next flow
-      response = api.flows.create_cycle(flow_id, options)
+      # Trigger the next app
+      response = api.apps.create_cycle(app_id, options)
     elsif trigger_forever
-      response = api.flows.run_forever(flow_id, options)
+      response = api.apps.run_forever(app_id, options)
     else
-      # List the flows
-      response = api.flows.list_cycles(flow_id, options)
-      # TODO List the sequence number for this flow.
-      display "Most recent cyles of the flow:"
+      # List the apps
+      response = api.apps.list_cycles(app_id, options)
+      # TODO List the sequence number for this app.
+      display "Most recent cyles of the app:" if type.nil?
       headings = ["Cycle_id", "State", "Start", "End"]
       rows = response["cycles"] 
       rows = rows.map do |row|
@@ -289,20 +392,57 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
         end_time = row["end"].nil? ? "---" : DateTime.parse(row["end"]).strftime("%m/%d/%Y %I:%M%p")
         [row["cycle_id"], row["state"], start_time, end_time ] #TODO Pretty print time
       end
-      display Terminal::Table.new(:headings => headings, :rows => rows).to_s
-      display "Total number of cycles executed: #{response['total']}"
+
+      display TableOutputBuilder.build_table(headings, rows, type)
+      display "Total number of cycles executed: #{response['total']}" if type.nil?
+      return
     end
-    if response["body"]
-      display  response["body"]
-    elsif  response["error"]
-      error response["error"]
+
+    if response["job_id"]
+      options[:job_id] = response["job_id"]
+      app_id = response["flow_id"]
+      options.delete :flow_name
+
+      start = Time.now.utc
+      display "Next cycle request sent. If your app was RETIRED this may take slightly longer." if type.nil?
+
+      while(Time.now.utc < start + MAX_POLL_SECONDS) do
+
+        # Poll
+        res = self.api.apps.cycles_poll(app_id, options)
+
+        case res['status']
+        when 'completed'
+          if res['return']
+            if type == "json"
+              return {}.to_json
+            else
+              display res['return']
+            end
+          else
+            throw "something is wrong: #{res}"
+          end
+          # success! continue below
+          break
+        when 'running'
+          sleep(POLL_SLEEP)
+       #   display ".", false
+        else
+          throw "unknown status: #{res}"
+        end
+
+      end
+    elsif response["error"]
+      error(response["error"], type)
+    else
+      error("remote server error (a380)", type) 
     end
   end
   
 
-  # flows:test
+  # apps:test
   #
-  # tests a local flow with sample data
+  # tests a local app with sample data
   # 
   # --config CONFIG_FILE  # use the given config file
   # --output OUTPUT_FILE  # writes sink output to a file
@@ -312,6 +452,8 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
   def test
     
     output = options[:output]
+    type = options[:type]
+
     max_seconds = (options[:wait] || "30").to_i
     batches = (options[:batches] || "1").to_i
 
@@ -364,33 +506,34 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     # INIT
     dir = options[:dir] || Dir.pwd
 
-    meta = Zillabyte::API::Flows.get_rich_meta_info_from_script(dir, self, {:test => true})
+    meta = Zillabyte::API::Apps.get_rich_meta_info_from_script(dir, self, {:test => true})
     if meta.nil?
-      error "this is not a valid zillabyte flow directory"
+      error "this is not a valid zillabyte app directory"
       exit
     end    
 
-    # Show the user what we know about their flow... 
-    display "inferring your flow details..."
+    # Show the user what we know about their app... 
+    display "inferring your app details..."
     colors = {}
-    describe_flow(meta, colors)
+    describe_app(meta, colors)
 
     
-    # Extract the flow's information.. 
+    # Extract the app's information.. 
     nodes = meta["nodes"]
     write_to_next_each = []
     write_queue = []
     stream_messages = {}
     default_stream = "_default"
     
-    split_branches = false
-    
     # Iterate all nodes sequentially and invoke them in separate processes... 
     nodes.each do |node|
 
       # Init 
       type = node["type"]
       name = node["name"]
+      consumes = node["consumes"]
+      emits = node["emits"]
+
       color = colors[name] || :default
       
       op_display = lambda do |msg, override_color = nil|
@@ -403,6 +546,7 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
         # A source from relation? 
         if node['matches'] or node["relation"]
           matches = node['matches'] || (node["relation"]["query"])
+          emits = emits.first #For spouting from a relation, there should only be one emits
           op_display.call "Grabbing remote data"
           
           res = api.query.agnostic(matches)
@@ -427,9 +571,9 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
             end
             read_msg = {"tuple" => values, "meta" => meta, "column_aliases" => column_aliases}.to_json
             values = Hash[values.map{|k, v| [truncate_message(k), truncate_message(v)]}]
-            op_display.call "emit tuple: #{values} #{meta}"
-            stream_messages[default_stream] ||= []
-            stream_messages[default_stream] << read_msg
+            op_display.call "emitted: #{values} #{meta} to #{emits}"
+            stream_messages[emits] ||= []
+            stream_messages[emits] << read_msg
           end
           
           # Done processing... 
@@ -439,10 +583,14 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
           
           # A regular source.. 
           stream_messages[default_stream] ||= []
-          batches.times do |i|
-            stream_messages[default_stream] << "{\"command\": \"next\"}\n"
-          end
-          
+          stream_messages[default_stream] << "{\"command\": \"begin_cycle\"}\n"
+          emits.each {|ss| stream_messages[ss] = []} #initialize streams
+          stream_size_at_last_call_to_next_tuple = Hash[emits.map {|ss| [ss, 0]}] #initialize initial size of streams (all 0)
+            # the above initializations are used to deal with the case where end_cycle_policy == "null_emit"
+          n_batches_emitted = 1
+          end_cycle_received = false
+          last_call_next_tuple = false
+ 
         end
 
       # An Aggregate?  
@@ -488,16 +636,10 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
       # A Sink? 
       elsif type == "sink"
        
-        if split_branches || stream_messages.size > 1
-          split_branches = true
-          if node['consumes'].nil?
-            error "The node #{name} must declare which stream it 'consumes'"
-          end
-          sink_stream = node["consumes"]
-          messages = stream_messages[sink_stream] || []
-        else
-          messages = stream_messages.values.first || []
+        if consumes.nil?
+          error "The node #{name} must declare which stream it 'consumes'"
         end
+        messages = stream_messages[consumes] || []
         
         table = Terminal::Table.new :title => name
         csv_str = CSV.generate do |csv|
@@ -529,8 +671,6 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
           op_display.call "output written to #{filename}"
         end
         
-        
-        
         next
       end
       
@@ -548,28 +688,32 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
             write_queue = []
             read_queue = []
           
-            # Get the incoming stream 
-            if !split_branches && stream_messages.size == 1  # i.e. the number of streams we're dealing with right now
-              # Assume default stream 
-              stream_name = stream_messages.keys.first
-              write_queue = stream_messages.values.first.clone
-              stream_messages.delete(stream_name)
+            if consumes.nil?
+              # Assume default stream (this should only happen for the source)
+              stream_name = default_stream
             else
-              # Multiple streams...
-              split_branches = true;
-              if node['consumes'].nil?
-                error "The node #{name} must declare which stream it 'consumes'"
-              end
-              stream_name = node["consumes"]
-              write_queue = stream_messages[stream_name].clone()
-              stream_messages.delete(stream_name)
+              stream_name = consumes
             end
+            write_queue = stream_messages[stream_name].clone
+            stream_messages.delete(stream_name)
           
             # Start writing the messages... 
             stuff_to_read = false
             writing_thread = Thread.start do 
-              until(write_queue.empty?)
-                
+
+              while(true)
+
+                case type
+                when 'source'
+                  break if n_batches_emitted > batches
+                  if write_queue.empty?
+                    sleep 0.5
+                    next
+                  end
+                else
+                  break if write_queue.empty?
+                end
+
                 # Make sure we're not reading anything... 
                 while(stuff_to_read)   # TODO: semaphores
                   sleep 0.5 # spin wait
@@ -584,7 +728,8 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
                   display_hash = Hash[write_json['tuple'].map{|k, v| [truncate_message(k), truncate_message(v)]}]
                   op_display.call "receiving: #{display_hash}"
                 elsif write_json['command'] == 'next'
-                  op_display.call "starting next source batch"
+                  last_call_next_tuple = true
+                  op_display.call "getting next set of tuples in the batch"
                 else
                   puts write_json
                 end
@@ -605,10 +750,43 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
             reading_thread = Thread.start do 
               while(true)
 
+                # If the end cycle command is received, we either trigger the next cycle if the number of emitted
+                # cycles is less than what the user requested, or we break
+                if type == "source" and end_cycle_received
+                  write_queue << "{\"command\": \"begin_cycle\"}\n"
+                  n_batches_emitted += 1
+                  end_cycle_received = false
+                  last_call_next_tuple = false
+                  stuff_to_read = false
+                  break if n_batches_emitted > batches
+                  sleep 0.5
+                  next
+                end
+
                 # Get next message
                 read_msg = read_message(stdout, color)
                 if read_msg == "done" || read_msg.nil?
                   stuff_to_read = false
+
+                  # For sources, if we receive a "done", check to see if any of the streams emitted by the source has
+                  # increased in size since the last call to next_tuple. If so, the cycle isn't over, otherwise, the
+                  # current call to next_tuple emitted nothing and if the end_cycle_policy is set to null_emit, this
+                  # should end the current cycle.
+                  if type == "source"
+                    if last_call_next_tuple and node["end_cycle_policy"] == "null_emit"
+                      end_cycle_received = true
+                      emits.each do |ss|
+                        end_cycle_received = false if stream_messages[ss].size > stream_size_at_last_call_to_next_tuple[ss]
+                        break
+                      end
+                      next if end_cycle_received
+                    end 
+
+                    # If the policy isn't "null_emit", then just request next_tuple again
+                    write_queue << "{\"command\": \"next\"}\n"
+                  end
+  
+                  # For other operations, if the queue is empty then we're done
                   if write_queue.empty?
                     break  # exit while loop
                   else
@@ -620,20 +798,49 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
                 
                 # Process message
                 obj = JSON.parse(read_msg)
+   
+                # process the received tuple or other commands
                 if obj['tuple']
-                  
-                  # Conver to a incoming tuple for the next operation
+                 
+                  # if 
+                  tt = obj['tuple']
+                  tt.each do |kk, vv|
+                    if tt[kk].nil? and type == "source" and node["end_cycle_policy"] == "null_emit"
+                      end_cycle_received = true
+                      # read rest of stuff in stdout buffer until "done"
+                      mm = nil
+                      while(mm != "done")
+                        mm = read_message(stdout, color)
+                      end
+                      break
+                    end
+                  end
+                  next if end_cycle_received
+                    
+                  # Convert to a incoming tuple for the next operation
                   next_msg = {
                     :tuple => obj['tuple'],
                     :meta => obj['meta']
                   }
-                  emit_stream = obj['stream'] || default_stream
+                  emit_stream = obj['stream']
                   stream_messages[emit_stream] ||= []
                   stream_messages[emit_stream] << next_msg.to_json
+
                   display_hash = Hash[obj['tuple'].map{|k, v| [truncate_message(k), truncate_message(v)]}]
                   op_display.call "emitted: #{display_hash} to #{emit_stream}"
+
+                  # track stream message size to end cycles when necessary
+                  stream_size_at_last_call_to_next_tuple[emit_stream] = stream_messages[emit_stream].size if type == "source"
+                elsif obj['command'] == 'end_cycle'
+                  end_cycle_received = true
+                  # command:end_cycle should always be followed by done, read it (below) so 
+                  # that it doesn't interfere with next
+                  read_message(stdout, color)
                 elsif obj['command'] == 'log'
                   op_display.call "log: #{obj['msg']}"
+                elsif obj['command'] == 'fail'
+                  op_display.call "error: #{obj['msg']}", :red
+                  exit(1)
                 else
                   error "unknown message: #{read_msg}"
                 end
@@ -641,7 +848,6 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
               end
             end
             
-            
             # stderr thread 
             stderr_thread = Thread.start do 
               stderr.each do |line|
@@ -670,60 +876,61 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
         end
       rescue PTY::ChildExited
         puts "The child process exited!"
-      ensure
-        # We need to check here to see if we need to turn on multistream mode.
-        # Note that we still need the redundant checks above, in case the user
-        # didn't honor the emits contract.
-        if node["emits"] && node["emits"].size() > 1
-          split_branches = true
-        end
       end
     end
     
   end  
-  alias_command "test", "flows:test"
+  alias_command "test", "apps:test"
   
   
-  # flows:kill ID
+  # apps:kill ID
   #
-  # kills the given flow
+  # kills the given app
   # 
   # --config CONFIG_FILE # use the given config file
+  # --type TYPE # specify an output type i.e. json
   #
   def kill
 
     id = options[:id] || shift_argument
+    type = options[:type]
+
     if id.nil?
       id = read_name_from_conf(options)
       options[:flow_name] = true
     end
 
-    display "Killing flow ##{id}...please wait..."
-    api.flows.kill(id, options)
-    display "Flow ##{id} killed"
-   
-  end  
-  
-  
-  
+    display "Killing app ##{id}...please wait..." if type.nil?
+    api.apps.kill(id, options)
 
+    if type == "json"
+      display {}.to_json
+    else
+      display "App ##{id} killed"
+    end
 
+  end
   
-  # flows:live_run [OPERATION_NAME] [PIPE_NAME] [DIR]
+
+  # apps:live_run [OPERATION_NAME] [PIPE_NAME] [DIR]
   #
-  # runs a local flow with live data
+  # runs a local app with live data
   # 
   # --config CONFIG_FILE # use the given config file
+  # --type TYPE # specify an output type i.e. json
+  #
   # HIDDEN:
   def live_run
 
     name = options[:name] || shift_argument
+    type = options[:type]
+
     thread_id = options[:thread] || shift_argument || ""
     dir = options[:directory] || shift_argument || Dir.pwd
     meta = Zillabyte::CLI::Config.get_config_info(dir)
   
     if meta.nil?
-      throw "could not find meta information for: #{dir}"
+      error("could not find meta information for: #{dir}", type)
     end
    
     if(thread_id == "")
@@ -732,73 +939,91 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
       exec(command("--execute_live --name #{name.to_s} --pipe #{thread_id}"))
     end
   end  
-  alias_command "live_run", "flows:live_run"
+  alias_command "live_run", "apps:live_run"
   
   
-  # flows:info [DIR]
+  # apps:info [DIR]
   # 
-  # outputs the info for the flow in the dir.
+  # outputs the info for the app in the dir.
   # 
   # --pretty # Pretty prints the info output
+  # --type TYPE # specify an output type i.e. json
   # 
   def info
     info_file = SecureRandom.uuid
+    type = options[:type]
+
     cmd = command("--info --file #{info_file}")
-    flow_info = Zillabyte::Command::Flows.get_info(cmd, info_file)
+    app_info = Zillabyte::Command::Apps.get_info(cmd, info_file)
 
-    if options[:pretty]
-      puts JSON.pretty_generate(JSON.parse(flow_info))
+    if type == "json"
+      puts app.info
     else
-      puts flow_info
+      if options[:pretty]
+        puts JSON.pretty_generate(JSON.parse(app_info))
+      else
+        puts app_info
+      end
     end
+
     exit
   end
-  alias_command "info", "flows:info"
+  alias_command "info", "apps:info"
 
 
+  #
+  # --type TYPE # specify an output type i.e. json
+  #
   def self.get_info(cmd, info_file, options = {})
+    type = options[:type]
     response = `#{cmd}`
     if($?.exitstatus == 1)
       File.delete("#{info_file}") if File.exists?(info_file)
-      puts "error: #{response}" if options[:test]
-      Process.exit 1
+      if options[:type].nil?
+        exit(1)
+      else
+        Zillabyte::Helpers.error("error: #{response}", type)
+      end
     end
 
-    flow_info = {}
+    app_info = {}
     File.open("#{info_file}", "r+").each do |line|
       line = JSON.parse(line)
       if(line["type"])
-        flow_info["nodes"] << line
+        app_info["nodes"] << line
       else
-        flow_info = line
-        flow_info["nodes"] = []
+        app_info = line
+        app_info["nodes"] = []
       end
     end
     File.delete("#{info_file}")
 
-    flow_info = flow_info.to_json
+    app_info = app_info.to_json
     if(File.exists?("info_to_java.in"))
       java_pipe = open("info_to_java.in","w+")
-      java_pipe.puts(flow_info+"\n")
+      java_pipe.puts(app_info+"\n")
       java_pipe.flush
       java_pipe.close()
     end
 
-    flow_info
+    app_info
   end
 
 
   private 
   
-
-  
+  #
+  #
+  # --type TYPE # specify an output type i.e. json
+  #
   def command(arg="--execute_live", ignore_stderr = false)
 
     dir = options[:directory] || shift_argument || Dir.pwd
-    meta = Zillabyte::CLI::Config.get_config_info(dir, progress=nil, options)
+    type = options[:type]
+    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?" if meta.nil? 
-    error meta["error_message"] if meta['status'] == "error"
+    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
 
@@ -819,19 +1044,21 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
       cmd = "cd \"#{dir}\"; NODE_PATH=~/zb1/multilang/js/src/lib #{Zillabyte::API::NODEJS_BIN}  \"#{full_script}\" #{arg} #{stderr_opt}"
 
     else
-      error "no language specified"
+      error("no language specified", type)
     end
     
     return cmd
 
   end
   
-  
-  def describe_flow(meta, colors = {})
+  #
+  #
+  #
+  def describe_app(meta, colors = {})
     @colors ||= [:green, :yellow, :magenta, :cyan, :light_black, :light_green, :light_yellow, :light_blue, :light_magenta, :light_cyan]
     rjust = 20
-    display "#{'flow name'.rjust(rjust)}: #{meta['name']}"
-    display "#{'flow language'.rjust(rjust)}: #{meta['language']}"
+    display "#{'app name'.rjust(rjust)}: #{meta['name']}"
+    display "#{'app language'.rjust(rjust)}: #{meta['language']}"
     
     meta['nodes'].each_with_index do |node, index|
       colors[node['name']] ||= @colors.shift
@@ -845,9 +1072,12 @@ class Zillabyte::Command::Flows < Zillabyte::Command::Base
     
   end
 
+  #
+  #
   def read_name_from_conf(options = {})
-    hash = Zillabyte::API::Flows.get_rich_meta_info_from_script 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." if hash["error"]
+    type = options[:type]
+    hash = Zillabyte::API::Apps.get_rich_meta_info_from_script Dir.pwd, options
+    error("No id given and current directory does not contain a valid Zillabyte configuration file. Please specify an app id or run command from the directory containing the app.",type) if hash["error"]
     hash["name"]
   end