yetty 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d62402f9a45233864b3273f6cbcef84e06426857
-  data.tar.gz: 4efde678a3eec7a504d3ffbbce4f993c0f589d84
+  metadata.gz: 7f45bd672b89d1030a4d3dc6c661c9509feb07d0
+  data.tar.gz: 8e357c6886ad138f1c56cd727ac340d62fcad281
 SHA512:
-  metadata.gz: 8ce82e5ceb45e840bb67573a7491feb292318651a2072a16bc29fd85359d4fb1a0b17ba2bf4dde0efb968406da396ee01d68c52b0dc3f30d37999e6172d82806
-  data.tar.gz: 24c52b6820665db19107c9f1767c76be40280fea1d82a17780c611c90d561159c65c27cb4326826209e1b94ac6fbc423d2aedf99cd7f2f2b4a043e7bdd0826a7
+  metadata.gz: a98db022addf0ad2ff0ad3fc2864454e9ad365b666620331cd73b665b23358a8aad67855a907fe2c132434392f1992540d0a1a1511fee92158cd3a1ab9cc97b6
+  data.tar.gz: 21bad94340f8d3769204c587cdc4f0678aac9c87160f1b6aed8af17d7cbc24784fcd9f755dc8d6be4b2c9bea6caba2f5605d1ac0d889171112f86266c829bae8

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/README.md

@@ -0,0 +1,66 @@
+## Yetty
+
+With shelr.tv[1] now defunct, I wanted an easy way to spin out
+my own to easily share terminal recordings. Yetty is a wrapper
+around shelr[2] that removes some of the extra features it
+provids. It also has a very simple web UI builtin that hooks into
+an object store to persist dump files.
+
+### Is it secure?
+
+No, not at all. This is configuration based and user uploads are
+simply prefixed within the bucket. But this is just a friendly
+tool, so if bad things happen, maybe your friends aren't so friendly.
+
+### Web UI?
+
+Yep. It's a very simple sinatra application. It pulls information
+directly from the object store. So not built for speed or scale.
+
+### Private?
+
+Kinda. Private pushes are simply not listed publicly. So you'll need
+the direct link to access them (much like private gists).
+
+### Configuration
+
+Configuration is a JSON file. Locations checked in order of precedence:
+
+* ./yetty
+* ~/.yetty
+* /etc/yetty/config.json
+
+File contents:
+
+```json
+{
+  "site": {
+    "url": "http://localhost:4000"
+  },
+  "user": {
+    "username": "YOUR_USERNAME",
+    "storage": {
+      "provider": "aws",
+      "bucket": "my-yetty-bucket",
+      "credentials": {
+        "aws_access_key_id": "...",
+        "aws_secret_access_key": "...",
+        "aws_bucket_region": "..."
+      }
+    }
+  }
+}
+```
+
+The `credentials` section are the credentials expected
+by miasma[3] based on the provider in use.
+
+### Thanks!
+
+A big thanks to @antono for the shelr[2] library. Also
+to @jeromeetienne for the beautiful nyancat[4]
+
+[1]: https://github.com/antono/shelr.tv "record you shell and publish it"
+[2]: https://github.com/antono/shelr "Console screencasting tool"
+[3]: https://github.com/chrisroberts/miasma "Cloud modeling library"
+[4]: https://github.com/jeromeetienne/threex.nyancat "three.js extension to make nyancat"

data/bin/yetty

@@ -23,7 +23,6 @@ begin
       description 'Push JSON recording'
       on :c, :config=, 'JSON configuration file'
       on :p, :private, 'Not publicly listed'
-      on :o, :overwrite, 'Overwrite if already exists'
       run do |opts, args|
         Yetty::Push.new({:push => opts.to_hash}, args).execute!
       end
@@ -37,11 +36,17 @@ begin
       end
     end
 
+    command 'play' do
+      description 'Play terminal'
+      run do |opts, args|
+        Yetty::Play.new({:play => opts}, args).execute!
+      end
+    end
+
     command 'user' do
-      description 'View/set user information'
-      on :c, :config=, 'JSON configuration file'
+      description 'Set user information'
       run do |opts, args|
-        Yetty::UserInfo.new({:user => opts.to_hash}, args).execute!
+        Yetty::User.new({:user => opts.to_hash}, args).execute!
       end
     end
 

data/lib/yetty.rb

@@ -0,0 +1,15 @@
+require 'yetty/version'
+
+# TTY utility
+module Yetty
+  autoload :Command, 'yetty/command'
+  autoload :Play, 'yetty/play'
+  autoload :Push, 'yetty/push'
+  autoload :Record, 'yetty/record'
+  autoload :Site, 'yetty/site'
+  autoload :Ui, 'yetty/ui'
+  autoload :User, 'yetty/user'
+end
+
+require 'miasma'
+require 'miasma/utils/smash'

data/lib/yetty/command.rb

@@ -0,0 +1,136 @@
+require 'yetty'
+
+module Yetty
+  # Abstract command class
+  class Command
+
+    # @return [Hash] options
+    attr_reader :options
+    # @return [Array] cli arguments
+    attr_reader :arguments
+    # @return [Ui]
+    attr_reader :ui
+
+    # Default configuration file locations
+    DEFAULT_CONFIGURATION_FILES = [
+      './.yetty',
+      '~/.yetty',
+      '/etc/yetty/config.json'
+    ]
+
+    # Build new command instance
+    #
+    # @return [self]
+    def initialize(opts, args)
+      @options = opts.to_smash
+      @arguments = args
+      @ui = Ui.new
+      load_config!
+    end
+
+    # Execute the command
+    #
+    # @return [TrueClass]
+    def execute!
+      raise NotImplementedError
+    end
+
+    protected
+
+    # Command specific options
+    #
+    # @return [Hash]
+    def opts
+      options.fetch(self.class.name.split('::').last.downcase, {})
+    end
+
+    # User specific options
+    #
+    # @return [Smash]
+    def user
+      result = options[:user]
+      unless(result)
+        raise 'No user information defined!'
+      else
+        result = result.to_smash
+        unless(result[:username])
+          result[:username] = ENV['USER']
+        end
+        result
+      end
+    end
+
+    # @return [Miasma::Models::Storage]
+    def storage
+      if(user[:storage])
+        Miasma.api(
+          :type => :storage,
+          :provider => user[:storage][:provider],
+          :credentials => user[:storage][:credentials]
+        )
+      else
+        raise 'No remote storage configuration found!'
+      end
+    end
+
+    # @return [Miasma::Models::Storage::Bucket]
+    def bucket
+      unless(user.get(:storage, :bucket))
+        raise 'No bucket defined within storage configuration!'
+      end
+      bucket = storage.buckets.get(user[:storage][:bucket])
+      unless(bucket)
+        bucket = storage.buckets.build
+        bucket.name = user[:storage][:bucket]
+        bucket.save
+        bucket = storage.buckets.reload.get(user[:storage][:bucket])
+      end
+      bucket
+    end
+
+    # Load configuration file and merge opts
+    # on top of file values
+    #
+    # @return [Hash]
+    def load_config!
+      if(options[:config])
+        content = File.read(options[:config])
+      else
+        path = DEFAULT_CONFIGURATION_FILES.detect do |check|
+          full_check = File.expand_path(check)
+          File.exists?(full_check)
+        end
+        content = File.read(path) if path
+      end
+      if(content)
+        @options = MultiJson.load(content).to_smash.deep_merge(options)
+      end
+    end
+
+    # Wrap action within nice text. Output resulting Hash if provided
+    #
+    # @param msg [String] message of action in progress
+    # @yieldblock action to execute
+    # @yieldreturn [Hash] result to output
+    # @return [TrueClass]
+    def run_action(msg)
+      ui.info("#{msg}... ", :nonewline)
+      begin
+        result = yield
+        ui.puts ui.color('complete!', :green, :bold)
+        if(result.is_a?(Hash))
+          ui.puts '---> Results:'
+          result.each do |k,v|
+            ui.puts "    #{ui.color("#{k}:", :bold)} #{v}"
+          end
+        end
+      rescue => e
+        ui.puts ui.color('error!', :red, :bold)
+        ui.error "Reason - #{e}"
+        raise
+      end
+      true
+    end
+
+  end
+end

data/lib/yetty/play.rb

@@ -0,0 +1,23 @@
+require 'yetty'
+require 'shelr'
+
+module Yetty
+  class Player < Shelr::Player
+  end
+end
+
+module Yetty
+  # Play command class
+  class Play < Command
+
+    # Invoke shelr record
+    def execute!
+      if(arguments.first.start_with?('http'))
+        Yetty::Player.play_remote(arguments.first)
+      else
+        Yetty::Player.play_dump(arguments.first)
+      end
+    end
+
+  end
+end

data/lib/yetty/push.rb

@@ -0,0 +1,44 @@
+require 'yetty'
+
+module Yetty
+  # Push command class
+  class Push < Command
+
+    # Push shelr json to storage
+    def execute!
+      run_action('Updating user list') do
+        file = bucket.files.get('userlist.json')
+        content = file ? MultiJson.load(file.body.readpartial).to_smash : Smash.new(:users => [])
+        unless(content[:users].include?(user[:username]))
+          content[:users].push(user[:username]).uniq!
+          file = bucket.files.build
+          file.name = 'userlist.json'
+          file.content_type = 'application/json'
+          file.body = MultiJson.dump(content)
+          file.save
+        end
+      end
+      filename = arguments.first
+      run_action("Pushing file #{filename}") do
+        key_name = File.basename(filename).sub(/\.[^\.]+$/, '')
+        file_content = File.read(filename)
+        data = MultiJson.load(file_content).to_smash
+        state = data[:private] || options[:push][:private] ? 'private' : 'public'
+        key_name = File.join(user[:username], state, "#{Time.now.to_i}-#{key_name}.json")
+        file = bucket.files.build
+        file.name = key_name
+        file.content_type = 'application/json'
+        file.body = file_content
+        file.save
+        encoded_key = Base64.urlsafe_encode64(file.name)
+        Smash.new(
+          :bucket => bucket.name,
+          :key => file.name,
+          :encoded_key => encoded_key,
+          :link => options.get(:site, :url) ? File.join(options[:site][:url], 'recording', encoded_key) : 'Not configured!'
+        )
+      end
+    end
+
+  end
+end

data/lib/yetty/record.rb

@@ -0,0 +1,73 @@
+require 'yetty'
+require 'shelr'
+
+module Yetty
+
+  class Publisher < Shelr::Publisher
+
+    attr_reader :file_name
+
+    def initialize(file_name='yetty.json')
+      @file_name = file_name
+      super()
+    end
+
+    def prepare(id)
+      out = {}
+      ['meta', 'timing', 'typescript'].each do |file|
+        out[file] = File.read(File.join(Shelr.data_dir(id), file))
+      end
+
+      meta = JSON.parse(out.delete('meta'))
+      meta.each { |k,v| out[k] = v }
+      STDOUT.print 'Description: '
+      out['description'] = STDIN.gets.strip
+      STDOUT.print 'Tags (ex: howto, linux): '
+      out['tags'] = STDIN.gets.strip
+      out['private'] = @private
+      return out.to_json
+    end
+
+    def dump_filename
+      file_name
+    end
+
+  end
+
+  class Recorder < Shelr::Recorder
+
+    def record!(options={})
+      ensure_terminal_has_good_size
+      check_record_dir
+      with_lock_file do
+        init_terminal
+        request_metadata
+        Shelr.terminal.puts_line
+        STDOUT.puts "=> Your session started"
+        STDOUT.puts "=> Please, do not resize your terminal while recording"
+        STDOUT.puts "=> Press Ctrl+D or 'exit' to finish recording"
+        Shelr.terminal.puts_line
+        start_sound_recording if options[:sound]
+        system(recorder_cmd)
+        stop_sound_recording if options[:sound]
+        save_as_typescript if Shelr.backend == 'ttyrec'
+        Shelr.terminal.puts_line
+        STDOUT.puts "=> Session finished"
+      end
+    end
+
+  end
+end
+
+module Yetty
+  # Record command class
+  class Record < Command
+
+    # Invoke shelr record
+    def execute!
+      Yetty::Recorder.record!(opts)
+      Yetty::Publisher.new(arguments.first || 'yetty.json').dump('last')
+    end
+
+  end
+end

data/lib/yetty/site.rb

@@ -0,0 +1,23 @@
+require 'yetty'
+
+module Yetty
+  class Site < Yetty::Command
+
+    autoload :App, 'yetty/site/app'
+
+    # Start the web UI
+    #
+    # @return true
+    def execute!
+      if(opts[:port])
+        App.port = opts[:port]
+      end
+      if(opts[:bind])
+        App.bind = opts[:bind]
+      end
+      App.server = options.fetch(:server, 'webrick')
+      App.run!
+    end
+
+  end
+end

data/lib/yetty/site/app.rb

@@ -0,0 +1,91 @@
+require 'base64'
+require 'sinatra/base'
+
+module Yetty
+  class Site
+    # Web UI
+    class App < Sinatra::Base
+
+      def bucket
+        storage = Miasma.api(
+          :type => :storage,
+          :provider => :aws,
+          :credentials => {
+            :aws_access_key_id => ENV['MIASMA_AWS_ACCESS_KEY_ID'],
+            :aws_secret_access_key => ENV['MIASMA_AWS_SECRET_ACCESS_KEY'],
+            :aws_region => ENV['MIASMA_AWS_REGION'],
+            :aws_bucket_region => 'us-west-2'
+          }
+        )
+        bucket = storage.buckets.get('cr-test-00')
+      end
+
+      set :public_folder, File.join(File.dirname(__FILE__), 'static')
+
+      get '/' do
+        haml :index
+      end
+
+      get '/recordings' do
+        haml :recordings
+      end
+
+      get '/recording/:info' do
+        rec_path = Base64.urlsafe_decode64(params[:info])
+        user, state, name = rec_path.split('/')
+        rec_url = bucket.files.get(rec_path).url
+        haml(
+          :recording,
+          :locals => {
+            :user => user,
+            :state => state,
+            :name => name,
+            :url => rec_url
+          }
+        )
+      end
+
+      get '/users' do
+        file = bucket.files.get('userlist.json')
+        users = file ? MultiJson.load(file.body.readpartial).to_smash[:users] : []
+        haml(
+          :users,
+          :locals => {
+            :users => users
+          }
+        )
+      end
+
+      get '/users/:username' do
+        user_file = bucket.files.get(
+          File.join(params[:username], 'userinfo.json')
+        )
+        if(user_file)
+          user_info = MultiJson.load(user_file.read).to_smash
+        else
+          user_info = Smash.new
+        end
+        prefix = [params[:username], 'public'].join('/')
+        records = bucket.files.filter(
+          :prefix => [
+            params[:username],
+            'public'
+          ].join('/')
+        )
+        haml(
+          :user,
+          :locals => {
+            :username => params[:username],
+            :user_info => user_info,
+            :records => records
+          }
+        )
+      end
+
+      get '/about' do
+        haml :about
+      end
+
+    end
+  end
+end