pytty 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86943cf397ea5d69b0d735243100ad08ed00629b2b1ffc34157f44acb0ff2316
-  data.tar.gz: 5ee2c4f7c9bd1bbb9e550be3140d1c7c53f5b51f74ae3cad2f60994b1a026374
+  metadata.gz: fd905d25dba15816b22209e67dfd888c3379e3f0ef01d18611b86c21e49a6666
+  data.tar.gz: 7b215e1046ea4a67b3bc619ccb6603ba8f540a8473a6060b6f47d9921187296e
 SHA512:
-  metadata.gz: 04b69e3162611cda3e34a33dfae91a6cbad3226ae31e928d8a77dcf1e210c7b4fd766a173f182e8be7a089c2ca26cd3f6456fb13fab420695108c706649a56c3
-  data.tar.gz: 4a61b1ff318f39adb8918565e78a6ef7ed189c7063bcb97ce3ca9efc27593a2b73e8a9262e5542cd5c6e850eb77ddbe5c9555be8948f136f4422962d3d18c06b
+  metadata.gz: 19c80222d3401ca8e1b84878cba3a2fd9f858de56382388104533a03a9ec88ac8cb83594984218273467b8c83e9f94c640b28985462b1f54e76a1fda562dded9
+  data.tar.gz: 1056958148e94f81ba23f50970e4fc399300fc93fe2854518f3a551f46b1128c61da8a9166fab9349bb6ebaa67bfa66b1eb46e64c10ee9c71e5aca0320a58e76

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    pytty (0.2.0)
+    pytty (0.3.0)
       async-websocket
       clamp (~> 1.3)
       falcon
+      mustermann
 
 GEM
   remote: https://rubygems.org/
@@ -51,6 +52,9 @@ GEM
       guard (~> 2.2)
       guard-compat (~> 1.1)
     guard-compat (1.2.1)
+    guard-process (1.2.1)
+      guard-compat (~> 1.2, >= 1.2.1)
+      spoon (~> 0.0.1)
     guard-rspec (4.7.3)
       guard (~> 2.1)
       guard-compat (~> 1.1)
@@ -67,6 +71,7 @@ GEM
     lumberjack (1.0.13)
     mapping (1.1.1)
     method_source (0.9.2)
+    mustermann (1.0.3)
     nenv (0.3.0)
     nio4r (2.3.1)
     notiffany (0.1.1)
@@ -99,6 +104,8 @@ GEM
       mapping (~> 1.0)
       rainbow (>= 2.0, < 4.0)
     shellany (0.0.1)
+    spoon (0.0.6)
+      ffi
     thor (0.20.3)
     timers (4.2.0)
     websocket-driver (0.7.0)
@@ -112,6 +119,7 @@ DEPENDENCIES
   bundler (~> 1.16)
   guard
   guard-bundler
+  guard-process
   guard-rspec
   kommando
   pytty!

data/bin/build

@@ -0,0 +1,15 @@
+#!/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/exe/pytty

@@ -9,6 +9,7 @@ $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
 STDOUT.sync = true
 
 require 'pytty'
+require 'pytty/client'
 require 'pytty/client/cli'
 
 Pytty::Client::Cli::RootCommand.run

data/exe/pyttyd

@@ -9,6 +9,7 @@ $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
 STDOUT.sync = true
 
 require 'pytty'
+require 'pytty/daemon'
 require 'pytty/daemon/cli'
 
 Pytty::Daemon::Cli::RootCommand.run

data/lib/pytty/client.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pytty
+  module Client
+  end
+end
+
+require_relative "client/process_yield"
+require_relative "client/api"

data/lib/pytty/client/api.rb

@@ -0,0 +1,4 @@
+require_relative "api/ps"
+require_relative "api/yield"
+require_relative "api/attach"
+require_relative "api/spawn"

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

@@ -0,0 +1,61 @@
+module Pytty
+  module Client
+    module Api
+      class Attach
+        def self.run(id:)
+          Async::Task.current.async do |stdin_task|
+            internet = Async::HTTP::Internet.new
+            headers = [['accept', 'application/json']]
+            body = {}.to_json
+
+            $stdin.raw!
+            $stdin.echo = false
+            async_stdin = Async::IO::Stream.new(
+              Async::IO::Generic.new($stdin)
+            )
+
+            stdin_body = {
+              c: "\f"
+            }.to_json
+            response = internet.post("http://localhost:1234/v1/stdin/#{id}", headers, [stdin_body])
+
+            detach_sequence_started = false
+            while c = async_stdin.read(1) do
+              case c
+              when "\x10"
+                detach_sequence_started = true
+                next
+              when "\x11"
+                if detach_sequence_started
+                  detach_sequence_started = false
+                  exit 0
+                end
+              end
+
+              detach_sequence_started = false
+
+              stdin_body = {
+                c: c
+              }.to_json
+              response = internet.post("http://localhost:1234/v1/stdin/#{id}", headers, [stdin_body])
+            end
+          end
+
+          begin
+            internet = Async::HTTP::Internet.new
+            headers = [['accept', 'application/json']]
+            body = {}.to_json
+
+            response = internet.post("http://localhost:1234/v1/attach/#{id}", headers, [body])
+            response.body.each do |c|
+              print c
+            end
+          rescue Async::Wrapper::Cancelled => ex
+          ensure
+            internet.close
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Pytty
+  module Client
+    module Api
+      class Ps
+        def self.run
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {}.to_json
+
+          response = internet.post("http://localhost:1234/v1/ps", headers, [body])
+          JSON.parse(response.body.read)
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+module Pytty
+  module Client
+    module Api
+      class Yield
+        def self.run(cmd:, env:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+
+          term_env = {
+            "LINES" => IO.console.winsize.first.to_s,
+            "COLUMNS" => IO.console.winsize.last.to_s
+          }.merge env
+
+          body = {
+            cmd: cmd,
+            env: term_env
+          }.to_json
+
+          response = internet.post("http://localhost:1234/v1/yield", headers, [body])
+          JSON.parse(response.body.read)
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/cli.rb

@@ -3,5 +3,12 @@ require "clamp"
 require_relative "../common/cli/version_command"
 require_relative "cli/run_command"
 require_relative "cli/stream_command"
+require_relative "cli/yield_command"
+require_relative "cli/ps_command"
+require_relative "cli/kill_command"
+require_relative "cli/rm_command"
+require_relative "cli/spawn_command"
+require_relative "cli/signal_command"
+require_relative "cli/attach_command"
 
 require_relative "cli/root_command"

data/lib/pytty/client/cli/attach_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 AttachCommand < Clamp::Command
+        parameter "ID", "id"
+
+        def execute
+          Async.run do
+            Pytty::Client::Api::Attach.run id: id
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class KillCommand < Clamp::Command
+        parameter "ID ...", "id"
+
+        def execute
+          Async.run do
+            internet = Async::HTTP::Internet.new
+            headers = [['accept', 'application/json']]
+            body = {}.to_json
+
+            for id in id_list do
+              response = internet.post("http://localhost:1234/v1/kill/#{id}", headers, [body])
+              puts response.read
+            end
+          ensure
+            internet.close
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class PsCommand < Clamp::Command
+        option ["-q","--quiet"], :flag, "quiet"
+
+        def execute
+          process_yields = Async.run do
+            Pytty::Client::Api::Ps.run
+          end.wait
+
+          unless quiet?
+            puts "id  cmd"
+            puts "-"*40
+          end
+          for process_yield in process_yields do
+            if quiet?
+              puts process_yield.fetch "id"
+            else
+              puts process_yield
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class RmCommand < Clamp::Command
+        parameter "[ID] ...", "id"
+        option ["--all"], :flag, "all"
+
+        def execute
+          ids = if all?
+            process_yield_jsons = Async.run do
+              Pytty::Client::Api::Ps.run
+            end.wait
+            process_yield_jsons.map do |json|
+              json.fetch("id")
+            end
+          else
+            id_list
+          end
+
+          Async.run do
+            internet = Async::HTTP::Internet.new
+            headers = [['accept', 'application/json']]
+            body = {}.to_json
+
+            for id in ids do
+              response = internet.post("http://localhost:1234/v1/rm/#{id}", headers, [body])
+              puts id
+            end
+          ensure
+            internet.close
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -14,6 +14,13 @@ module Pytty
         subcommand ["version"], "Show version information", Pytty::Common::Cli::VersionCommand
         subcommand ["run"], "run", RunCommand
         subcommand ["stream"], "stream", StreamCommand
+        subcommand ["yield"], "yield", YieldCommand
+        subcommand ["ps"], "ps", PsCommand
+        subcommand ["kill"], "kill", KillCommand
+        subcommand ["rm"], "rm", RmCommand
+        subcommand ["spawn"], "spawn", SpawnCommand
+        subcommand ["signal"], "signal", SignalCommand
+        subcommand ["attach"], "attach", AttachCommand
 
         def self.run
           super

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

@@ -9,18 +9,21 @@ module Pytty
     module Cli
       class RunCommand < Clamp::Command
         parameter "CMD ...", "command"
+        option ["-i","--interactive"], :flag, "interactive"
+        option ["-t","--tty"], :flag, "tty"
+        option ["-d","--detach"], :flag, "detach"
+
         def execute
           Async.run do
-            internet = Async::HTTP::Internet.new
-            headers = [['accept', 'application/json']]
-            body = {
-              cmd: cmd_list
-            }.to_json
+            json = Pytty::Client::Api::Yield.run cmd: cmd_list, env: {}
+            process_yield = Pytty::Client::ProcessYield.from_json json
+            process_yield.spawn tty: tty?, interactive: interactive?
 
-            response = internet.post("http://localhost:1234/v1/run", headers, [body])
-            puts response.read
-          ensure
-            internet.close
+            if detach?
+              puts process_yield.id
+            else
+              process_yield.attach
+            end
           end
         end
       end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class SignalCommand < Clamp::Command
+        parameter "SIGNAL", "signal"
+        parameter "ID ...", "id"
+
+        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
+            end
+          ensure
+            internet.close
+          end
+        end
+      end
+    end
+  end
+end
+

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

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

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

@@ -11,6 +11,37 @@ module Pytty
       class StreamCommand < Clamp::Command
         parameter "CMD ...", "command"
         def execute
+
+          $stdin.raw!
+          $stdin.echo = false
+          Async::Reactor.run do |task|
+            async_stdin = Async::IO::Stream.new(
+              Async::IO::Generic.new($stdin)
+            )
+
+            while c = async_stdin.read(1) do
+              case c
+              when "\x01"
+                print "\r"
+              when "\x03"
+                puts "\r\n\nctrl+c\n\r"
+                break
+              when "\r"
+                print "\n\r"
+              when "\e"
+                print c
+                print async_stdin.read(2)
+              else
+                print c.inspect
+#                print c
+#                p c
+              end
+            end
+          end
+
+          exit 0
+
+          #---------------
           env = {
             "LINES" => IO.console.winsize.first.to_s,
             "COLUMNS" => IO.console.winsize.last.to_s

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class YieldCommand < Clamp::Command
+        parameter "CMD ...", "command"
+        option ["-q", "--quiet"], :flag, "quiet"
+
+        def execute
+          process_yield = Async.run do
+            json = Pytty::Client::Api::Yield.run cmd: cmd_list, env: {}
+            ::Pytty::Client::ProcessYield.from_json json
+          end.wait
+
+          if quiet?
+            puts process_yield.id
+          else
+            puts process_yield
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/client/process_yield.rb

@@ -0,0 +1,35 @@
+module Pytty
+  module Client
+    class ProcessYield
+      def initialize(id:, cmd:, env:, pid:)
+        @cmd = cmd
+        @env = env
+        @pid = pid
+        @id = id
+      end
+
+      attr_reader :id
+
+      def self.from_json(json)
+        self.new({
+          id: json.fetch("id"),
+          cmd: json.fetch("cmd"),
+          env: json.fetch("env"),
+          pid: json.fetch("pid")
+        })
+      end
+
+      def to_s
+        "#{@id} #{@cmd}"
+      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
+      end
+    end
+  end
+end

data/lib/pytty/daemon.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pytty
+  module Daemon
+    @@yields = {}
+
+    def self.yields
+      @@yields
+    end
+
+    def self.dump
+      FileUtils.mkdir_p File.dirname(yields_json)
+      File.write yields_json, @@yields.to_json
+    end
+
+    def self.load
+      return unless File.exist? yields_json
+      puts "restoring from #{yields_json}"
+
+      objs = JSON.parse(File.read(yields_json))
+      objs.each do |k,obj|
+        process_yield = ProcessYield.new obj["cmd"], id: obj["id"], env: obj["env"]
+        @@yields[obj["id"]] = process_yield
+        print "spawning #{process_yield.cmd} ... "
+        process_yield.spawn if obj["running"]
+        puts "done"
+      end
+
+    end
+
+    def self.yields_json
+      File.join(Dir.home,".pytty","yields.json")
+    end
+  end
+end
+
+require_relative "daemon/process_yield"
+require_relative "daemon/components"

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

@@ -1,7 +1,5 @@
-require_relative "web_sockets"
-require_relative "chunk"
-
-require_relative "../components"
+require "mustermann"
+require "json"
 
 module Pytty
   module Daemon
@@ -9,20 +7,46 @@ module Pytty
       class Router
         def call(env)
           req = Rack::Request.new(env)
-          resp = case req.path_info
-          when "/stream"
+
+          params = Mustermann.new('/:component(/?:id)?').params(req.path_info)
+          body = begin
+            JSON.parse(req.body.read)
+          rescue
+          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
             end
 
             [404, {"Content-Type" => "text/html"}, ["websocket only"]]
-          when "/run"
-            handler = Pytty::Daemon::Components::WebHandler.new(env)
-            output = handler.handle
+          when "attach"
+            task = Async::Task.current
+            body = Async::HTTP::Body::Writable.new
+
+            task.async do |task|
+              Pytty::Daemon.yields[params["id"]].stdouts << body
+              loop do
+                task.sleep 0.1
+              end
+            rescue Exception => ex
+              p ex
+            ensure
+              puts "closing body"
+              body.close
+            end
 
-            [200, {"Content-Type" => "text/html"}, [output]]
-          when "/ws"
+            [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
+            [status, {"Content-Type" => "application/json"}, [output.to_json]]
+          when "ws"
             if env["HTTP_UPGRADE"] == "websocket"
               ws = WebSockets.new env
               ws.handle

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

@@ -1,21 +1,12 @@
 require "falcon"
 require_relative "router"
-require_relative "chunk"
 
 module Pytty
   module Daemon
     module Api
       class Server
-        def initialize
-        end
-
-        def run
+        def self.run(url:)
           rack_app = Rack::Builder.new do
-            #use Rack::CommonLogger
-
-            map "/chunk" do
-              run Chunk.new
-            end
             map "/v1" do
               run Router.new
             end
@@ -23,16 +14,12 @@ module Pytty
 
           app = Falcon::Server.middleware rack_app, verbose: true
 
-          endpoint = Async::HTTP::URLEndpoint.parse "http://0.0.0.0:1234"
-          bound_endpoint = Async::Reactor.run do
-            Async::IO::SharedEndpoint.bound(endpoint)
-          end.result
+          endpoint = Async::HTTP::URLEndpoint.parse url
+          bound_endpoint = Async::IO::SharedEndpoint.bound(endpoint)
 
           server = Falcon::Server.new(app, bound_endpoint, endpoint.protocol, endpoint.scheme)
-          Async::Reactor.run do
-            server.run
-            puts "serving..."
-          end
+          puts "serving at #{url}"
+          server.run
         end
       end
     end

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

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

data/lib/pytty/daemon/components.rb

@@ -2,5 +2,6 @@
 require_relative "components/run"
 require_relative "components/stream"
 
-require_relative "components/web_handler"
-require_relative "components/web_socket_handler"
+require_relative "components/http_handler"
+require_relative "components/web_socket_handler"
+require_relative "components/handler"

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require "rack/request"
+require "mustermann"
+
+module Pytty
+  module Daemon
+    module Components
+      module Handler
+        def self.handle(component:, id:, 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|
+              output << process_yield
+            end
+            [200, output]
+          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
+
+            [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
+            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}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/daemon/components/{web_handler.rb → http_handler.rb}

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 require "rack/request"
+require "mustermann"
 
 module Pytty
   module Daemon
     module Components
-      class WebHandler
+      class HttpHandler
         def initialize(env)
           @env = env
         end
@@ -16,6 +17,25 @@ module Pytty
           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")

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

@@ -22,13 +22,20 @@ module Pytty
           stderr_writer.close
 
           stdout = Async::IO::Generic.new process_stdout
-          stdin = Async::IO::Generic.new process_stdin
+#          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

data/lib/pytty/daemon/process_yield.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require "securerandom"
+
+module Pytty
+  module Daemon
+    class ProcessYield
+      def initialize(cmd, id:nil, env:{})
+        @cmd = cmd
+        @env = env
+
+        @pid = nil
+        @id = id || SecureRandom.uuid
+
+        @stdouts = []
+        @stdin = Async::Queue.new
+      end
+
+      attr_reader :id, :cmd, :pid
+      attr_accessor :stdouts, :stdin
+
+      def running?
+        !@pid.nil?
+      end
+
+      def to_json(json_generator_state=nil)
+        {
+          id: @id,
+          pid: @pid,
+          cmd: @cmd,
+          env: @env,
+          running: running?
+        }.to_json
+      end
+
+      def spawn
+        executable, args = @cmd
+        @env.merge!({
+          "TERM" => "vt100"
+        })
+
+        Async::Task.current.async do |task|
+          p ["spawn", executable, args, @env]
+
+          real_stdout, real_stdin, pid = PTY.spawn @env, executable, *args
+          @pid = pid
+          async_stdout = Async::IO::Generic.new real_stdout
+          async_stdin = Async::IO::Generic.new real_stdin
+
+          task.async do |subtask|
+            while c = @stdin.dequeue do
+              p c
+              async_stdin.write c
+            end
+          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
+              end
+            end
+          end
+          puts "CLOSED"
+          #stdout.close
+        end
+
+      end
+      def signal(sig)
+        Process.kill(sig, @pid)
+      end
+
+      def tstp
+        Process.kill("TSTP", @pid)
+      end
+
+      def cont
+        Process.kill("CONT", @pid)
+      end
+
+      def kill
+        Process.kill("KILL", @pid)
+      end
+
+      def term
+        Process.kill("TERM", @pid)
+      end
+    end
+  end
+end
+

data/lib/pytty/version.rb

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

data/pytty.gemspec

@@ -18,6 +18,15 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
+  ignored_files = ["Dockerfile", "docker-compose.yml",
+    ".dockerignore",".gitignore",
+    ".ruby-gemset",".ruby-version",
+    ".rspec",
+    ".travis.yml",
+    "Guardfile"
+  ]
+  spec.files = spec.files - ignored_files
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
@@ -25,6 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "clamp", "~> 1.3"
   spec.add_runtime_dependency "falcon"
   spec.add_runtime_dependency "async-websocket"
+  spec.add_runtime_dependency "mustermann"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
@@ -32,7 +42,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
   spec.add_development_dependency "guard-bundler"
-
-  spec.add_development_dependency "kommando"
-
+  spec.add_development_dependency "guard-process"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pytty
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Matti Paksula
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-10 00:00:00.000000000 Z
+date: 2019-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -137,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: kommando
+  name: guard-process
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -159,28 +173,37 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".ruby-gemset"
-- ".ruby-version"
-- ".travis.yml"
 - Gemfile
 - Gemfile.lock
-- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/build
 - bin/console
 - bin/setup
 - exe/pytty
 - exe/pyttyd
 - lib/pytty.rb
+- lib/pytty/client.rb
+- lib/pytty/client/api.rb
+- lib/pytty/client/api/attach.rb
+- lib/pytty/client/api/ps.rb
+- lib/pytty/client/api/spawn.rb
+- lib/pytty/client/api/yield.rb
 - lib/pytty/client/cli.rb
+- lib/pytty/client/cli/attach_command.rb
+- lib/pytty/client/cli/kill_command.rb
+- lib/pytty/client/cli/ps_command.rb
+- lib/pytty/client/cli/rm_command.rb
 - lib/pytty/client/cli/root_command.rb
 - 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/stream_command.rb
+- lib/pytty/client/cli/yield_command.rb
+- lib/pytty/client/process_yield.rb
 - lib/pytty/common/cli/version_command.rb
-- lib/pytty/daemon/api/chunk.rb
+- lib/pytty/daemon.rb
 - lib/pytty/daemon/api/router.rb
 - lib/pytty/daemon/api/server.rb
 - lib/pytty/daemon/api/web_sockets.rb
@@ -188,10 +211,12 @@ files:
 - lib/pytty/daemon/cli/root_command.rb
 - 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_handler.rb
 - lib/pytty/daemon/components/web_socket_handler.rb
+- lib/pytty/daemon/process_yield.rb
 - lib/pytty/version.rb
 - pytty.gemspec
 homepage: https://github.com/pyttyhq/pytty-ruby

data/.gitignore

@@ -1,11 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-# rspec failure tracking
-.rspec_status

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.ruby-gemset

@@ -1 +0,0 @@
-pytty

data/.ruby-version

@@ -1 +0,0 @@
-2.6.0

data/.travis.yml

@@ -1,7 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.6.0
-before_install: gem install bundler -v 1.16.6

data/Guardfile

@@ -1,25 +0,0 @@
-guard :rspec, cmd: "bundle exec rspec" do
-  require "guard/rspec/dsl"
-  dsl = Guard::RSpec::Dsl.new(self)
-
-  watch %r{^lib\/pytty\/(?<component>client|daemon)\/cli\/(?<command>.+_command)\.rb$} do |m|
-    "spec/cli/#{m[:component]}/#{m[:command]}_spec.rb"
-  end
-
-  watch %r{^spec\/cli\/(?<component>client|daemon)\/(?<command>.+_command_spec)\.rb$} do |m|
-    m.instance_variable_get(:@original_value)
-  end
-
-end
-
-guard :bundler do
-  require 'guard/bundler'
-  require 'guard/bundler/verify'
-  helper = Guard::Bundler::Verify.new
-
-  files = ['Gemfile']
-  files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
-
-  # Assume files are symlinked from somewhere
-  files.each { |file| watch(helper.real_path(file)) }
-end

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

@@ -1,28 +0,0 @@
-require "falcon"
-require_relative "router"
-
-module Pytty
-  module Daemon
-    module Api
-      class Chunk
-
-        def call(env)
-          task = Async::Task.current
-          body = Async::HTTP::Body::Writable.new
-          task.async do |task|
-            10.times do
-              body.write "hello"
-              task.sleep 0.5
-            end
-          rescue Exception => ex
-            p ex
-          ensure
-            body.close
-          end
-
-          [200, {'content-type' => 'text/html; charset=utf-8'}, body]
-        end
-      end
-    end
-  end
-end