shatty 0.0.1

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem "clamp"
+gem "ftw"
+gem "uuidtools"

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    backports (2.3.0)
+    cabin (0.4.4)
+      json
+    clamp (0.3.1)
+    ftw (0.0.14)
+      addressable (= 2.2.6)
+      backports (= 2.3.0)
+      cabin (> 0)
+      http_parser.rb (= 0.5.3)
+      json (= 1.6.5)
+      minitest (> 0)
+    http_parser.rb (0.5.3)
+    json (1.6.5)
+    minitest (2.11.0)
+    uuidtools (2.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  clamp
+  ftw
+  uuidtools

data/Procfile

@@ -0,0 +1 @@
+web: ruby web.rb

data/README.md

@@ -0,0 +1,59 @@
+# shatty
+
+share tty.
+
+## Play a demo recording
+
+```
+% ruby shatty.rb play examples/output.shatty
+```
+
+## Recording
+
+```
+% shatty.rb record <command>
+```
+
+By default will record to 'output.shatty'
+
+## Playback
+
+```
+% shatty.rb play output.shatty
+```
+
+## Sharing
+
+TBD.
+
+* read-only
+* read/write
+
+## Tricks
+
+### Record an active tmux session
+
+```bash
+# From any shell in your tmux session:
+% TMUX= ruby shatty.rb record --headless tmux -2 attach
+```
+
+The '--headless' is required otherwise you end up tmux printing to tmux and you get a loop.
+
+
+## TODO
+
+* Improved player
+  * Skip forward/back
+  * Tunable playing speed (1x, 2x, etc)
+  * Search.
+  * Pause/rewind/etc live while viewing or recording.
+* Online sharing
+  * Live sharing
+  * Multiuser
+  * Sharing recorded sessions
+* Terminal size options
+  * Currently stuck at default 80x24, fix that.
+* Improve & document recording format
+  * Currently a sequence of [play_time, length, data].pack("GNA*")
+* Implement a terminal emulator so we can calculate key frames to better support playback/rewind

data/misc/shatty.go

@@ -0,0 +1,173 @@
+package main
+
+import (
+  "os"
+  "time"
+  "io"
+  "os/exec"
+  "syscall"
+  "unsafe"
+  "fmt"
+)
+
+/*
+forkpty == openpty + fork
+  parent: close slave
+  child: close master
+
+openpty == 
+  master = getpt
+  granpt(master)
+  unlockpt(master)
+  open as file ptsname(master)
+    tcsetattr (slave, TCSAFLUSH, termp);
+    ioctl (slave, TIOCSWINSZ, winp);
+
+getpt 
+  open /dev/ptmx, return fd (linux specific)
+grantpt
+  call ptsname (get the filename of the slave)
+  chown/chgrp/chmod the filename to us
+unlockpt
+  ioctl(master, TIOCSPTLCK, 0)
+open slave
+  if 'login terminal'
+    ioctl(slave, TIOCSCTTY, NULL) // set this procses as controlling terminal
+  dup stdin/stdout/stderr to slave
+*/
+
+func getpt() (file *os.File, err error) {
+  file, err = os.OpenFile("/dev/ptmx", os.O_RDWR, 0)
+  if err != nil {
+    return nil, err
+  }
+  return file, nil
+} /* getpt */
+
+func ptsname(file *os.File) (name string, err error) {
+  /* On linux, this calls ioctl(fd, TIOCGPTN, ...) */
+  var num int
+
+  /* Get the /dev/pts number */
+  err = ioctl(file, syscall.TIOCGPTN, &num)
+  if err != nil && err.Error() != "errno 0" {
+    return "", err
+  }
+  return fmt.Sprintf("/dev/pts/%d", num), nil
+}
+
+func grantpt(file *os.File) (err error) {
+  slave_name, err := ptsname(file)
+  if err != nil { return err }
+  err = os.Chown(slave_name, os.Getuid(), os.Getgid())
+  if err != nil { return err }
+  err = os.Chmod(slave_name, 0600)
+  if err != nil { return err }
+  return nil
+}
+
+func unlockpt(file *os.File) (err error) {
+  var val = 0
+  err = ioctl(file, syscall.TIOCSPTLCK, &val)
+
+  if err != nil && err.Error() != "errno 0" { return err }
+  return nil
+}
+
+/* Borrowed with modifications from github.com/kr/pty/pty_linux.go; MIT license */
+func ioctl(file *os.File, command uint, data *int) (err syscall.Errno) {
+  _, _, err = syscall.Syscall(syscall.SYS_IOCTL, uintptr(file.Fd()),
+                               uintptr(command), uintptr(unsafe.Pointer(data)))
+  if err != 0 {
+    return err
+  }
+  return syscall.Errno(0)
+} /* ioctl */
+
+func openpty() (master *os.File, slave *os.File, err error) {
+  master, err = getpt()
+  if err != nil { return nil, nil, err }
+  if err = grantpt(master); err != nil { return nil, nil, err }
+  if err = unlockpt(master); err != nil { return nil, nil, err }
+
+  slave_name, err := ptsname(master)
+  if err != nil { return nil, nil, err }
+  slave, err = os.OpenFile(slave_name, os.O_RDWR, 0)
+
+  return master, slave, nil
+} /* openpty */
+
+func dup(file *os.File, name string) (newfile *os.File, err error) {
+  fd, err := syscall.Dup(int(file.Fd()))
+  if err != nil { return nil, err }
+
+  return os.NewFile(uintptr(fd), "<stdin>"), nil
+}
+
+func forkpty(name string, argv []string, attr *os.ProcAttr) (master *os.File, command *exec.Cmd, err error) {
+  master, slave, err := openpty()
+  if err != nil { return nil, nil, err }
+
+  /* dup it up. */
+
+  fd := [3]*os.File{slave, slave, slave}
+  attr.Files = fd[:]
+
+  command = new(exec.Cmd)
+  //command.Path = name
+  //command.Args = argv[:]
+  command.Stdin, err = dup(slave, "<slave stdin>")
+  command.Stdout, err = dup(slave, "<slave stdout>")
+  command.Stderr, err = dup(slave, "<slave stderr>")
+  //command.Stdout = slave
+  //command.Stderr = slave
+  command.Process, err = os.StartProcess(name, argv, attr)
+  slave.Close()
+  if err != nil { return nil, nil, err }
+
+  /* Now in the parent */
+  command.Stdin, err = dup(master, "<stdin>")
+  command.Stdout, err = dup(master, "<stdout>")
+  command.Stderr, err = dup(master, "<stderr>")
+  //command.Stdin = master
+  //command.Stdout = master
+  //command.Stderr = master
+  //master.Close()
+
+  if err != nil { return nil, nil, err }
+  return master, command, nil
+}
+
+func main() {
+  master, command, err := forkpty("/bin/bash", []string{"/bin/bash", "-li"}, new(os.ProcAttr))
+
+  if err != nil { fmt.Printf("forkpty: %v\n", err); return }
+  fmt.Printf("%T/%v %s\n", master, master, master.Name())
+  
+  go func() {
+    for { 
+      data := make([]byte, 1024)
+      _, err := command.Stdout.(io.Reader).Read(data)
+      if err != nil { return }
+      //fmt.Printf("Read: %d '%#v'\n", size, fmt.Sprintf("%.*s", size, data))
+      os.Stdout.Write(data)
+      //time.Sleep(500 * time.Millisecond)
+    }
+  }()
+
+  time.Sleep(500 * time.Millisecond)
+  _, err = command.Stdin.(*os.File).WriteString("echo hello world\n")
+  if err != nil { fmt.Printf("Fprintf: %v\n", err); return }
+  time.Sleep(500 * time.Millisecond)
+  _, err = command.Stdin.(*os.File).WriteString("tty\n")
+  if err != nil { fmt.Printf("Fprintf: %v\n", err); return }
+  time.Sleep(500 * time.Millisecond)
+  //_, err = command.Stdin.(*os.File).WriteString("exit\n")
+  //if err != nil { fmt.Printf("Fprintf: %v\n", err); return }
+  master.Close()
+
+  /* It would be nice if this actually closed stdin for the subcommand */
+  command.Stdin.(*os.File).Close()
+  fmt.Printf("Wait: %v\n", command.Wait())
+
+}

data/shatty.rb

@@ -0,0 +1,115 @@
+require "clamp"
+require "pty"
+require "ftw"
+require "uuidtools"
+
+class Shatty < Clamp::Command
+  subcommand "record", "Record a command" do
+    option ["-o", "--output"], "PATH_OR_URL",
+      "where to output the recording to (a path or url)"
+    option "--headless", :flag,
+      "headless mode; don't output anything to stdout."
+    parameter "COMMAND ...", "The command to run",
+      :attribute_name => :command
+
+    def execute
+      start = Time.now
+
+      if output.nil?
+        output = "http://r.logstash.net:8200/s/#{UUIDTools::UUID.random_create}"
+        puts "Sending output to: #{output}"
+      end
+
+      if output =~ /^https?:/
+        agent = FTW::Agent.new
+        stream, out = IO::pipe
+        Thread.new { 
+          response = agent.post!(output, :body => stream)
+          # TODO(sissel): Shouldn't get here...
+        }
+      else
+        # no http/https, assume file output.
+        out = File.new(output, "w")
+      end
+
+      # binary mode.
+      buffer = ""
+
+      STDOUT.sync = true
+      terminal, keyboard, pid = PTY.spawn(*command)
+      system("stty raw -echo") # yeah, perhaps we should use termios instead.
+
+      # Dump stdin to the tty's keyboard
+      # We could use reopen here, but the 'keyboard' io has mode read/write.
+      Thread.new { STDIN.each_char { |c| keyboard.syswrite(c) } }
+
+      while true
+        # Read from the terminal output and compute the time offset
+        begin
+          terminal.sysread(16834, buffer)
+        rescue Errno::EIO => e
+          Process.waitpid(pid)
+          puts "Command exited with code: #{$?.exitstatus}"
+          break
+        end
+
+        time_offset = Time.now - start
+
+        # for each chunk of text read from tmux, record
+        # the timestamp (duration since 'start' of recording)
+        out.syswrite([time_offset.to_f, buffer.length, buffer].pack("GNA#{buffer.length}"))
+
+        $stdout.write(buffer) unless headless?
+      end
+
+      system("stty sane")
+    end # def execute
+  end # subcommand "record"
+
+  subcommand "play", "Play a recording" do
+    parameter "[PATH_OR_URL]",
+      "The recording to play. This can be a path or URL.",
+      :attribute_name => :path
+
+    def execute
+      # TODO(sissel): Don't abort :(
+      Thread.abort_on_exception = true 
+
+      if path =~ /^https?:/
+        input, writer = IO::pipe
+        Thread.new do 
+          agent = FTW::Agent.new
+          response = agent.get!(path)
+          response.read_http_body { |chunk| writer.syswrite(chunk) }
+        end
+      else
+        input = File.new(path, "w")
+      end
+
+      start = nil
+
+      $stdout.sync = true
+      headersize = [1,1].pack("GN").size
+      last_time = 0
+      while true
+        # Read the header
+        begin
+          buffer = input.read(headersize)
+          time, length = buffer.unpack("GN")
+          buffer = input.read(length)
+        rescue EOFError
+          break
+        end
+
+        # Sleep if necessary
+        #sleep(time - last_time) if last_time > 0
+        last_time = time
+
+        # output this frame.
+        $stdout.syswrite(buffer)
+      end
+    end # def execute
+  end # subcommand "play"
+end # class Shatty
+
+Shatty.run

data/web.rb

@@ -0,0 +1,84 @@
+require "ftw" # gem ftw
+require "cabin" # gem cabin
+require "thread"
+
+ShutdownSignal = :shutdown
+
+class Session
+  def initialize
+    @queue = Queue.new
+    @recent = []
+  end # def initialize
+
+  def <<(chunk)
+    @queue << chunk
+    @recent << chunk
+    @recent = @recent[0..100]
+  end # def push
+
+  def enumerator
+    return Enumerator.new do |y|
+      @recent.each { |chunk| y << chunk }
+      while true
+        chunk = @queue.pop
+        break if chunk == ShutdownSignal
+        y << chunk
+      end
+    end # Enumerator
+  end # def enumerator
+
+  def raw
+    return Enumerator.new do |y|
+      enumerator.each do |chunk|
+        puts decode(chunk).inspect
+        y << decode(chunk)
+      end
+    end # Enumerator
+  end # def enumerator
+
+  def decode(chunk)
+    return chunk[headersize .. -1]
+  end # def decode
+
+  def close
+    @queue << ShutdownSignal
+  end
+end # class Session
+
+sessions = {}
+
+port = ENV.include?("PORT") ? ENV["PORT"].to_i : 8888
+server = FTW::WebServer.new("0.0.0.0", port) do |request, response|
+  @logger = Cabin::Channel.get
+  if request.path =~ /^\/s\//
+    session = sessions[request.path] ||= Session.new
+    if request.method == "POST"
+      # TODO(sissel): Check if a session exists.
+
+      begin
+        request.read_http_body do |chunk|
+          session << chunk
+        end
+      rescue EOFError
+      end
+      session.close
+      sessions.delete(request.path)
+    elsif request.method == "GET"
+      response.status = 200
+      response["Content-Type"] = "text/plain"
+      if request["user-agent"] =~ /^curl\/[0-9]/
+        # Curl. Send raw text.
+        response.body = session.raw
+      else
+        response.body = session.enumerator
+      end
+    else
+      response.status = 400
+      response.body = "Invalid method '#{request.method}'\n"
+    end
+  else
+    response.status = 404
+  end
+end
+
+server.run

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: shatty
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jordan Sissel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cabin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+description: shatty
+email:
+- jls@semicomplete.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- Procfile
+- README.md
+- examples/blinkenlights.shatty
+- examples/output.shatty
+- misc/shatty.go
+- shatty.rb
+- web.rb
+homepage: 
+licenses:
+- none chosen yet
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: shatty
+test_files: []