puppetfactory 0.4.0

data/lib/puppetfactory/cli.rb

@@ -0,0 +1,114 @@
+require 'yaml'
+require 'puppetfactory'
+require 'json'
+require 'httparty'
+
+class Puppetfactory
+  class Cli
+    def initialize(options = {})
+      if options[:server]
+        @server = options[:server]
+      else
+        @server = 'localhost'
+      end
+      @server = "http://#{@server}:#{options[:port]}" unless @server.start_with? 'http'
+      @master = options[:master]
+      @debug  = options[:debug]
+    end
+
+    def list()
+      begin
+        puts ' Username        Sandbox URL                   Certname                 Container | Node Group'
+        response = HTTParty.get("#{@server}/api/users")
+        raise "PuppetFactory service not responding: #{@server}" unless response.code == 200
+
+        JSON.parse(response.body).each do |user, params|
+          container = params['container_status']['Dead'] ? 'X' : '+' rescue '?'
+          nodegroup = params['node_group_url'].nil?      ? 'X' : '+'
+          printf("%-14s  https://%s%10s        %-25s     %1s          %1s\n", user, @master, params['url'], params['certname'], container, nodegroup)
+        end
+      rescue => e
+        puts "API error listing users: #{e.message}"
+        puts e.backtrace if @debug
+      end
+    end
+
+    def create(user, password)
+      begin
+        params = {
+          body: {
+            username: user,
+            password: password
+          }
+        }
+        response = HTTParty.post("#{@server}/api/users", params)
+        raise "PuppetFactory error: #{response.body}" unless response.code == 200
+
+        data = JSON.parse(response.body)
+        raise data['message'] unless data['status'] == 'success'
+
+        puts "User #{user} created."
+      rescue => e
+        puts "API error creating user #{user}: #{e.message}"
+        puts e.backtrace if @debug
+      end
+    end
+
+    def delete(user)
+      begin
+        response = HTTParty.delete("#{@server}/api/users/#{user}")
+        raise "Puppetfactory error: #{response.body}" unless response.code == 200
+
+        data = JSON.parse(response.body)
+        raise data['message'] unless data['status'] == 'success'
+
+        puts "User #{user} deleted."
+      rescue => e
+        puts "API error deleting user #{user}: #{e.message}"
+        puts e.backtrace if @debug
+      end
+    end
+
+    def repair(user)
+      begin
+        response = HTTParty.put("#{@server}/api/users/#{user}",
+                                { body: {
+                                    username: user,
+                                    action: "repair"}
+                                })
+        raise "Puppetfactory error: #{response.body}" unless response.code == 200
+
+        data = JSON.parse(response.body)
+        raise data['message'] unless data['status'] == 'success'
+
+        puts "User #{user} repaired."
+      rescue => e
+        puts "API error repair user #{user}: #{e.message}"
+        puts e.backtrace if @debug
+      end
+    end
+    def redeploy(user)
+      begin
+        response = HTTParty.put("#{@server}/api/users/#{user}",
+                                { body: {
+                                    username: user,
+                                    action: "redeploy"}
+                                })
+        raise "Puppetfactory error: #{response.body}" unless response.code == 200
+
+        data = JSON.parse(response.body)
+        raise data['message'] unless data['status'] == 'success'
+
+        puts "User #{user} repaired."
+      rescue => e
+        puts "API error redeploying environment #{user}: #{e.message}"
+        puts e.backtrace if @debug
+      end
+    end
+
+    def test()
+      require 'pry'
+      binding.pry
+    end
+  end
+end

data/lib/puppetfactory/dashboard/rake_tasks.rb

@@ -0,0 +1,69 @@
+require 'json'
+require 'rake'
+require 'rspec/core/rake_task'
+
+task :spec    => 'spec:all_agents'
+task :default => :spec
+
+desc "List all available tests"
+task :list do
+  Dir.glob('spec/*').sort.each do |dir|
+    puts File.basename(dir, '_spec.rb')
+  end
+end
+
+desc "Run each test and summarize their output"
+task :generate => [:spec] do
+  output = {'timestamp' => Time.now}
+  Dir.glob("output/json/*.json") do |file|
+    name = File.basename(file, '.json')
+    data = JSON.parse(File.read(file)) rescue {}
+    output[name] ||= {}
+    output[name]['summary'] = data['summary']
+  end
+
+  Dir.glob("output/json/*/*.json") do |file|
+    current, name = file.chomp('.json').split('/').last(2)
+    data = JSON.parse(File.read(file)) rescue {}
+    output[name] ||= {}
+    output[name][current] = data['summary']
+  end
+
+  File.write('output/summary.json', output.to_json)
+end
+
+namespace :spec do
+  targets = []
+  Dir.glob('/etc/puppetlabs/code/environments/*').each do |dir|
+    next unless File.directory?(dir)
+    next unless dir.end_with? '_production'
+    target = File.basename(dir.sub('_production', ''))
+    targets << target
+  end
+  task :all_agents => targets
+
+  if ENV.include? 'current_test'
+    test    = ENV['current_test']
+    html    = "output/html/#{test}"
+    json    = "output/json/#{test}"
+    pattern = "spec/#{test}_spec.rb"
+  else
+    html    = "output/html"
+    json    = "output/json"
+    pattern = "spec/*_spec.rb"
+  end
+
+  FileUtils.mkdir_p html
+  FileUtils.mkdir_p json
+
+  targets.each do |target|
+    desc "Run Puppetfactory tests for #{target}"
+    RSpec::Core::RakeTask.new(target.to_sym) do |t|
+      ENV['TARGET_HOST'] = target
+      t.verbose = false
+      t.fail_on_error = false
+      t.rspec_opts = "--format html --out #{html}/#{target}.html --format json --out #{json}/#{target}.json"
+      t.pattern = pattern
+    end
+  end
+end

data/lib/puppetfactory/dashboard/serverspec_helper.rb

@@ -0,0 +1,84 @@
+require 'serverspec'
+require "docker"
+
+set :backend, :docker
+username = ENV['TARGET_HOST']
+
+set :docker_container, Docker::Container.get(username).id
+
+# Serverspec types and matchers below. Until we decide to gemify them :)
+
+# This defines the method used to build the test case
+def puppet
+  Serverspec::Type::Puppet.new()
+end
+
+module Serverspec::Type
+  class Puppet < Base
+
+    def initialize
+      super
+      return unless @settings.nil?
+
+      @settings = {}
+      data = @runner.run_command('puppet agent --configprint all').stdout
+      data.split("\n").each do |line|
+        key, value = line.split(' = ')
+        @settings[key.to_sym] = value
+
+        self.class.send(:define_method, key) { value }
+        #define_method(key) { value }
+      end
+    end
+
+    def to_s
+      'Puppet managed attributes'
+    end
+
+    def enabled?
+      not disabled?
+    end
+
+    def disabled?
+      @runner.check_file_is_file(@settings[:agent_disabled_lockfile])
+    end
+
+    def has_signed_cert?
+      @runner.check_file_is_file(@settings[:hostcert])
+    end
+
+    def has_run_puppet?
+      @runner.check_file_is_file(@settings[:lastrunreport])
+    end
+
+    def classified_with?(klass)
+      #@runner.check_file_contains(@settings[:classfile], /^klass$/)
+      @classfile ||= @runner.get_file_content(@settings[:classfile]).stdout
+      @classfile =~ /^#{klass}$/
+    end
+
+    def has_resource?(resource)
+      #@runner.check_file_contains(@settings[:resourcefile], resource)
+      @resourcefile ||= @runner.get_file_content(@settings[:resourcefile]).stdout
+
+      case resource
+      when String
+        @resourcefile.include? resource
+      when Regexp
+        @resourcefile =~ /^#{resource}$/
+      else
+        false
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :manage_resource do |resource|
+  match do |subject|
+    if subject.class.name == 'Serverspec::Type::Puppet'
+      subject.has_resource?(resource)
+    else
+      raise "The 'manage_resource' matcher does not support #{subject.class.name}."
+    end
+  end
+end

data/lib/puppetfactory/dashboard/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rspec-puppet'
+# we can't use psh, because it declares things that conflict with serverspec
+
+username = ENV['TARGET_HOST']
+environmentpath = "/etc/puppetlabs/code/environments"
+
+if File.directory? "#{environmentpath}/#{username}_production"
+  environment = "#{username}_production"
+else
+  environment = username
+end
+
+RSpec.configure do |c|
+  c.environmentpath = environmentpath
+  c.module_path     = "#{environmentpath}/#{environment}/site"
+  c.manifest        = "#{environmentpath}/#{environment}/manifests"
+
+  # Adds to the built in defaults from rspec-puppet
+  c.default_facts = {
+    :ipaddress                 => '127.0.0.1',
+    :kernel                    => 'Linux',
+    :operatingsystem           => 'CentOS',
+    :operatingsystemmajrelease => '7',
+    :osfamily                  => 'RedHat',
+  }
+end

data/lib/puppetfactory/helpers.rb

@@ -0,0 +1,37 @@
+require 'puppetfactory'
+
+class Puppetfactory::Helpers
+
+  def self.configure(options)
+    @@options = options
+  end
+
+  def self.environment_name(username)
+    case @@options[:repomodel]
+    when :peruser
+      "#{username}_production"
+
+    when :single
+      username
+
+    else
+      raise "Invalid setting for repomodel (#{repomodel})"
+    end
+  end
+
+  def self.approximate_time_difference(timestamp)
+    return 'never' if timestamp.nil?
+
+    start = timestamp.class == String ? Time.parse(timestamp) : timestamp
+    delta = (Time.now - start)
+
+    if delta > 60
+      # This grossity is rounding to the nearest whole minute
+      mins = ((delta / 600).round(1)*10).to_i
+      "about #{mins} minutes ago"
+    else
+      "#{delta.to_i} seconds ago"
+    end
+  end
+
+end

data/lib/puppetfactory/monkeypatches.rb

@@ -0,0 +1,30 @@
+class String
+  if not String.method_defined? :snake_case
+     def snake_case!
+       gsub!(/(.)([A-Z])/,'\1_\2')
+       downcase!
+     end
+
+     def snake_case
+       dup.tap { |s| s.snake_case! }
+     end
+  end
+
+  if not String.method_defined? :trim
+    def trim(size)
+      if self.size > size
+        "#{self[0...(size - 1)]}…"
+      else
+        self
+      end
+    end
+  end
+end
+
+class Symbol
+  if not Symbol.method_defined? :snake_case
+     def snake_case
+       to_s.snake_case.to_sym
+     end
+  end
+end

data/lib/puppetfactory/plugins.rb

@@ -0,0 +1,11 @@
+class Puppetfactory
+  class Plugins
+    attr_reader :weight
+    # just sets up the namespace for now
+
+    def initialize(options=nil)
+      @weight ||= 100
+    end
+  end
+end
+

data/lib/puppetfactory/plugins/certificates.rb

@@ -0,0 +1,28 @@
+require 'puppetfactory'
+class Puppetfactory::Plugins::Certificates < Puppetfactory::Plugins
+
+  def initialize(options)
+    super(options)
+
+    @puppet = options[:puppet]
+    @suffix = options[:usersuffix]
+  end
+
+  def delete(username)
+    certname = "#{username}.#{@suffix}"
+
+    output, status = Open3.capture2e('puppet', 'cert', 'clean', certname)
+    unless status.success?
+      $logger.warn "Error cleaning certificate #{certname}: #{output}"
+      return false
+    end
+
+    $logger.info "Certificate #{certname} removed"
+    true
+  end
+
+  def repair(username)
+    delete(username)
+  end
+
+end

data/lib/puppetfactory/plugins/classification.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'puppetfactory'
+require 'puppetclassify'
+
+class Puppetfactory::Plugins::Classification < Puppetfactory::Plugins
+
+  def initialize(options)
+    super(options)
+
+    @weight    = 25
+    @puppet    = options[:puppet]
+    @suffix    = options[:usersuffix]
+    @master    = options[:master]
+    classifier = options[:classifier] || "http://#{@master}:4433/classifier-api"
+
+    auth_info = options[:auth_info]  || {}
+    auth_info['ca_certificate_path'] ||= "#{options[:confdir]}/ssl/ca/ca_crt.pem"
+    auth_info['certificate_path']    ||= "#{options[:confdir]}/ssl/certs/#{options[:master]}.pem"
+    auth_info['private_key_path']    ||= "#{options[:confdir]}/ssl/private_keys/#{options[:master]}.pem"
+
+    @puppetclassify = PuppetClassify.new(classifier, auth_info)
+  end
+
+  def create(username, password)
+    environment = Puppetfactory::Helpers.environment_name(username)
+    certname    = "#{username}.#{@suffix}"
+
+    group_hash = {
+      'name'               => certname,
+      'environment'        => environment,
+      'environment_trumps' => true,
+      'parent'             => '00000000-0000-4000-8000-000000000000',
+      'classes'            => {},
+      'rule'               => ['or', ['=', 'name', certname]]
+    }
+
+    begin
+      @puppetclassify.groups.create_group(group_hash)
+    rescue => e
+      $logger.error "Could not create node group #{certname}: #{e.message}"
+      return false
+    end
+
+    $logger.info "Created node group #{certname} assigned to environment #{environment}"
+    true
+  end
+
+  def delete(username)
+    certname = "#{username}.#{@suffix}"
+
+    begin
+      group_id = @puppetclassify.groups.get_group_id(certname)
+      @puppetclassify.groups.delete_group(group_id)
+    rescue => e
+      $logger.warn "Error removing node group #{certname}: #{e.message}"
+      return false
+    end
+
+    $logger.info "Node group #{certname} removed"
+    true
+  end
+
+  def userinfo(username, extended = false)
+    return unless extended
+
+    ngid = @puppetclassify.groups.get_group_id("#{username}.#{@suffix}")
+
+    {
+      :username       => username,
+      :node_group_id  => ngid,
+      :node_group_url => "https://#{@master}/#/node_groups/groups/#{ngid}",
+    }
+  end
+
+end