appforce-spawn 0.5.1

data/ansible/rvm.yml

@@ -0,0 +1,13 @@
+---
+- hosts: rvm
+  remote_user: "{{ ansible_user }}"
+  sudo: yes
+  roles:
+    - role: rvm_io.rvm1-ruby
+      sudo: yes
+      rvm1_user: 'synctree'
+      rvm1_install_path: '/home/synctree/.rvm'
+      rvm1_rvm_version: 'stable'
+      rvm1_install_flags: '--user-install'
+      rvm1_rubies:
+        - 'ruby-2.2.0'

data/ansible/scout.yml

@@ -0,0 +1,6 @@
+---
+- hosts: scout
+  remote_user: "{{ ansible_user }}"
+  sudo: yes
+  roles:
+    - scout

data/ansible/site.yml

@@ -0,0 +1,4 @@
+---
+- include: common.yml
+- include: rvm.yml
+- include: scout.yml

data/appforce-spawn.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'appforce/spawn/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'appforce-spawn'
+  s.version     = Appforce::Spawn::VERSION
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.summary     = "Synctree user installation tool"
+  s.description = "A gem that uses the Appforce SSH key manager API to install users on client machines."
+  s.authors     = ["Derek Smith"]
+  s.email       = 'derek@synctree.com'
+  s.homepage    = 'http://synctree.com'
+  
+  s.files         = `git ls-files`.split("\n").map {|f| f !~ /vagrant|test/ ? f : next }.compact
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "ansible"]
+
+  s.required_ruby_version = '>= 1.9.3'
+  s.add_dependency 'httparty', '~> 0.10', '>= 0.10.2'
+  s.add_dependency 'highline', '~> 1.7', '>= 1.7'
+  s.add_development_dependency "rspec", '~> 3.0'
+
+  s.license = 'Private'
+end

data/bin/appforce-spawn

@@ -0,0 +1,161 @@
+#! /usr/bin/env ruby
+
+require "optparse"
+
+$:.unshift(File.join(File.dirname(__FILE__), "/../lib"))
+require "appforce-spawn"
+
+opts = {
+  verbose: false
+}
+
+OptionParser.new do |o|
+  o.banner = "VERSION: #{Appforce::Spawn::VERSION}\nUSAGE: #{$0} [options]"
+
+  o.on("-a",
+       "--action [ACTION]",
+       "Action to perform. Use '-l' to view all available actions") do |a|
+    opts[:action] = a.downcase
+  end
+
+  o.on("-l",
+       "--list-actions",
+       "List available Actions") do |l|
+    opts[:list_actions] = true
+  end
+
+  o.on("-C",
+       "--client [CLIENT API NAME]",
+       "API Client Name to use for calls") do |cl|
+    opts[:client_api_name] = cl.downcase
+  end
+
+  o.on("-c", "--config [PATH]", "Optional custom config file") do |c|
+    opts[:config] = c
+  end
+
+  o.on("-D", 
+      "--dump-config",
+      "Generate a example config template (to ~/.appforce.example)") do |d|
+    opts[:dump_config] = true
+  end
+
+  o.on("-v", "--verbose", "If set, print verbose output") do |v|
+    opts[:verbose] = true
+  end
+
+  o.on("--version", "Show current version and latest version available on RubyGems") do |v|
+    opts[:list_version] = true
+  end
+
+  o.on("-h", "--help", "Show help documentation") do |h|
+    STDERR.puts o
+    exit
+  end
+
+end.parse!
+
+if opts[:dump_config]
+  STDERR.puts " Dumping example config temlplate..."
+  Appforce::Spawn.dump_example_config
+  STDERR.puts " File written to ~/.appforce.example"
+  STDERR.puts " You will need to replace the API token and move the file to ~/.appforce"
+  exit
+end
+
+##
+# Settiung up logger
+# TODO: Internalize this
+logger = Logger.new(STDOUT)
+opts[:verbose] ? logger.level = Logger::DEBUG : logger.level = Logger::INFO
+logger.formatter = proc do |severity, datetime, progname, msg|
+  "[#{severity}] #{datetime.strftime("%Y-%m-%d %H:%M:%S")} #{msg}\n"
+end
+Appforce::Spawn.logger = logger
+Appforce::Spawn.logger.debug "Debug logging is on."
+
+##
+# List Version
+if opts[:list_version]
+  installed = Appforce::Spawn::VERSION
+  latest = Appforce::Spawn.latest_version
+  
+  STDERR.puts " appforce-spawn gem version: #{installed}"
+  STDERR.puts " latest version available: #{latest}"
+  if latest == installed
+    STDERR.puts " You are up-to-date"
+  else
+    STDERR.puts " A new version is available. Run the following to update:"
+    STDERR.puts " gem update appforce-spawn"
+  end
+  exit
+end
+
+##
+# List actions to screen
+if opts[:list_actions]
+  STDERR.puts Appforce::Spawn.header("Avaialable Actions")
+  Appforce::Spawn.available_actions.each do |m|
+    STDERR.printf " %-20s # %s\n", m[0], m[1][:info]
+  end
+  STDERR.puts Appforce::Spawn.footer
+  exit
+end
+
+unless opts[:action]
+  STDERR.puts Appforce::Spawn.header("An Action Is Required")
+  STDERR.puts " USAGE: #{$0} [options]"
+  STDERR.puts " Use '-h' or '--help' to list all options."
+  STDERR.puts " Use '-l' or '--list-actions' to list all actions."
+  STDERR.puts Appforce::Spawn.footer
+  exit
+end
+
+unless Appforce::Spawn.available_actions.keys.include? opts[:action]
+  STDERR.puts Appforce::Spawn.header("Action '#{opts[:action]}' Not Supported")
+  STDERR.puts Appforce::Spawn.header("Avaialable Actions")
+  Appforce::Spawn.available_actions.each do |m|
+    STDERR.printf " %-20s # %s\n", m[0], m[1][:info]
+  end
+  STDERR.puts Appforce::Spawn.footer
+  exit
+end
+
+##
+# Do stuff down here
+Appforce::Spawn.load_config(opts[:config])
+if opts[:verbose]
+  logger.debug "Parameters as read from the config file:"
+  Appforce::Spawn.config.marshal_dump.keys.each {|k| logger.debug "-- #{k}: #{Appforce::Spawn.config.send(k)}"}
+end
+
+##
+# validate Client API Name before proceeding
+if opts[:client_api_name]
+  resp = Appforce::Spawn.get_clients
+  a = []
+  resp.each do |item|
+    a.push item['api_name']
+  end
+  unless a.include? opts[:client_api_name]
+    logger.fatal "-- '#{opts[:client_api_name]}' is not a valid Client API name."
+    Appforce::Spawn.clients
+    exit
+  end
+end
+
+# Execute method
+result = Appforce::Spawn.send(
+  Appforce::Spawn.available_actions[opts[:action]][:cmd],
+  ARGV.first,
+  opts)
+
+if opts[:action] =~ /hosts|users|vars|^ping/
+  STDERR.puts Appforce::Spawn.header("The YAML output from the API will be written to STDOUT below")
+  STDERR.puts "\n"
+  puts "#{result}"
+  STDERR.puts "\n"
+  STDERR.puts  STDERR.puts Appforce::Spawn.header("Action Complete")
+else
+  logger.info "Action Complete."
+end

data/lib/appforce-spawn.rb

@@ -0,0 +1 @@
+require 'appforce/spawn'

data/lib/appforce/config.rb

@@ -0,0 +1,50 @@
+module Appforce
+  class Config
+    require 'yaml'
+    require 'ostruct'
+
+    # read in config file
+    # default location is root at runtime
+    DEFAULT_CONFIG_PATH = "#{File.expand_path('~')}/.appforce"
+
+    def self.load_config(path=nil)
+      begin
+        temp = YAML::load(File.open(path.nil? ? DEFAULT_CONFIG_PATH : path))
+        @config = OpenStruct.new temp
+      rescue Exception => e
+        logger.fatal "[#{self.name}##{__method__.to_s}] Appforce::Spawn::ConfigFileParseError"\
+          " -- Config file appears to be malformed -- #{e}"
+        raise e
+      end  
+    end
+
+    def self.config
+      @config
+    end
+
+    def self.dump_example_config
+      path = "#{File.expand_path('~')}/.appforce.example"
+      h = {
+        'api_host'    => 'https://afuka.synctree.com',
+        'api_version' => 'api/v1',
+        'api_token'   => 'PUT_API_TOKEN_HERE'
+      }
+      begin
+        file = File.open(path, "w")
+        file.write(h.to_yaml)
+      rescue IOError => e
+        logger.fatal "[#{self.name}##{__method__.to_s}] Appforce::ConfigDumpError -- #{e}"
+        raise e
+      ensure
+        file.close unless file == nil
+      end
+    end
+
+    private
+
+    def self.logger
+      Appforce::Logger.logger
+    end
+
+  end
+end

data/lib/appforce/logger.rb

@@ -0,0 +1,25 @@
+module Appforce
+  class Logger
+    require 'logger'
+
+    def self.logger
+      @logger
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+    end
+
+    def self.header(str='')
+      output = ' == ' + str + ' '
+      adjust = 78 - output.length
+      adjust = adjust < 0 ? 0 : adjust
+      output << "="*adjust
+    end
+
+    def self.footer
+      " " + "="*77
+    end
+
+  end
+end

data/lib/appforce/spawn.rb

@@ -0,0 +1,312 @@
+require 'httparty'
+
+require 'appforce/config'
+require 'appforce/logger'
+require 'appforce/spawn/version'
+require 'appforce/spawn/exceptions'
+require 'appforce/spawn/api'
+require 'appforce/spawn/template'
+require 'appforce/spawn/runner'
+
+module Appforce
+  module Spawn
+
+    ##
+    # Extend module base class
+    # Allows fo r class like interactions on Module
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Define methods to extend
+    module ClassMethods
+
+      def logger
+        Appforce::Logger.logger
+      end
+
+      def logger=(logger)
+        Appforce::Logger.logger = logger
+      end
+
+      def header(input)
+        Appforce::Logger.header(input)
+      end
+
+      def footer
+        Appforce::Logger.footer
+      end
+
+      def ping_host
+        HTTParty.get("#{config.api_host}/ping")
+      end
+
+      def ping_api
+        Appforce::Spawn::Api::Call.ping
+      end
+
+      def load_config(*args)
+        Appforce::Config.load_config(*args)
+      end
+
+      def config
+        Appforce::Config.config
+      end
+
+      def clients
+        Appforce::Spawn::Api::Call.list_clients
+      end
+
+      def get_clients
+        Appforce::Spawn::Api::Call.get_clients
+      end
+
+      def get_hosts(*args)
+        Appforce::Spawn::Api::Call.get_hosts(*args)
+      end
+
+      def get_active_users(*args)
+        Appforce::Spawn::Api::Call.get_active_users(*args)
+      end
+
+      def get_inactive_users(*args)
+        Appforce::Spawn::Api::Call.get_inactive_users(*args)
+      end
+
+      def get_vars(*args)
+        Appforce::Spawn::Api::Call.get_vars(*args)
+      end
+
+      def generate(*args)
+        logger.info "[#{self.name}##{__method__.to_s}] Template Generation Starting"
+        Appforce::Spawn::Template.create_dirs(*args)
+        Appforce::Spawn::Template.copy_template(*args)
+        Appforce::Spawn::Template.download_files(*args)
+        logger.info "[#{self.name}##{__method__.to_s}] Template Generation Complete"
+      end
+
+      def spawn(*args)
+        Appforce::Spawn::Runner.can_run?
+        Appforce::Spawn::Runner.run_playbook
+      end
+
+      def display_ansible_command(*args)
+        Appforce::Spawn::Runner.can_run?
+        Appforce::Spawn::Runner.display_ansible_command
+      end
+
+      def ansible_ping(*args)
+        Appforce::Spawn::Runner.can_run?
+        Appforce::Spawn::Runner.ansible_ping
+      end
+
+      def display_ansible_ping_command(*args)
+        Appforce::Spawn::Runner.can_run?
+        Appforce::Spawn::Runner.display_ansible_ping_command
+      end
+
+      def dump_example_config(*args)
+        Appforce::Config.dump_example_config
+      end
+
+      def get_all_host_data(*args)
+        Appforce::Spawn::Api::Call.get_all_host_data(*args)
+      end
+
+      def ssh_to_host(*args)
+        Appforce::Spawn::Api::Call.ssh_to_host(*args)
+      end
+
+      def latest_version(*args)
+        Appforce::Spawn::Api::Call.latest_version
+      end
+      
+      def check_dependencies(*args)
+        Appforce::Spawn::Runner.check_dependencies
+        logger.info "[#{self.name}##{__method__.to_s}] All required Ansible checks passed."
+      end
+    end
+
+    # Extension class
+    class Basement #:nodoc:
+      include Appforce::Spawn
+    end
+
+    def self.logger
+      Basement.logger
+    end
+
+    def self.logger=(logger)
+      Basement.logger = logger
+    end
+
+    def self.header(input)
+      Basement.header(input)
+    end
+
+    def self.footer
+      Basement.footer
+    end
+
+    def self.load_config(*args, &block)
+      Basement.load_config(*args, &block)
+    end
+
+    def self.config(*args)
+      Basement.config
+    end
+
+    def self.available_actions
+      {
+        'clients' => {
+          info: "Retrieve a complete list of Clients",
+          cmd:  :clients
+        },
+        'generate' => {
+          info: "Build out the Ansible template for a Client (client API name is required)",
+          cmd:  :generate
+        },
+        'client:hosts' => {
+          info: "Retrieve a Hosts file for a Client (client API name is required)",
+          cmd:  :get_hosts
+        },
+        'client:hosts:details' => {
+          info: "Display all details about Client Hosts (client API name is required)",
+          cmd:  :get_all_host_data
+        },
+        'client:users:active' => {
+          info: "Retrieve an Active Users file for a Client (client API name is required)",
+          cmd:  :get_active_users
+        },
+        'client:users:inactive' => {
+          info: "Retrieve an Inactive Users file for a Client (client API name is required)",
+          cmd:  :get_inactive_users
+        },
+        'client:vars' => {
+          info: "Retrieve a Vars file for a Client (client API name is required)",
+          cmd:  :get_vars
+        },
+        'ping' => {
+          info: "Test connection to host and API access",
+          cmd:  :ping
+        },
+        'ping:host' => {
+          info: "Test if API is available",
+          cmd:  :ping_host
+        },
+        'ping:api' => {
+          info: "Test if you have access to the API",
+          cmd:  :ping_api
+        },
+        'spawn' => {
+          info: "Run Ansible Playbook to spawn users to Client hosts",
+          cmd:  :spawn
+        },
+        'spawn:ready?' => {
+          info: "Check to see if you have the required ansible version and roles installed",
+          cmd:  :check_dependencies
+        },
+        'spawn:command' => {
+          info: "Display Ansible command to run Playbook for a Client",
+          cmd:  :display_ansible_command
+        },
+        'spawn:ping' => {
+          info: "Ansible ping Client hosts in the 'hosts' file",
+          cmd:  :ansible_ping
+        },
+        'spawn:ping:command' => {
+          info: "Display ansible ping command",
+          cmd:  :display_ansible_ping_command
+        },
+        'ssh' => {
+          info: "Select a Host to ssh in as your User name (client API name is required)",
+          cmd:  :ssh_to_host
+        },
+      }
+    end
+
+    def self.clients(*args)
+      Basement.clients
+    end
+
+    def self.get_clients(*args)
+      Basement.get_clients
+    end
+
+    def self.get_hosts(*args)
+      Basement.get_hosts(*args)
+    end
+
+    def self.get_active_users(*args)
+      Basement.get_active_users(*args)
+    end
+
+    def self.get_inactive_users(*args)
+      Basement.get_inactive_users(*args)
+    end
+    
+    def self.get_vars(*args)
+      Basement.get_vars(*args)
+    end
+
+    def self.get_all_host_data(*args)
+      Basement.get_all_host_data(*args)
+    end
+
+    def self.generate(*args)
+      Basement.generate(*args)
+    end
+
+    def self.spawn(*args)
+      Basement.spawn
+    end
+
+    def self.display_ansible_command(*args)
+      Basement.display_ansible_command
+    end
+
+    def self.ansible_ping(*args)
+      Basement.ansible_ping
+    end
+
+    def self.display_ansible_ping_command(*args)
+      Basement.display_ansible_ping_command
+    end
+
+    def self.dump_example_config(*args)
+      Basement.dump_example_config(*args)
+    end
+
+    def self.ssh_to_host(*args)
+      Basement.ssh_to_host(*args)
+    end
+
+    def self.latest_version(*args)
+      Basement.latest_version(*args)
+    end
+    
+    def self.check_dependencies(*args)
+      Basement.check_dependencies(*args)
+    end
+
+    def self.ping(*args)
+      host = Basement.ping_host
+      api  = Basement.ping_api
+      {
+        :host => { :code => host.code, :body => host.body },
+        :api  => { :code => api.code, :body => api.body }
+      }
+    end
+
+    def self.ping_host(*args)
+      host = Basement.ping_host
+      { :code => host.code, :body => host.body }
+    end
+
+    def self.ping_api(*args)
+      api = Basement.ping_api
+      { :code => api.code, :body => api.body }
+    end
+
+  end
+end