cf_script 0.0.1.beta.1

data/lib/cf_script/command.rb

@@ -0,0 +1,44 @@
+module CfScript::Command
+  # TODO: decide which is better, @_registry or @@_registry
+  class << self
+    attr_reader :_registry
+  end
+
+  extend CfScript::UI
+
+  module_function
+
+  def registry
+    @_registry ||= Registry.new
+  end
+
+  def register(command_class)
+    registry.add!(command_class)
+  end
+
+  def run(command_name, *args, &block)
+    registry.check!(command_name)
+
+    begin
+      registry[command_name].run(*args, &block)
+    rescue StandardError => e
+      error command_name, e.message
+    end
+  end
+
+  def method_missing(m, *args, &block)
+    run(m, *args, &block)
+  end
+end
+
+require 'cf_script/command/registry'
+require 'cf_script/command/runner'
+
+require 'cf_script/command/base'
+require 'cf_script/command/error'
+require 'cf_script/command/line'
+
+require 'cf_script/command/cf/general'
+require 'cf_script/command/cf/apps'
+require 'cf_script/command/cf/spaces'
+require 'cf_script/command/cf/routes'

data/lib/cf_script/config.rb

@@ -0,0 +1,60 @@
+class CfScript::Config
+  attr_reader :io
+  attr_reader :ui
+  attr_reader :runtime
+
+  def initialize
+    @io = CfScript::Config::IO.new
+    @ui = CfScript::Config::UI.new
+
+    @runtime = CfScript::Config::Runtime.new
+  end
+
+  class IO
+    attr_accessor :stdout
+    attr_accessor :stderr
+
+    def initialize
+      @stdout = $stdout
+      @stderr = $stderr
+    end
+  end
+
+  class UI
+    attr_accessor :tags
+    attr_accessor :emoji
+    attr_reader   :color # Special case for String.disable_colorization
+
+    def initialize
+      @tags  = true
+      @emoji = false
+      @color = true
+    end
+
+    def color=(state)
+      @color = state
+
+      if String.respond_to?(:disable_colorization)
+        String.disable_colorization = @color ? false : true
+      end
+    end
+  end
+
+  class Runtime
+    attr_accessor :trace
+    attr_accessor :color
+
+    attr_accessor :executor
+
+    def initialize
+      @trace = ENV['TRACE'] || false
+      @color = true
+
+      @executor = ENV['NON_BLOCKING_EXECUTOR'] ? CfScript::Executor::NonBlocking.new : default_executor
+    end
+
+    def default_executor
+      CfScript::Executor::Simple.new
+    end
+  end
+end

data/lib/cf_script/executor/non_blocking.rb

@@ -0,0 +1,107 @@
+require 'open3'
+
+class CfScript::Executor::NonBlocking
+  include CfScript::UI
+
+  READ_SIZE = 1024
+
+  PROGRESS_CHARS = ['|', '/', '-', '\\']
+
+  def initialize
+    @executions = 0
+    @spin_count = 0
+  end
+
+  def execute(env, command_line)
+    @spin_count = 0
+    @executions += 1
+
+    print " ...  "
+    stdout, stderr, status = execute_internal(env, command_line)
+
+    report_exit(status.exitstatus == 0 ? :success : :error)
+
+    [stdout, stderr, status]
+  end
+
+  def spin
+    char = PROGRESS_CHARS[(@spin_count += 1) % PROGRESS_CHARS.length]
+
+    print "\b#{char}".colorize(with_color_of(:step))
+  end
+
+  def got(c = '@')
+    print "\b#{c}".colorize(with_color_of(:info))
+  end
+
+  def report_exit(type)
+    icon = "#{emoji_for(type)}          "
+    text = case type
+           when :success
+             CfScript.config.ui.emoji ? icon : 'DONE '
+           else
+             CfScript.config.ui.emoji ? icon : 'ERROR'
+           end
+
+    puts "\b\b\b\b\b#{text}".colorize(with_color_of(type))
+  end
+
+  def execute_internal(env, command_line)
+    out_stdout = ''
+    out_stderr = ''
+    out_status = nil
+
+    Open3.popen3(env, command_line.to_s) do |stdin, stdout, stderr, wait|
+      stdin.close_write
+
+      begin
+        streams = [stdout, stderr]
+
+       #until streams.empty? do
+        loop do
+          ready = IO.select(streams, [], [], 0.1)
+          spin
+
+          if ready
+            readable = ready[0]
+
+            readable.each do |stream|
+              fileno = stream.fileno
+
+              begin
+                data = stream.read_nonblock(READ_SIZE)
+
+                if fileno == stdout.fileno
+                  got ; out_stdout << data
+                elsif fileno == stderr.fileno
+                  got ; out_stderr << data
+                else
+                  fileno_error(fileno, stdin, stdout, stderr)
+                end
+              rescue EOFError => e
+              # puts "EOF-ERROR".colorize(with_color_of(:error))
+              # streams.delete(stream)
+              end
+            end
+          end
+
+          break if stdout.eof? && stderr.eof?
+        end
+
+        out_status = wait.value
+      rescue IOError => e
+        puts "IOError: #{e}"
+      end
+    end
+
+    [out_stdout, out_stderr, out_status]
+  end
+
+  def fileno_error(fileno, stdin, stdout, stderr)
+    puts "ERROR: unexpected fileno: #{fileno} [" +
+        "stdin: #{stdin.fileno}, " +
+        "stdout: #{stdout.fileno}, " +
+        "stderr: #{stderr.fileno}" +
+      "]"
+  end
+end

data/lib/cf_script/executor/recorder.rb

@@ -0,0 +1,16 @@
+class CfScript::Executor::Recorder
+  def initialize(executor = nil)
+    @executions = []
+    @executor   = executor || CfScript::Executor::Simple.new
+  end
+
+  def execute(env, command_line)
+    @executions << command_line
+
+    @executor.execute(env, command_line)
+  end
+
+  def dump
+    puts @executions.join("\n")
+  end
+end

data/lib/cf_script/executor/simple.rb

@@ -0,0 +1,17 @@
+require 'open3'
+
+class CfScript::Executor::Simple
+  def initialize
+    @executions = 0
+  end
+
+  def execute(env, command_line)
+    @executions += 1
+
+    out, err, status = Open3.capture3(env, command_line.to_s)
+
+    puts if CfScript.config.runtime.trace
+
+    [out, err, status]
+  end
+end

data/lib/cf_script/executor.rb

@@ -0,0 +1,5 @@
+CfScript.const_set(:Executor, Module.new)
+
+require 'cf_script/executor/recorder'
+require 'cf_script/executor/simple'
+require 'cf_script/executor/non_blocking'

data/lib/cf_script/manifest.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'yaml'
+
+class CfScript::Manifest
+  attr_reader :filename
+  attr_reader :applications
+
+  include CfScript::Utils
+
+  FILENAME = 'manifest.yml'
+
+  def initialize(filename = FILENAME)
+    @filename = filename
+
+    @applications = load_file
+  end
+
+  def each
+    applications.each do |app|
+      yield app
+    end
+  end
+
+  private
+
+  def load_file
+    data = if File.exist?(filename)
+      YAML.load(File.open(filename))
+    else
+      { 'applications' => [] }
+    end
+
+    data['applications'].map do |app|
+      OpenStruct.new(symbolize_keys(app))
+    end
+  end
+end

data/lib/cf_script/object/api_endpoint.rb

@@ -0,0 +1,10 @@
+class CfScript::ApiEndpoint < CfScript::Object
+  attr_reader :url
+  attr_reader :version
+
+  def initialize(url = nil, version = nil)
+    @url     = url
+    @version = version
+  end
+end
+

data/lib/cf_script/object/app_info.rb

@@ -0,0 +1,69 @@
+class CfScript::AppInfo < CfScript::Object
+  # These are always available
+  attr_reader :name
+  attr_reader :requested_state
+  attr_reader :instances
+  attr_reader :urls
+
+  # These are available from `cf app` only
+  attr_reader :usage
+  attr_reader :last_uploaded
+  attr_reader :stack
+  attr_reader :buildpack
+
+  # These are available from `cf apps` only
+  attr_reader :memory # patched from :usage
+  attr_reader :disk
+
+  # This gets set after some commands, like push and start
+  attr_reader :instance_status
+
+  def initialize(name, attrs)
+    @name = name
+
+    update(attrs)
+  end
+
+  def state
+    requested_state
+  end
+
+  def started?
+    state == 'started'
+  end
+
+  alias :hot? :started?
+
+  def stopped?
+    state == 'stopped'
+  end
+
+  alias :cold? :stopped?
+
+  def update(attrs)
+    @requested_state = attrs[:requested_state].value if attrs.key?(:requested_state)
+    @instances       = attrs[:instances].value if attrs.key?(:instances)
+
+    @urls            = attrs.key?(:urls) ? attrs[:urls].to_a : []
+
+    @usage           = attrs[:usage].value if attrs.key?(:usage)
+    @last_uploaded   = attrs[:last_uploaded].value if attrs.key?(:last_uploaded)
+    @stack           = attrs[:stack].value if attrs.key?(:stack)
+    @buildpack       = attrs[:buildpack].value if attrs.key?(:buildpack)
+
+    @memory          = attrs[:memory].value if attrs.key?(:memory)
+    @disk            = attrs[:disk].value if attrs.key?(:disk)
+
+    if @memory.nil? and @usage
+      @memory = @usage.split(' ').first
+    end
+  end
+
+  def set_instance_status(instance_statuses)
+    @instance_status = []
+
+    instance_statuses.each do |instance_status|
+      @instance_status << CfScript::InstanceStatus.new(instance_status)
+    end
+  end
+end

data/lib/cf_script/object/app_list.rb

@@ -0,0 +1,24 @@
+class CfScript::AppList < CfScript::Object
+  extend Forwardable
+  include Enumerable
+
+  def initialize(list = [])
+    @list = list
+  end
+
+  def_delegators :@list, :<<, :[], :clear, :length, :each, :select
+
+  def select!(options)
+    if options[:starting_with]
+      @list.reject! { |app_info| app_info.name !~ /\A#{options[:starting_with]}/ }
+    end
+
+    if options[:state]
+      @list.reject! { |app_info| app_info.requested_state !~ /\A#{options[:state]}\z/ }
+    end
+
+    if options[:ending_with]
+      @list.reject! { |app_info| app_info.name !~ /#{options[:ending_with]}\z/ }
+    end
+  end
+end

data/lib/cf_script/object/app_spec.rb

@@ -0,0 +1,55 @@
+class CfScript::AppSpec < CfScript::Object
+  include CfScript::Callbacks
+  include CfScript::UI
+
+  def initialize(spec)
+    @org       = spec[:org]
+    @env       = spec[:env]
+    @domain    = spec[:domain]
+    @name      = spec[:name]
+    @type      = spec[:type]
+    @phase     = spec[:phase]
+    @memory    = spec[:memory] || '2GB'
+    @instances = spec[:instances] || 1
+  end
+
+  def push_options
+    {
+     #domain:             @domain,
+     #hostname:           hostname,
+      memory:             @memory,
+      instances:          @instances,
+      health_check_type:  @health_check,
+      flags: [
+        :no_route,
+        :no_start,
+        :no_manifest,
+      ]
+    }
+  end
+
+  def method_missing(m, *args, &block)
+    if args.empty? && block.nil?
+      instance_variable_get("@#{m}")
+    elsif !args.empty? && block.nil?
+      instance_variable_set("@#{m}", args.first)
+    elsif args.empty? && !block.nil?
+      instance_variable_set("@#{m}", yield)
+    else
+      raise "Can not accept arguments and a block. " +
+            "Pass arguments or a block, not both."
+    end
+  end
+
+  def full_name
+    [name, type, phase].compact.join('-')
+  end
+
+  def hostname
+    [org, env, name, type, phase].compact.join('-')
+  end
+
+  def fqdn
+    [hostname, domain].compact.join('.')
+  end
+end

data/lib/cf_script/object/attribute.rb

@@ -0,0 +1,18 @@
+class CfScript::Attribute < CfScript::Object
+  attr_reader :name, :value
+
+  def initialize(name, value)
+    @name  = name
+    @value = value
+  end
+
+  def to_a
+    value ? value.split(/,\s*/) : []
+  end
+
+  def to_s
+    "#{name}: #{value}"
+  end
+
+  alias :inspect :to_s
+end

data/lib/cf_script/object/attribute_list.rb

@@ -0,0 +1,40 @@
+class CfScript::AttributeList < CfScript::Object
+  extend Forwardable
+  include Enumerable
+
+  def_delegators :@list, :[], :key?, :empty?, :length, :clear, :each
+
+  def initialize(attributes = [])
+    @list = {}
+
+    attributes.each do |attribute|
+      self << attribute
+    end
+  end
+
+  def names
+    @list.keys
+  end
+
+  def values
+    @list.values.map { |attr| attr.value }
+  end
+
+  def <<(attr)
+    if @list.key?(attr.name)
+      raise "Duplicate attribute '#{attr.name}'"
+    end
+
+    @list[attr.name] = attr
+  end
+
+  def to_h
+    hash = {}
+
+    @list.each do |name, attr|
+      hash[name] = attr.value
+    end
+
+    hash
+  end
+end

data/lib/cf_script/object/instance_status.rb

@@ -0,0 +1,29 @@
+class CfScript::InstanceStatus < CfScript::Object
+  attr_reader :index
+  attr_reader :state
+  attr_reader :since
+  attr_reader :cpu
+  attr_reader :memory
+  attr_reader :disk
+  attr_reader :details
+
+  def initialize(attrs = {})
+    @index   = attrs[:index]   ? attrs[:index].value   : nil
+    @state   = attrs[:state]   ? attrs[:state].value   : nil
+    @since   = attrs[:since]   ? attrs[:since].value   : nil
+    @cpu     = attrs[:cpu]     ? attrs[:cpu].value     : nil
+    @memory  = attrs[:memory]  ? attrs[:memory].value  : nil
+    @disk    = attrs[:disk]    ? attrs[:disk].value    : nil
+    @details = attrs[:details] ? attrs[:details].value : nil
+  end
+
+  def show(*attrs)
+    line = []
+
+    attrs.each do |attr|
+      line << "#{attr}: #{send(attr)}"
+    end
+
+    line.join(', ')
+  end
+end

data/lib/cf_script/object/route_info.rb

@@ -0,0 +1,14 @@
+class CfScript::RouteInfo < CfScript::Object
+  attr_reader :space
+  attr_reader :host
+  attr_reader :domain
+  attr_reader :apps
+
+  def initialize(space = nil, host = nil, domain = nil, apps = [])
+    @space  = space
+    @host   = host
+    @domain = domain
+    @apps   = apps
+  end
+end
+

data/lib/cf_script/object/space.rb

@@ -0,0 +1,17 @@
+class CfScript::Space < CfScript::Object
+  attr_reader :name
+  attr_reader :org
+  attr_reader :apps
+  attr_reader :domains
+  attr_reader :services
+  attr_reader :security_groups
+
+  def initialize(name, org = nil, apps = [], domains = [], services = [], security_groups = [])
+    @name            = name
+    @org             = org
+    @apps            = apps
+    @domains         = domains
+    @services        = services
+    @security_groups = security_groups
+  end
+end

data/lib/cf_script/object/target.rb

@@ -0,0 +1,23 @@
+class CfScript::Target < CfScript::Object
+  attr_reader   :api_endpoint
+  attr_reader   :user
+  attr_reader   :org
+
+  attr_accessor :space
+
+  def initialize(api_endpoint = '', org = '', space = '', user = nil)
+    @api_endpoint = api_endpoint
+    @org          = org
+    @space        = space
+    @user         = user
+  end
+
+  def to_options
+    options = {}
+
+    options[:o] = @org   if @org and not @org.empty?
+    options[:s] = @space if @space and not @space.empty?
+
+    options
+  end
+end

data/lib/cf_script/object.rb

@@ -0,0 +1,24 @@
+require 'ostruct'
+require 'forwardable'
+
+class CfScript::Object
+  class << self
+    attr_reader :_cf_script_object_count
+  end
+
+  def initialize
+    @@_cf_script_object_count += 1
+  end
+end
+
+require 'cf_script/object/attribute'
+require 'cf_script/object/attribute_list'
+
+require 'cf_script/object/api_endpoint'
+require 'cf_script/object/app_spec'
+require 'cf_script/object/app_info'
+require 'cf_script/object/app_list'
+require 'cf_script/object/instance_status'
+require 'cf_script/object/space'
+require 'cf_script/object/target'
+require 'cf_script/object/route_info'

data/lib/cf_script/output/buffer.rb

@@ -0,0 +1,74 @@
+module CfScript
+  class Output::Buffer
+    attr_reader :raw
+
+    ANSI_ESCAPE_SEQUENCE_REGEXP = /\e\[(\d+)(;\d+)*m/
+
+    def initialize(buffer = nil)
+      @raw = buffer
+    end
+
+    def content
+      @clean_content ||= sanitize
+    end
+
+    def lines
+      @clean_lines ||= sanitize_lines
+    end
+
+    def last_line
+      lines.last
+    end
+
+    def [](arg)
+      content[arg]
+    end
+
+    def each_line(&block)
+      content.each_line(&block)
+    end
+
+    def from(pattern)
+      lines_from(pattern).join("\n")
+    end
+
+    def lines_from(pattern)
+      index = lines.find_index { |line| line =~ /#{pattern}/ }
+      index ? lines[index..-1] : []
+    end
+
+    def match(regexp)
+      content.match(regexp)
+    end
+
+    def matches?(regexp)
+      content =~ regexp ? true : false
+    end
+
+    def contains?(text)
+      matches? /#{text}/
+    end
+
+    def last_line_matches?(regexp)
+      last_line =~ regexp ? true : false
+    end
+
+    private
+
+    def sanitize
+      raw.gsub ANSI_ESCAPE_SEQUENCE_REGEXP, ''
+    end
+
+    def sanitize_line(line)
+      line.gsub! ANSI_ESCAPE_SEQUENCE_REGEXP, ''
+      line.strip!
+      line
+    end
+
+    def sanitize_lines
+      raw.lines.map! do |line|
+        sanitize_line(line)
+      end
+    end
+  end
+end