pytty 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd905d25dba15816b22209e67dfd888c3379e3f0ef01d18611b86c21e49a6666
-  data.tar.gz: 7b215e1046ea4a67b3bc619ccb6603ba8f540a8473a6060b6f47d9921187296e
+  metadata.gz: 449a17a0c2d92d72ceddac8091af43e21e16d730d063458b58411385cd659fa2
+  data.tar.gz: db5e5b5446c3d18b16d886fcd5409380fcd49ed1f6d120bdc7f29f3e6740146a
 SHA512:
-  metadata.gz: 19c80222d3401ca8e1b84878cba3a2fd9f858de56382388104533a03a9ec88ac8cb83594984218273467b8c83e9f94c640b28985462b1f54e76a1fda562dded9
-  data.tar.gz: 1056958148e94f81ba23f50970e4fc399300fc93fe2854518f3a551f46b1128c61da8a9166fab9349bb6ebaa67bfa66b1eb46e64c10ee9c71e5aca0320a58e76
+  metadata.gz: cc1f6302b922e313c85327d3348d116905d2f889260695f680c946eedcc769c84bf510a3b0439ed499e3f8528f2c8c8bde89cce0a5bb2e29a600ab04987a7631
+  data.tar.gz: 59553a444c16d811403ce3e288aaf44d454ed1bb100896b4b6a30645664554b6004dfc8e748ee66d81227ce7792a1a43c4c58d6d63a549f43a2ea45b879e2811

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pytty (0.3.0)
+    pytty (0.4.0)
       async-websocket
       clamp (~> 1.3)
       falcon
@@ -10,7 +10,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    async (1.12.0)
+    async (1.13.0)
       nio4r (~> 2.3)
       timers (~> 4.1)
     async-container (0.8.1)
@@ -62,7 +62,6 @@ GEM
     http-hpack (0.1.1)
     http-protocol (0.10.1)
       http-hpack (~> 0.1.0)
-    kommando (0.1.2)
     listen (3.1.5)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
@@ -121,7 +120,6 @@ DEPENDENCIES
   guard-bundler
   guard-process
   guard-rspec
-  kommando
   pytty!
   rake (~> 10.0)
   rspec (~> 3.0)

data/README.md

@@ -1 +1,3 @@
 # pytty
+
+Process Yield TTY

data/build/linux-debian-deps.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env sh
+set -e
+
+apt-get update && apt-get install -y squashfs-tools build-essential bison curl
+
+curl -L https://github.com/kontena/ruby-packer/releases/download/0.5.0%2Bextra7/rubyc-0.5.0+extra7-linux-amd64.gz | gunzip > /usr/local/bin/rubyc
+chmod +x /usr/local/bin/rubyc

data/build/linux.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env sh
+set -e
+
+version=${TRAVIS_TAG#"v"}
+package="tmp/pyttyd-linux-amd64-${version}"
+rubyc -o "$package" -d /tmp/pytty-build --make-args="-j16 --silent" pyttyd
+./"$package" --version

data/build/macos-deps.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env sh
+set -e
+
+export HOMEBREW_NO_AUTO_UPDATE=1
+brew install squashfs || brew upgrade squashfs || true
+brew install openssl || brew upgrade openssl || true
+
+curl -sL https://curl.haxx.se/ca/cacert.pem > /usr/local/etc/openssl/cacert.pem
+
+curl -sL https://dl.bintray.com/kontena/ruby-packer/0.5.0-dev/rubyc-0.5.0-extra2-darwin-amd64.gz | gunzip > /usr/local/bin/rubyc
+chmod +x /usr/local/bin/rubyc

data/build/macos.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+set -ue
+
+version=${TRAVIS_TAG#"v"}
+package="tmp/pyttyd-darwin-amd64-${version}"
+
+rubyc --openssl-dir=/usr/local/etc/openssl -o "$package" -d /tmp/pytty-build-macos --make-args="-j16 --silent" pyttyd
+./"$package" --version

data/lib/pytty/client.rb

@@ -2,6 +2,13 @@
 
 module Pytty
   module Client
+    def self.host_url
+      if ENV["PYTTY_HOST"]
+        ENV["PYTTY_HOST"]
+      else
+        "http://localhost:1234"
+      end
+    end
   end
 end
 

data/lib/pytty/client/api.rb

@@ -2,3 +2,5 @@ require_relative "api/ps"
 require_relative "api/yield"
 require_relative "api/attach"
 require_relative "api/spawn"
+require_relative "api/stdout"
+require_relative "api/signal"

data/lib/pytty/client/api/attach.rb

@@ -2,8 +2,8 @@ module Pytty
   module Client
     module Api
       class Attach
-        def self.run(id:)
-          Async::Task.current.async do |stdin_task|
+        def self.run(id:, interactive:)
+          stdin_task = Async::Task.current.async do
             internet = Async::HTTP::Internet.new
             headers = [['accept', 'application/json']]
             body = {}.to_json
@@ -17,27 +17,35 @@ module Pytty
             stdin_body = {
               c: "\f"
             }.to_json
-            response = internet.post("http://localhost:1234/v1/stdin/#{id}", headers, [stdin_body])
+            response = internet.post("#{Pytty::Client.host_url}/v1/stdin/#{id}", headers, [stdin_body])
 
             detach_sequence_started = false
             while c = async_stdin.read(1) do
+              detach = false
               case c
               when "\x10"
                 detach_sequence_started = true
                 next
               when "\x11"
-                if detach_sequence_started
-                  detach_sequence_started = false
-                  exit 0
-                end
+                detach = true if detach_sequence_started
+              when "\x03"
+                detach = true unless interactive
+              end
+
+              if detach
+                puts ""
+                puts "detached.\r"
+                exit 0
               end
 
               detach_sequence_started = false
 
-              stdin_body = {
-                c: c
-              }.to_json
-              response = internet.post("http://localhost:1234/v1/stdin/#{id}", headers, [stdin_body])
+              if interactive
+                stdin_body = {
+                  c: c
+                }.to_json
+                response = internet.post("#{Pytty::Client.host_url}/v1/stdin/#{id}", headers, [stdin_body])
+              end
             end
           end
 
@@ -46,12 +54,15 @@ module Pytty
             headers = [['accept', 'application/json']]
             body = {}.to_json
 
-            response = internet.post("http://localhost:1234/v1/attach/#{id}", headers, [body])
+            response = internet.post("#{Pytty::Client.host_url}/v1/attach/#{id}", headers, [body])
             response.body.each do |c|
               print c
             end
           rescue Async::Wrapper::Cancelled => ex
+            p ["rescued", ex]
           ensure
+            stdin_task.stop
+
             internet.close
           end
         end

data/lib/pytty/client/api/ps.rb

@@ -7,7 +7,7 @@ module Pytty
           headers = [['accept', 'application/json']]
           body = {}.to_json
 
-          response = internet.post("http://localhost:1234/v1/ps", headers, [body])
+          response = internet.post("#{Pytty::Client.host_url}/v1/ps", headers, [body])
           JSON.parse(response.body.read)
         ensure
           internet.close

data/lib/pytty/client/api/signal.rb

@@ -0,0 +1,20 @@
+module Pytty
+  module Client
+    module Api
+      class Signal
+        def self.run(id:, signal:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {
+            signal: signal
+          }.to_json
+
+          response = internet.post("#{Pytty::Client.host_url}/v1/signal/#{id}", headers, [body])
+          [response, JSON.parse(response.read)]
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/api/spawn.rb

@@ -10,8 +10,8 @@ module Pytty
             interactive: interactive
           }.to_json
 
-          response = internet.post("http://localhost:1234/v1/spawn/#{id}", headers, [body])
-          JSON.parse(response.read)
+          response = internet.post("#{Pytty::Client.host_url}/v1/spawn/#{id}", headers, [body])
+          [response, JSON.parse(response.read)]
         ensure
           internet.close
         end

data/lib/pytty/client/api/stdout.rb

@@ -0,0 +1,19 @@
+module Pytty
+  module Client
+    module Api
+      class Stdout
+        def self.run(id:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {
+          }.to_json
+
+          response = internet.post("#{Pytty::Client.host_url}/v1/stdout/#{id}", headers, [body])
+          puts response.read
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/api/yield.rb

@@ -2,7 +2,7 @@ module Pytty
   module Client
     module Api
       class Yield
-        def self.run(cmd:, env:)
+        def self.run(cmd:, id:, env:)
           internet = Async::HTTP::Internet.new
           headers = [['accept', 'application/json']]
 
@@ -12,11 +12,12 @@ module Pytty
           }.merge env
 
           body = {
+            id: id,
             cmd: cmd,
             env: term_env
           }.to_json
 
-          response = internet.post("http://localhost:1234/v1/yield", headers, [body])
+          response = internet.post("#{Pytty::Client.host_url}/v1/yield", headers, [body])
           JSON.parse(response.body.read)
         end
       end

data/lib/pytty/client/cli.rb

@@ -10,5 +10,6 @@ require_relative "cli/rm_command"
 require_relative "cli/spawn_command"
 require_relative "cli/signal_command"
 require_relative "cli/attach_command"
+require_relative "cli/stdout_command"
 
 require_relative "cli/root_command"

data/lib/pytty/client/cli/attach_command.rb

@@ -9,10 +9,11 @@ module Pytty
     module Cli
       class AttachCommand < Clamp::Command
         parameter "ID", "id"
+        option ["-i","--interactive"], :flag, "interactive"
 
         def execute
           Async.run do
-            Pytty::Client::Api::Attach.run id: id
+            Pytty::Client::Api::Attach.run id: id, interactive: interactive?
           end
         end
       end

data/lib/pytty/client/cli/kill_command.rb

@@ -14,10 +14,12 @@ module Pytty
           Async.run do
             internet = Async::HTTP::Internet.new
             headers = [['accept', 'application/json']]
-            body = {}.to_json
+            body = {
+              signal: "KILL"
+            }.to_json
 
             for id in id_list do
-              response = internet.post("http://localhost:1234/v1/kill/#{id}", headers, [body])
+              response = internet.post("#{Pytty::Client.host_url}/v1/signal/#{id}", headers, [body])
               puts response.read
             end
           ensure

data/lib/pytty/client/cli/ps_command.rb

@@ -11,17 +11,18 @@ module Pytty
         option ["-q","--quiet"], :flag, "quiet"
 
         def execute
-          process_yields = Async.run do
+          process_yield_jsons = Async.run do
             Pytty::Client::Api::Ps.run
           end.wait
 
           unless quiet?
-            puts "id  cmd"
+            puts "id\trunning\tcmd"
             puts "-"*40
           end
-          for process_yield in process_yields do
+          for process_yield_json in process_yield_jsons do
+            process_yield = Pytty::Client::ProcessYield.from_json process_yield_json
             if quiet?
-              puts process_yield.fetch "id"
+              puts process_yield.id
             else
               puts process_yield
             end

data/lib/pytty/client/cli/rm_command.rb

@@ -29,8 +29,13 @@ module Pytty
             body = {}.to_json
 
             for id in ids do
-              response = internet.post("http://localhost:1234/v1/rm/#{id}", headers, [body])
-              puts id
+              response = internet.post("#{Pytty::Client.host_url}/v1/rm/#{id}", headers, [body])
+              if response.status == 200
+                puts id
+              else
+                puts response.read
+                exit 1
+              end
             end
           ensure
             internet.close

data/lib/pytty/client/cli/root_command.rb

@@ -21,6 +21,7 @@ module Pytty
         subcommand ["spawn"], "spawn", SpawnCommand
         subcommand ["signal"], "signal", SignalCommand
         subcommand ["attach"], "attach", AttachCommand
+        subcommand ["stdout"], "stdout", StdoutCommand
 
         def self.run
           super

data/lib/pytty/client/cli/run_command.rb

@@ -12,17 +12,22 @@ module Pytty
         option ["-i","--interactive"], :flag, "interactive"
         option ["-t","--tty"], :flag, "tty"
         option ["-d","--detach"], :flag, "detach"
+        option ["--name"], "name", "name"
 
         def execute
-          Async.run do
-            json = Pytty::Client::Api::Yield.run cmd: cmd_list, env: {}
+          Async.run do |task|
+            json = Pytty::Client::Api::Yield.run id: name, cmd: cmd_list, env: {}
             process_yield = Pytty::Client::ProcessYield.from_json json
+            unless detach?
+              task.async do
+                process_yield.attach interactive: interactive?
+              end
+            end
+
             process_yield.spawn tty: tty?, interactive: interactive?
 
             if detach?
               puts process_yield.id
-            else
-              process_yield.attach
             end
           end
         end

data/lib/pytty/client/cli/signal_command.rb

@@ -13,17 +13,14 @@ module Pytty
 
         def execute
           Async.run do
-            internet = Async::HTTP::Internet.new
-            headers = [['accept', 'application/json']]
-            body = {}.to_json
-
             for id in id_list do
-              #TODO /v1/process/:id/signal ?
-              response = internet.post("http://localhost:1234/v1/signal/#{signal}/#{id}", headers, [body])
-              p response.read
+              response, body = Pytty::Client::Api::Signal.run id: id, signal: signal
+              if response.status == 200
+                puts id
+              else
+                puts body
+              end
             end
-          ensure
-            internet.close
           end
         end
       end

data/lib/pytty/client/cli/spawn_command.rb

@@ -13,7 +13,13 @@ module Pytty
         def execute
           Async.run do
             for id in id_list
-              Pytty::Client::Api::Spawn.run id: id
+              response, body = Pytty::Client::Api::Spawn.run id: id, tty:true, interactive:true
+              unless response.status == 200
+                puts body
+                exit 1
+              else
+                puts id
+              end
             end
           end
         end

data/lib/pytty/client/cli/stdout_command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class StdoutCommand < Clamp::Command
+        parameter "ID", "id"
+
+        def execute
+          Async.run do
+            Pytty::Client::Api::Stdout.run id: id
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/client/cli/yield_command.rb

@@ -9,19 +9,15 @@ module Pytty
     module Cli
       class YieldCommand < Clamp::Command
         parameter "CMD ...", "command"
-        option ["-q", "--quiet"], :flag, "quiet"
+        option ["--name"], "NAME", "name"
 
         def execute
           process_yield = Async.run do
-            json = Pytty::Client::Api::Yield.run cmd: cmd_list, env: {}
+            json = Pytty::Client::Api::Yield.run cmd: cmd_list, id: name, env: {}
             ::Pytty::Client::ProcessYield.from_json json
           end.wait
 
-          if quiet?
-            puts process_yield.id
-          else
-            puts process_yield
-          end
+          puts process_yield.id
         end
       end
     end

data/lib/pytty/client/process_yield.rb

@@ -18,17 +18,23 @@ module Pytty
           pid: json.fetch("pid")
         })
       end
-
+      def running?
+        !@pid.nil?
+      end
       def to_s
-        "#{@id} #{@cmd}"
+        fields = []
+        fields << @id
+        fields << running?
+        fields << @cmd.join(" ")
+        fields.join("\t")
       end
 
       def spawn(tty:, interactive:)
         Pytty::Client::Api::Spawn.run id: @id, tty: tty, interactive: interactive
       end
 
-      def attach
-        Pytty::Client::Api::Attach.run id: @id
+      def attach(interactive:)
+        Pytty::Client::Api::Attach.run id: @id, interactive: interactive
       end
     end
   end

data/lib/pytty/daemon.rb

@@ -28,8 +28,12 @@ module Pytty
 
     end
 
+    def self.pytty_path
+      File.join Dir.home, ".pytty"
+    end
+
     def self.yields_json
-      File.join(Dir.home,".pytty","yields.json")
+      File.join(pytty_path,"yields.json")
     end
   end
 end

data/lib/pytty/daemon/api/router.rb

@@ -15,26 +15,34 @@ module Pytty
           end
 
           resp = case params["component"]
-          when "stdin"
-            c = body["c"]
-            Pytty::Daemon.yields[params["id"]].stdin.enqueue c
-            [200, {"Content-Type" => "text/html"}, ["ok"]]
-          when "stream"
-            if env["HTTP_UPGRADE"] == "websocket"
-              handler = Pytty::Daemon::Components::WebSocketHandler.new(env)
-              handler.handle
+          when "stdout"
+            process_yield = Pytty::Daemon.yields[params["id"]]
+            return [404, {'content-type' => 'text/html; charset=utf-8'}, ["does not exist"]] unless process_yield
+
+            body = Async::HTTP::Body::Writable.new
+
+            begin
+              our_stdout = process_yield.stdout.dup
+              while c = our_stdout.read
+                body.write c
+              end
+            rescue Exception => ex
+              p ex
+            ensure
+              puts "closing body"
+              body.close
             end
 
-            [404, {"Content-Type" => "text/html"}, ["websocket only"]]
+            [200, {'content-type' => 'text/html; charset=utf-8'}, body]
           when "attach"
-            task = Async::Task.current
+            process_yield = Pytty::Daemon.yields[params["id"]]
             body = Async::HTTP::Body::Writable.new
 
-            task.async do |task|
-              Pytty::Daemon.yields[params["id"]].stdouts << body
-              loop do
-                task.sleep 0.1
-              end
+            Async::Task.current.async do |task|
+              notification = process_yield.add_stdout body
+              p ["blocking", notification]
+              notification.wait
+              p "got notification"
             rescue Exception => ex
               p ex
             ensure
@@ -43,8 +51,11 @@ module Pytty
             end
 
             [200, {'content-type' => 'text/html; charset=utf-8'}, body]
-          when "run","yield","ps","rm","kill","spawn","signal"
-            status, output = Pytty::Daemon::Components::Handler.handle component: params["component"], id: params["id"], params: body
+          when "ps","yield"
+            status, output = Pytty::Daemon::Components::Handler.handle component: params["component"], params: body
+            [status, {"Content-Type" => "application/json"}, [output.to_json]]
+          when "spawn","rm","signal","stdin"
+            status, output = Pytty::Daemon::Components::YieldHandler.handle component: params["component"], id: params["id"], params: body
             [status, {"Content-Type" => "application/json"}, [output.to_json]]
           when "ws"
             if env["HTTP_UPGRADE"] == "websocket"

data/lib/pytty/daemon/cli/root_command.rb

@@ -15,7 +15,11 @@ module Pytty
         subcommand ["serve"], "serve", ServeCommand
 
         def self.run
-          super
+          if ARGV.size == 0
+            ServeCommand.run
+          else
+            super
+          end
         rescue StandardError => exc
           warn exc.message
           warn exc.backtrace.join("\n")

data/lib/pytty/daemon/cli/serve_command.rb

@@ -5,23 +5,24 @@ module Pytty
   module Daemon
     module Cli
       class ServeCommand < Clamp::Command
-        option ["--url"], "URL", "url"
-
         def execute
           puts "🚽 pyttyd #{Pytty::VERSION}"
 
           url_parts = ["http://"]
-          url_parts << if bind = ENV.get("PYTTY_BIND")
-            bind
+          url_parts << if ENV["PYTTY_BIND"]
+            ENV["PYTTY_BIND"]
           else
             "127.0.0.1"
           end
-          url_parts << if port = ENV.get("PYTTY_PORT")
-            if port == "PORT"
+          url_parts << ":"
+          url_parts << if ENV["PYTTY_PORT"]
+            if ENV["PYTTY_PORT"] == "PORT"
               ENV.fetch "PORT"
             else
-              "1234"
+              ENV["PYTTY_PORT"]
             end
+          else
+            "1234"
           end
 
           Async::Reactor.run do

data/lib/pytty/daemon/components.rb

@@ -1,7 +1,3 @@
 
-require_relative "components/run"
-require_relative "components/stream"
-
-require_relative "components/http_handler"
-require_relative "components/web_socket_handler"
 require_relative "components/handler"
+require_relative "components/yield_handler"

data/lib/pytty/daemon/components/handler.rb

@@ -1,28 +1,11 @@
 # frozen_string_literal: true
-require "rack/request"
-require "mustermann"
 
 module Pytty
   module Daemon
     module Components
       module Handler
-        def self.handle(component:, id:, params:)
+        def self.handle(component:, params:)
           return case component
-          when "signal"
-            process_yield = Pytty::Daemon.yields[id]
-            return [404, "not found"] unless process_yield
-            return [500, "not running"] unless process_yield.running?
-            p params
-            process_yield.signal params["signal"]
-            [200, "ok"]
-          when "spawn"
-            process_yield = Pytty::Daemon.yields[id]
-            return [404, "not found"] unless process_yield
-
-            process_yield.spawn
-            Pytty::Daemon.dump
-
-            [200, "ok"]
           when "ps"
             output = []
             Pytty::Daemon.yields.each do |id, process_yield|
@@ -32,33 +15,12 @@ module Pytty
           when "yield"
             cmd = params.dig "cmd"
             env = params.dig "env"
-            process_yield = Pytty::Daemon::ProcessYield.new cmd, env: env
-            Pytty::Daemon.yields[process_yield.id] = process_yield
-            Pytty::Daemon.dump
+            id = params.dig "id"
 
-            [200, process_yield]
-          when "rm"
-            process_yield = Pytty::Daemon.yields[id]
-            p Pytty::Daemon.yields
-            p id
-            return [404, "not found"] unless process_yield
-            if process_yield.running?
-              process_yield.kill
-            end
-            Pytty::Daemon.yields.delete process_yield.id
+            process_yield = Pytty::Daemon::ProcessYield.new cmd, id: id, env: env
+            Pytty::Daemon.yields[process_yield.id] = process_yield
             Pytty::Daemon.dump
 
-            [200, nil]
-          when "spawn"
-            process_yield = Pytty::Daemon.yields[id]
-            return [404, "not found"] unless process_yield
-
-            pipe = IO.pipe
-            stderr_reader = Async::IO::Generic.new(pipe.first)
-            stderr_writer = Async::IO::Generic.new(pipe.last)
-
-            process_yield.spawn stdout: $stdout, stderr: stderr_writer, stdin: $stdin
-            stderr_reader.close
             [200, process_yield]
           else
             raise "unknown: #{component}"

data/lib/pytty/daemon/components/yield_handler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pytty
+  module Daemon
+    module Components
+      module YieldHandler
+        def self.handle(component:, id:, params:)
+          process_yield = Pytty::Daemon.yields[id]
+          return [404, "not found"] unless process_yield
+
+          return case component
+          when "stdin"
+            process_yield.stdin.enqueue params["c"]
+
+            [200, "ok"]
+          when "signal"
+            return [500, "not running"] unless process_yield.running?
+
+            process_yield.signal params["signal"]
+
+            [200, "ok"]
+          when "spawn"
+            return [500, "already running"] if process_yield.running?
+
+            if process_yield.spawn
+              Pytty::Daemon.dump
+            else
+              return [500, "could not spawn"]
+            end
+
+            [200, "ok"]
+          when "rm"
+            process_yield.signal("KILL") if process_yield.running?
+            Pytty::Daemon.yields.delete process_yield.id
+            Pytty::Daemon.dump
+
+            [200, id]
+          else
+            raise "unknown: #{component} with id: #{id}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/daemon/process_yield.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "securerandom"
+require "pty"
 
 module Pytty
   module Daemon
@@ -9,14 +10,22 @@ module Pytty
         @env = env
 
         @pid = nil
+        @status = nil
         @id = id || SecureRandom.uuid
 
-        @stdouts = []
+        @stdout = nil
+        @stdouts = {}
         @stdin = Async::Queue.new
       end
 
-      attr_reader :id, :cmd, :pid
-      attr_accessor :stdouts, :stdin
+      attr_reader :id, :cmd, :pid, :status, :stdout
+      attr_accessor :stdin
+
+      def add_stdout(stdout)
+        notification = Async::Notification.new
+        @stdouts[notification] = stdout
+        notification
+      end
 
       def running?
         !@pid.nil?
@@ -26,6 +35,7 @@ module Pytty
         {
           id: @id,
           pid: @pid,
+          status: @status,
           cmd: @cmd,
           env: @env,
           running: running?
@@ -33,11 +43,21 @@ module Pytty
       end
 
       def spawn
-        executable, args = @cmd
-        @env.merge!({
-          "TERM" => "vt100"
-        })
+        return false if running?
 
+        executable, args = @cmd
+        # @env.merge!({
+        #   "TERM" => "xterm"
+        # })
+
+        stdout_path = File.join(Pytty::Daemon.pytty_path, @id)
+        File.unlink stdout_path if File.exist? stdout_path
+        stdout_appender = Async::IO::Stream.new(
+          File.open stdout_path, "a"
+        )
+        @stdout = Async::IO::Stream.new(
+          File.open stdout_path, "r"
+        )
         Async::Task.current.async do |task|
           p ["spawn", executable, args, @env]
 
@@ -46,46 +66,52 @@ module Pytty
           async_stdout = Async::IO::Generic.new real_stdout
           async_stdin = Async::IO::Generic.new real_stdin
 
-          task.async do |subtask|
+          task_stdin_writer = task.async do |subtask|
             while c = @stdin.dequeue do
-              p c
               async_stdin.write c
             end
+          rescue Exception => ex
+            puts "async_stdin.write: #{ex.inspect}"
           end
 
-          while c = async_stdout.read(1)
-            @stdouts.each do |s|
-              begin
-                s.write c
-              rescue Errno::EPIPE => ex
-                puts "cannnot write, popping"
-                @stdouts.pop
+          task_stdout_writer = task.async do |subtask|
+            while c = async_stdout.read(1)
+              stdout_appender.write c
+              stdout_appender.flush
+              @stdouts.each do |notification, stdout|
+                begin
+                  stdout.write c
+                rescue Errno::EPIPE => ex
+                  notification.signal
+                  @stdouts.delete notification
+                end
               end
             end
+          ensure
+            task_stdin_writer.stop
+            Process.wait(@pid)
+            @status = $?.exitstatus
+            @pid = nil
+            stdout_appender.close
+
+            @stdouts.each do |notification, stdout|
+              p ["notifying: #{notification}"]
+              notification.signal
+              @stdouts.delete notification
+            end
+            p ["exited", @cmd, "status", @status]
           end
-          puts "CLOSED"
-          #stdout.close
-        end
-
-      end
-      def signal(sig)
-        Process.kill(sig, @pid)
-      end
-
-      def tstp
-        Process.kill("TSTP", @pid)
-      end
+        end.wait
 
-      def cont
-        Process.kill("CONT", @pid)
+        puts "spawned"
+        p ["@stdouts", @stdouts]
+        return true
       end
 
-      def kill
-        Process.kill("KILL", @pid)
-      end
-
-      def term
-        Process.kill("TERM", @pid)
+      def signal(sig)
+        sig_upcased = sig.upcase
+        p ["signaling", sig_upcased, "to", @pid]
+        Process.kill(sig_upcased, @pid)
       end
     end
   end

data/lib/pytty/version.rb

@@ -1,3 +1,3 @@
 module Pytty
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pytty
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Matti Paksula
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-13 00:00:00.000000000 Z
+date: 2019-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -178,9 +178,12 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/build
 - bin/console
 - bin/setup
+- build/linux-debian-deps.sh
+- build/linux.sh
+- build/macos-deps.sh
+- build/macos.sh
 - exe/pytty
 - exe/pyttyd
 - lib/pytty.rb
@@ -188,7 +191,9 @@ files:
 - lib/pytty/client/api.rb
 - lib/pytty/client/api/attach.rb
 - lib/pytty/client/api/ps.rb
+- lib/pytty/client/api/signal.rb
 - lib/pytty/client/api/spawn.rb
+- lib/pytty/client/api/stdout.rb
 - lib/pytty/client/api/yield.rb
 - lib/pytty/client/cli.rb
 - lib/pytty/client/cli/attach_command.rb
@@ -199,6 +204,7 @@ files:
 - lib/pytty/client/cli/run_command.rb
 - lib/pytty/client/cli/signal_command.rb
 - lib/pytty/client/cli/spawn_command.rb
+- lib/pytty/client/cli/stdout_command.rb
 - lib/pytty/client/cli/stream_command.rb
 - lib/pytty/client/cli/yield_command.rb
 - lib/pytty/client/process_yield.rb
@@ -212,10 +218,7 @@ files:
 - lib/pytty/daemon/cli/serve_command.rb
 - lib/pytty/daemon/components.rb
 - lib/pytty/daemon/components/handler.rb
-- lib/pytty/daemon/components/http_handler.rb
-- lib/pytty/daemon/components/run.rb
-- lib/pytty/daemon/components/stream.rb
-- lib/pytty/daemon/components/web_socket_handler.rb
+- lib/pytty/daemon/components/yield_handler.rb
 - lib/pytty/daemon/process_yield.rb
 - lib/pytty/version.rb
 - pytty.gemspec

data/bin/build

@@ -1,15 +0,0 @@
-#!/usr/bin/env sh
-set -e
-set -x
-case "$1" in
-  "gem")
-    set +e
-      gem uninstall -xa pytty
-    set -e
-    rake install
-  ;;
-  "binary")
-    rubyc -c --make-args="-j16" -o pkg/pyttyd pyttyd
-  ;;
-esac
-

data/lib/pytty/daemon/components/http_handler.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-require "rack/request"
-require "mustermann"
-
-module Pytty
-  module Daemon
-    module Components
-      class HttpHandler
-        def initialize(env)
-          @env = env
-        end
-
-        def handle
-          req = Rack::Request.new(@env)
-          body = begin
-            JSON.parse(req.body.read)
-          rescue
-          end
-
-          params = Mustermann.new('/:component(/?:id)?').params(req.path_info)
-          case params.fetch("component")
-          when "rm"
-            id = params["id"]
-
-            process_yield = Pytty::Daemon.yields[id]
-            unless process_yield
-              return [404, nil]
-            else
-              return [200, process_yield]
-            end
-          end
-
-          case req.path_info
-          when "/kill"
-            p req
-            return [200, {}]
-          end
-
-          obj = case req.path_info
-          when "/run"
-            Run.new cmd: body.dig("cmd")
-          when "/stream"
-            Stream.new cmd: body.dig("cmd")
-          else
-            raise "Unknown: #{req.path_info}"
-          end
-
-          obj.run
-        end
-      end
-    end
-  end
-end
-

data/lib/pytty/daemon/components/run.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pytty
-  module Daemon
-    module Components
-      class Run
-        def initialize(cmd:)
-          @cmd = cmd
-        end
-
-        def run
-          cmd_string = @cmd.join(" ")
-          `#{cmd_string}`
-        end
-      end
-    end
-  end
-end
-

data/lib/pytty/daemon/components/stream.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-require 'pty'
-require 'io/console'
-
-module Pytty
-  module Daemon
-    module Components
-      class Stream
-        def initialize(cmd:, env:)
-          @cmd = cmd
-          @env = env
-        end
-
-        def run(stream:)
-          pipe = IO.pipe
-          stderr = Async::IO::Generic.new(pipe.first)
-          stderr_writer = Async::IO::Generic.new(pipe.last)
-
-
-          cmd, args = @cmd
-          process_stdout, process_stdin, pid = PTY.spawn(@env, cmd, *args, err: stderr_writer.fileno)
-          stderr_writer.close
-
-          stdout = Async::IO::Generic.new process_stdout
-#          stdin = Async::IO::Generic.new process_stdin
-          Async::Task.current.async do |task|
-            while c = stdout.read(1)
-              stream.write c
-            end
-            stream.close
-          end
-          # Async::Task.current.async do |task|
-          #   loop do
-          #     p "o"
-          #     task.sleep 1
-          #   end
-          # end
-
-        end
-      end
-    end
-  end
-end
-

data/lib/pytty/daemon/components/web_socket_handler.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-require "rack/request"
-
-module Pytty
-  module Daemon
-    module Components
-      class WebSocketHandler
-        def initialize(env)
-          @env = env
-        end
-
-        def handle
-          req = Rack::Request.new(@env)
-          ws = Pytty::Daemon::Api::WebSockets.new(@env)
-          ws.handle
-
-          klass = case req.path_info
-          when "/stream"
-            Stream
-          else
-            raise "Unknown: #{req.path_info}"
-          end
-          params = ws.read
-          body = begin
-            JSON.parse(params)
-          rescue Exception => ex
-            p ex
-          end
-
-          obj = klass.new cmd: body.dig("cmd"), env: body.dig("env")
-          obj.run stream: ws
-        end
-      end
-    end
-  end
-end
-