fleetctl 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd025b42bf812102d80c3ded567acf7a5f3759bd
+  data.tar.gz: d51ee078697bbd24bbe9486d99f3521571ac99be
+SHA512:
+  metadata.gz: c38239fb5798ad2616d91089e5f5d1633e368c67245fae29b1322fde08a725301af40182f3687a2d62a108df76c206ca9930148192961f8bfe031db7eea4875a
+  data.tar.gz: 7ab0ec882dbe5f63584898c5f7495e348e1634adb6bddaf124e19a5cab49f032cdb75fbfa6530c11cea35f17bf49d74253868c09bfc7af413c81035731289eb1

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fleetctl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Josh Lauer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# Fleetctl
+
+Fleetctl is a gem for remotely controlling a fleet cluster on CoreOS. The gem executes all commands remotely on the fleet hosts via SSH, rather than using the `fleetctl` executable. At the time of this writing, this has proven to be more stable than using the native executable's `--tunnel` flag.
+
+Warning: This gem is essentially a wrapper for an executable that is still in alpha. Things are changing rapidly. It is known to work in one specific context. Use at your own risk. Future updates will be more stable.
+
+## Installation and Configuration
+
+Add Fleetctl to your Gemfile:
+
+    gem 'fleetctl', git: 'https://github.com/josh-lauer/ruby-fleetctl', tag: 'v0.1.0'
+
+And `$ bundle install`
+
+###Configure Fleetctl:
+
+All configuration options in Fleetctl are currently global. Just pass a hash to `Fleetctl.config` with the appropriate options included, like so:
+
+    Fleetctl.config({
+      # insert configuration options here
+    })
+
+The options, with default values, are as follows:
+
+    # a hash of global flags to be passed to the fleetctl executable.
+    global: {}
+
+    # the path to the fleetctl executable on the fleet hosts. (go ahead and move or rename it, weirdo)
+    executable: 'fleetctl'
+
+    # the logger for fleet to use. Pass it Rails.logger if you are in a rails application
+    logger: Logger.new(STDOUT)
+
+    # a string or array of strings to be prepended to the fleetctl command to be executed
+    # on the remote fleet host. use this if you need to set environment variables and the like.
+    command_prefix: nil
+
+    # a discovery url to use to locate the fleet hosts.
+    discovery_url: nil
+
+    # the IP of any of the fleet hosts to use for discovery
+    fleet_host: nil
+
+    # the user to use when SSH'ing to the fleet hosts
+    fleet_user: 'core'
+
+    # options to pass varbatim to Net::SSH and Net::SCP
+    ssh_options: {}
+
+    # temp directory to be used on the fleet hosts
+    remote_temp_dir: '/tmp'
+
+At a minumum, either :fleet_host or :discovery_url must be provided in order to contact the cluster. If both are used, the discovery_url will be used as a fallback if the fleet_host specified cannot be reached.
+
+## Usage
+To use Fleetctl, first create a `Fleetctl::Controller`
+
+A controller can be instantiated like this...
+
+    fleet = Fleetctl.new
+    => #<Fleet::Controller...>
+
+... or you can use a global singleton instance, like so:
+
+    fleet = Fleetctl.instance
+    => #<Fleet::Controller...>
+
+You can also call the methods `:instance`, `:machines`, `:units`, `:[]`, `:sync`, `:start`, `:submit`, `:load`, and `:destroy` on `Fleetctl` directly, and they will be passed to the singleton instance. More on them below.
+
+In either case, Fleetctl caches its state in order to avoid repeatedly querying the cluster. When actions that would change the state are taken (such as publishing or deleting units) the cache is refreshed. In order to manually trigger a refresh, call:
+
+    fleet.sync
+    => true
+
+To get an array of all the units on the cluster:
+
+    fleet.units
+    => [#<Fleet::Unit...>, #<Fleet::Unit...>, ...]
+
+To get an array of all the machines that comprise the cluster:
+
+    fleet.machines
+    => [#<Fleet::Machine...>, #<Fleet::Machine...>, ...]
+
+To get a specific unit by name:
+
+    fleet['my-unit.service']
+    => #<Fleet::Unit...>
+
+The `:start`, `:load`, and `:submit` methods all operate on one or more `File` objects (fleet unitfiles).
+    unitfile = File.open('my-unit.service')
+    fleet.submit(unitfile)
+    => true
+
+To remove one or more units from the cluster, call `:destroy` on the controller, and pass in the name
+or names of the units you wish to destroy
+
+    fleet.destroy('my-unit.service')
+    => true
+
+### Working with units
+
+A `Fleet::Unit` represents a unitfile and its accompanying docker container, if any.
+
+### Working with machines
+
+A `Fleet::Machine` represents a machine which is part of a fleet cluster.
+
+#### More Documentation pending
+
+## Contributing
+
+1. Fork it ( https://github.com/josh-lauer/fleetctl/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/fleetctl.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fleetctl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fleetctl'
+  spec.version       = Fleetctl::VERSION
+  spec.authors       = ['Josh Lauer']
+  spec.email         = ['jlauer@cloudspace.com']
+  spec.summary       = %q{A simple wrapper for fleetctl}
+  spec.description   = %q{Allows controlling fleet clusters via a ruby API}
+  spec.homepage      = 'https://github.com/josh-lauer/ruby-fleetctl'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_dependency 'hashie', '= 3.0.0'
+  spec.add_dependency 'net-ssh', '= 2.9.1'
+  spec.add_dependency 'net-scp', '= 1.2.1'
+end

data/lib/fleet/cluster.rb

@@ -0,0 +1,78 @@
+module Fleet
+  class Cluster < Fleet::ItemSet
+    attr_accessor :controller
+
+    def initialize(*args, controller: nil)
+      @controller = controller
+      super(*args)
+    end
+
+    def fleet_hosts
+      map(&:ip)
+    end
+
+    def fleet_host
+      fleet_hosts.sample
+    end
+
+    def machines
+      discover! if empty?
+      to_a
+    end
+
+    # attempts to rebuild the cluster from any of the hosts passed as arguments
+    # returns the first ip that worked, else nil
+    def build_from(*ip_addrs)
+      ip_addrs = [*ip_addrs].flatten.compact
+      begin
+        Fleetctl.logger.info 'building from hosts: ' + ip_addrs.inspect
+        built_from = ip_addrs.detect { |ip_addr| fetch_machines(ip_addr) }
+        Fleetctl.logger.info 'built successfully from host: ' + built_from.inspect if built_from
+        built_from
+      rescue => e
+        Fleetctl.logger.error 'ERROR building from hosts: ' + ip_addrs.inspect
+        Fleetctl.logger.error e.message
+        Fleetctl.logger.error e.backtrace.join("\n")
+        nil
+      end
+    end
+
+    # attempts a list-machines action on the given host.
+    # returns true if successful, else false
+    def fetch_machines(host)
+      Fleetctl.logger.info 'Fetching machines from host: '+host.inspect
+      clear
+      Fleetctl::Command.new('list-machines', '-l') do |runner|
+        runner.run(host: host)
+        new_machines = parse_machines(runner.output)
+        if runner.exit_code == 0
+          return true
+        else
+          return false
+        end
+      end
+    end
+
+    def parse_machines(raw_table)
+      machine_hashes = Fleetctl::TableParser.parse(raw_table)
+      machine_hashes.map do |machine_attrs|
+        machine_attrs[:id] = machine_attrs.delete(:machine)
+        machine_attrs[:cluster] = self
+        add_or_find(Fleet::Machine.new(machine_attrs))
+      end
+    end
+
+    # attempts to rebuild the cluster by the specified fleet host, then hosts that it
+    # has built previously, and finally by using the discovery url
+    def discover!
+      known_hosts = [Fleetctl.options.fleet_host] | fleet_hosts.to_a
+      clear
+      success_host = build_from(known_hosts) || build_from(Fleet::Discovery.hosts)
+      if success_host
+        Fleetctl.logger.info 'Successfully recovered from host: ' + success_host.inspect
+      else
+        Fleetctl.logger.info 'Unable to recover!'
+      end
+    end
+  end
+end

data/lib/fleet/controller.rb

@@ -0,0 +1,115 @@
+module Fleet
+  class Controller
+    attr_writer :units
+    attr_accessor :cluster
+
+    def initialize
+      @cluster = Fleet::Cluster.new(controller: self)
+    end
+
+    # returns an array of Fleet::Machine instances
+    def machines
+      cluster.machines
+    end
+
+    # returns an array of Fleet::Unit instances
+    def units
+      return @units.to_a if @units
+      machines
+      fetch_units
+      @units.to_a
+    end
+
+    # refreshes local state to match the fleet cluster
+    def sync
+      build_fleet
+      fetch_units
+      true
+    end
+
+    # find a unitfile of a specific name
+    def [](unit_name)
+      units.detect { |u| u.name == unit_name }
+    end
+
+    # accepts one or more File objects, or an array of File objects
+    def start(*unit_file_or_files)
+      unitfiles = [*unit_file_or_files].flatten
+      out = unitfile_operation(:start, unitfiles)
+      clear_units
+      out
+    end
+
+    # accepts one or more File objects, or an array of File objects
+    def submit(*unit_file_or_files)
+      unitfiles = [*unit_file_or_files].flatten
+      out = unitfile_operation(:submit, unitfiles)
+      clear_units
+      out
+    end
+
+    # accepts one or more File objects, or an array of File objects
+    def load(*unit_file_or_files)
+      unitfiles = [*unit_file_or_files].flatten
+      out = unitfile_operation(:load, unitfiles)
+      clear_units
+      out
+    end
+
+    def destroy(*unit_names)
+      runner = Fleetctl::Command.run('destroy', unit_names)
+      clear_units
+      runner.exit_code == 0
+    end
+
+    private
+
+    def build_fleet
+      cluster.discover!
+    end
+
+    def fleet_host
+      cluster.fleet_host
+    end
+
+    def clear_units
+      @units = nil
+    end
+
+    def unitfile_operation(command, files)
+      clear_units
+      if Fleetctl.options.runner_class.to_s == 'Shell'
+        runner = Fleetctl::Command.run(command.to_s, files.map(&:path))
+      else
+        runner = nil
+        Fleetctl::RemoteTempfile.open(*files) do |*remote_filenames|
+          runner = Fleetctl::Command.run(command.to_s, remote_filenames)
+        end
+      end
+      runner.exit_code == 0
+    end
+
+    def fetch_units(host: fleet_host)
+      Fleetctl.logger.info 'Fetching units from host: '+host.inspect
+      @units = Fleet::ItemSet.new
+      Fleetctl::Command.new('list-units', '-l') do |runner|
+        runner.run(host: host)
+        parse_units(runner.output)
+      end
+      @units.to_a
+    end
+
+    def parse_units(raw_table)
+      unit_hashes = Fleetctl::TableParser.parse(raw_table)
+      unit_hashes.each do |unit_attrs|
+        if unit_attrs[:machine]
+          machine_id, machine_ip = unit_attrs[:machine].split('/')
+          unit_attrs[:machine] = cluster.add_or_find(Fleet::Machine.new(id: machine_id, ip: machine_ip))
+        end
+        unit_attrs[:name] = unit_attrs.delete(:unit)
+        unit_attrs[:controller] = self
+        @units.add_or_find(Fleet::Unit.new(unit_attrs))
+      end
+    end
+  end
+end

data/lib/fleet/discovery.rb

@@ -0,0 +1,30 @@
+module Fleet
+  class Discovery
+    class << self
+      def hosts
+        new(discovery_url).hosts
+      end
+    end
+
+    attr_accessor :discovery_url
+
+    def initialize(discovery_url = Fleetctl.options.discovery_url)
+      @discovery_url = discovery_url
+    end
+
+    def data
+      @data ||= JSON.parse(Net::HTTP.get(URI.parse(@discovery_url)))
+    end
+
+    def hosts
+      begin
+        data['node']['nodes'].map{|node| node['value'].split(':')[0..1].join(':').split('//').last}
+      rescue => e
+        Fleetctl.logger.error 'ERROR in Fleet::Discovery#hosts, returning empty set'
+        Fleetctl.logger.error e.message
+        Fleetctl.logger.error e.backtrace.join("\n")
+        []
+      end
+    end
+  end
+end

data/lib/fleet/item_set.rb

@@ -0,0 +1,13 @@
+module Fleet
+  class ItemSet < Set
+    def add_or_find(obj)
+      res = self.detect { |member| member == obj }
+      if res
+        res
+      else
+        add(obj)
+        obj
+      end
+    end
+  end
+end

data/lib/fleet/machine.rb

@@ -0,0 +1,33 @@
+module Fleet
+  class Machine
+    attr_reader :cluster, :id, :ip, :metadata
+
+    def initialize(cluster: nil, id: nil, ip: nil, metadata: nil)
+      @cluster = cluster
+      @id = id
+      @ip = ip
+      @metadata = metadata
+    end
+
+    def controller
+      cluster.controller
+    end
+
+    def units
+      controller.units.select { |unit| unit.machine.id == id }
+    end
+
+    # run the command (string, array of command + args, whatever) and return stdout
+    def ssh(*command, port: 22)
+      runner = Fleetctl::Runner::SSH.new([*command].flatten.compact.join(' '))
+      runner.run(host: ip, ssh_options: { port: port })
+      runner.output
+    end
+
+    def ==(other_machine)
+      id == other_machine.id && ip == other_machine.ip
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/fleet/unit.rb

@@ -0,0 +1,81 @@
+module Fleet
+  class Unit
+    # http://linuxrackers.com/doku.php?id=fedora_systemd_services
+    # LOAD   = Reflects whether the unit definition was properly loaded.
+    # ACTIVE = The high-level unit activation state, i.e. generalization of SUB.
+    # SUB    = The low-level unit activation state, values depend on unit type.
+    attr_reader :controller, :name, :state, :load, :active, :sub, :desc, :machine
+
+    def initialize(controller:, name:, state:, load:, active:, sub:, desc:, machine:)
+      @controller = controller
+      @name = name
+      @state = state
+      @load = load
+      @active = active
+      @sub = sub
+      @machine = machine
+    end
+
+    [:status, :destroy, :stop, :start, :cat, :unload].each do |method_name|
+      define_method(method_name) do
+        cmd = Fleetctl::Command.new(method_name, self.name)
+        runner = cmd.run(host: ip)
+        runner.output
+      end
+    end
+
+    def ip
+      machine && machine.ip
+    end
+
+    def creating?
+      active == 'activating' && sub == 'start-pre'
+    end
+
+    def failed?
+      active == 'failed' && sub == 'failed'
+    end
+
+    def running?
+      active == 'active' && sub == 'running'
+    end
+
+    # run the command on host (string, array of command + args, whatever) and return stdout
+    def ssh(*command, port: 22)
+      runner = Fleetctl::Runner::SSH.new([*command].flatten.compact.join(' '))
+      runner.run(host: ip, ssh_options: { port: port })
+      runner.output
+    end
+
+    # gets the external port mapped to port 22 inside this unit's docker container
+    # assumes that this unit corresponds to a docker container
+    def container_ssh_port(container_name = name)
+      return @container_ssh_port if defined? @container_ssh_port
+      docker_runner = Fleetctl::Runner::SSH.new('docker', 'port', container_name, 22)
+      docker_runner.run(host: ip)
+      @container_ssh_port = docker_runner.output.split(':').last.rstrip
+    end
+
+    # TODO: GET THIS WORKING
+    # # attempts to execute a command via ssh directly on the container
+    # # assumes that this unit corresponds to a docker container
+    # def container_ssh(*command, container_name: name, key: Dir.home+'/.ssh/id_rsa', username: 'root', password: nil)
+    #   cmd_runner = Fleetctl::Runner::SSH.new([*command].flatten.compact.join(' '))
+    #   cmd_runner.run(host: ip, ssh_options: { port: container_ssh_port(container_name), keys: [*key], username: username, password: password})
+    #   runner.output
+    # end
+
+    # returns a JSON object representing the container
+    # assumes that this unit corresponds to a docker container
+    def docker_inspect(container_name = name)
+      raw = ssh('docker', 'inspect', container_name)
+      JSON.parse(raw)
+    end
+
+    def ==(other_unit)
+      name == other_unit.name
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/fleetctl/command.rb

@@ -0,0 +1,45 @@
+module Fleetctl
+  class Command
+    attr_accessor :command
+
+    class << self
+      def run(*cmd, &blk)
+        obj = new(*cmd, &blk)
+        obj.run
+      end
+    end
+
+    def initialize(*cmd)
+      @command = cmd
+      yield(runner) if block_given?
+    end
+
+    def run(*args)
+      runner.run(*args)
+      runner
+    end
+
+    def runner
+      klass = "Fleetctl::Runner::#{Fleetctl.options.runner_class}".constantize
+      @runner ||= klass.new(expression)
+    end
+
+    private
+
+    def global_options
+      Fleetctl.options.global.map { |k,v| "--#{k.to_s.gsub('_','-')}=#{v}" }
+    end
+
+    def prefix
+      Fleetctl.options.command_prefix
+    end
+
+    def executable
+      Fleetctl.options.executable
+    end
+
+    def expression
+      [prefix, executable, global_options, command].flatten.compact.join(' ')
+    end
+  end
+end

data/lib/fleetctl/options.rb

@@ -0,0 +1,30 @@
+module Fleetctl
+  class Options < Hashie::Mash
+    def initialize(*)
+      deep_merge!(Hashie::Mash.new(defaults))
+      super
+    end
+
+    def defaults
+      {
+        global: {},
+        executable: 'fleetctl',
+        logger: Logger.new(STDOUT),
+        runner_class: 'SSH',
+        command_prefix: nil,
+        discovery_url: nil,
+        
+        # for use with runner_class: 'SSH'
+        # these aren't used wih a Shell runner
+        fleet_host: nil,
+        fleet_user: 'core',
+        ssh_options: {},
+        remote_temp_dir: '/tmp'
+      }
+    end
+
+    def ssh_options
+      self[:ssh_options].symbolize_keys
+    end
+  end
+end

data/lib/fleetctl/remote_tempfile.rb

@@ -0,0 +1,12 @@
+module Fleetctl
+  class RemoteTempfile
+    class << self
+      def open(local_file)
+        remote_path = File.join(Fleetctl.options.remote_temp_dir, File.basename(local_file.path))
+        Net::SCP.upload!(Fleetctl.options.fleet_host, Fleetctl.options.fleet_user, local_file.path, remote_path, :ssh => Fleetctl.options.ssh_options)
+        yield(remote_path)
+        Net::SSH.start(Fleetctl.options.fleet_host, Fleetctl.options.fleet_user, Fleetctl.options.ssh_options) { |ssh| ssh.exec!("rm #{remote_path}") }
+      end
+    end
+  end
+end

data/lib/fleetctl/runner/runner.rb

@@ -0,0 +1,19 @@
+module Fleetctl
+  module Runner
+    class Runner
+      attr_reader :command, :status, :exit_code, :stdout_data, :stderr_data, :exit_signal
+
+      def initialize(*command)
+        @command = [*command].flatten.compact.join(' ')
+      end
+
+      def run(*)
+        fail NotImplementedError
+      end
+
+      def output
+        @output || run
+      end
+    end
+  end
+end

data/lib/fleetctl/runner/shell.rb

@@ -0,0 +1,18 @@
+module Fleetctl
+  module Runner
+    class Shell < ::Fleetctl::Runner::Runner
+      def run(*)
+        return @output if @output
+        Fleetctl.logger.info "#{self.class.name} RUNNING: #{command}"
+        @stdout_data = `#{command}`
+        @status = $?
+
+        @exit_signal = @status.termsig
+        @exit_code = @status.exitstatus
+        Fleetctl.logger.info "EXIT CODE!: #{@exit_code.inspect}"
+        Fleetctl.logger.info "STDOUT: #{@output.inspect}"
+        @output = @stdout_data
+      end
+    end
+  end
+end

data/lib/fleetctl/runner/ssh.rb

@@ -0,0 +1,51 @@
+module Fleetctl
+  module Runner
+    class SSH < ::Fleetctl::Runner::Runner
+      def run(host: Fleetctl.options.fleet_host, user: Fleetctl.options.fleet_user, ssh_options: {})
+        begin
+          ssh_options = Fleetctl.options.ssh_options.merge(ssh_options)
+          # return @output if @output
+          Fleetctl.logger.info "#{self.class.name} #{user}@#{host} RUNNING: #{command.inspect}"
+          Net::SSH.start(host, user, ssh_options) do |ssh|
+            @stdout_data = ''
+            @stderr_data = ''
+            @exit_code = nil
+            @exit_signal = nil
+            ssh.open_channel do |channel|
+              channel.exec(command) do |ch, success|
+                unless success
+                  abort "FAILED: couldn't execute command (ssh.channel.exec)"
+                end
+                channel.on_data do |ch,data|
+                  @stdout_data+=data
+                end
+
+                channel.on_extended_data do |ch,type,data|
+                  @stderr_data+=data
+                end
+
+                channel.on_request('exit-status') do |ch,data|
+                  @exit_code = data.read_long
+                end
+
+                channel.on_request('exit-signal') do |ch, data|
+                  @exit_signal = data.read_long
+                end
+              end
+            end
+            ssh.loop
+            @output = @stdout_data
+          end
+          Fleetctl.logger.info "EXIT CODE!: #{exit_code.inspect}"
+          Fleetctl.logger.info "STDOUT: #{@output.inspect}"
+          @output
+        rescue => e
+          Fleetctl.logger.error 'ERROR in Runner#run'
+          Fleetctl.logger.error e.message
+          Fleetctl.logger.error e.backtrace.join("\n")
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/fleetctl/table_parser.rb

@@ -0,0 +1,32 @@
+module Fleetctl
+  class TableParser
+    attr_accessor :raw
+
+    class << self
+      def parse(raw)
+        self.new(raw).parse
+      end
+    end
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def parse
+      rows = raw.split("\n").map { |row| row.split(/\t+/) }
+      header = rows.shift
+      if header
+        keys = header.map { |key| key.downcase.to_sym }
+        [].tap do |output|
+          rows.each do |row|
+            scrubbed_row = row.map { |val| val == '-' ? nil : val }
+            output << Hash[keys.zip(scrubbed_row)]
+          end
+        end
+      else
+        Fleetctl.logger.error('ERROR in Fleetctl::TableParser.parse - no header row found')
+        []
+      end
+    end  
+  end
+end

data/lib/fleetctl/version.rb

@@ -0,0 +1,3 @@
+module Fleetctl
+  VERSION = '0.1.1'
+end

data/lib/fleetctl.rb

@@ -0,0 +1,48 @@
+require 'net/ssh'
+require 'net/scp'
+require 'hashie'
+
+require 'fleetctl/version'
+require 'fleetctl/command'
+require 'fleetctl/runner/runner'
+require 'fleetctl/runner/ssh'
+require 'fleetctl/runner/shell'
+require 'fleetctl/table_parser'
+require 'fleetctl/options'
+require 'fleetctl/remote_tempfile'
+
+require 'fleet/item_set'
+require 'fleet/unit'
+require 'fleet/machine'
+require 'fleet/controller'
+require 'fleet/discovery'
+require 'fleet/cluster'
+
+module Fleetctl
+  class << self
+    extend Forwardable
+    def_delegators :instance, :machines, :units, :[], :sync, :start, :submit, :load, :destroy
+  
+    attr_reader :options
+
+    # use if you might need more than one fleet
+    def new(*args)
+      Fleet::Controller.new(*args)
+    end
+
+    # get the global singleton controller
+    def instance
+      @instance ||= Fleet::Controller.new
+    end
+
+    # set global configuration options
+    def config(cfg)
+      @options = Options.new(cfg)
+    end
+
+    # set the logger for fleet to use
+    def logger
+      options.logger
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: fleetctl
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Josh Lauer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.9.1
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+description: Allows controlling fleet clusters via a ruby API
+email:
+- jlauer@cloudspace.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fleetctl.gemspec
+- lib/fleet/cluster.rb
+- lib/fleet/controller.rb
+- lib/fleet/discovery.rb
+- lib/fleet/item_set.rb
+- lib/fleet/machine.rb
+- lib/fleet/unit.rb
+- lib/fleetctl.rb
+- lib/fleetctl/command.rb
+- lib/fleetctl/options.rb
+- lib/fleetctl/remote_tempfile.rb
+- lib/fleetctl/runner/runner.rb
+- lib/fleetctl/runner/shell.rb
+- lib/fleetctl/runner/ssh.rb
+- lib/fleetctl/table_parser.rb
+- lib/fleetctl/version.rb
+homepage: https://github.com/josh-lauer/ruby-fleetctl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple wrapper for fleetctl
+test_files: []