puppetfactory 0.4.0

data/lib/puppetfactory/plugins/code_manager.rb

@@ -0,0 +1,156 @@
+require 'puppetfactory'
+require 'hocon'
+require 'hocon/parser/config_document_factory'
+require 'hocon/config_value_factory'
+
+class Puppetfactory::Plugins::CodeManager < Puppetfactory::Plugins
+
+  def initialize(options)
+    super(options)
+
+    @puppet       = options[:puppet]
+    @gitserver    = options[:gitserver]
+    @repomodel    = options[:repomodel]
+    @controlrepo  = options[:controlrepo]
+    @environments = options[:environments]
+    @sources      = '/etc/puppetlabs/puppet/hieradata/sources.yaml' # we can hardcode these assumptions
+    @meep         = '/etc/puppetlabs/enterprise/conf.d/common.conf' # because CM is PE only.
+    @pattern      = "#{@gitserver}/%s/#{@controlrepo}"
+
+    # the rest of this method is for the big boys only
+    return unless Process.euid == 0
+
+    # in case this is the first run and these doesn't exist yet
+    unless File.exist? @sources
+      FileUtils.mkdir_p File.dirname @sources
+      File.open(@sources, 'w') { |f| f.write( { 'puppet_enterprise::master::code_manager::sources' => {} }.to_yaml) }
+    end
+    File.open(@meep, 'w') { |f| f.write('') } unless File.exist? @meep
+
+    if options[:codedir]
+      # ensure sane file permissions
+      FileUtils.chown_R('pe-puppet', 'pe-puppet', options[:codedir])
+      FileUtils.chmod(0755, options[:codedir])
+    end
+  end
+
+  def create(username, password)
+    begin
+      environment = "#{@environments}/#{Puppetfactory::Helpers.environment_name(username)}"
+      FileUtils.mkdir_p environment
+      FileUtils.chown_R(username, 'pe-puppet', environment)
+      FileUtils.chmod(0750, environment)
+
+      File.open(@sources) do |file|
+        # make sure we don't have any concurrency issues
+        file.flock(File::LOCK_EX)
+
+        # We need to duplicate the sources list in the MEEP config for recovery options
+        # I'd like to add it to code-manager.conf too and avoid the delay of running
+        # puppet, but that's a race condition that we cannot accept.
+        File.open(@meep) do |anotherfile|
+          anotherfile.flock(File::LOCK_EX)
+
+          source = {
+            'remote'  => sprintf(@pattern, username),
+            'prefix'  => (@repomodel == :peruser),
+          }
+
+          sources = YAML.load_file(@sources)
+          meep    = Hocon::Parser::ConfigDocumentFactory.parse_file(@meep)
+
+          sources['puppet_enterprise::master::code_manager::sources'][username] = source
+          meep = meep.set_config_value(
+                      "\"puppet_enterprise::master::code_manager::sources\".#{username}",
+                      Hocon::ConfigValueFactory.from_any_ref(source)
+                    )
+
+          # Ruby 1.8.7, why don't you just go away now
+          File.open(@sources, 'w') { |f| f.write(sources.to_yaml) }
+          File.open(@meep, 'w')    { |f| f.write(meep.render)     }
+          $logger.info "Created Code Manager source for #{username}"
+        end
+      end
+    rescue => e
+      $logger.error "Cannot create Code Manager source for #{username}"
+      $logger.error e.backtrace
+      return false
+    end
+
+    true
+  end
+
+  def delete(username)
+    begin
+      environment = "#{@environments}/#{Puppetfactory::Helpers.environment_name(username)}"
+      FileUtils.rm_rf environment
+
+      # also delete any prefixed environments. Is this even a good idea?
+      FileUtils.rm_rf "#{@environments}/#{username}_*" if @repomodel == :peruser
+
+      File.open(@sources) do |file|
+        # make sure we don't have any concurrency issues
+        file.flock(File::LOCK_EX)
+
+        # We need to duplicate the sources list in the MEEP config for recovery options
+        # I'd like to add it to code-manager.conf too and avoid the delay of running
+        # puppet, but that's a race condition that we cannot accept.
+        File.open(@meep) do |anotherfile|
+          anotherfile.flock(File::LOCK_EX)
+
+          source = {
+            'remote'  => sprintf(@pattern, username),
+            'prefix'  => (@repomodel == :peruser),
+          }
+
+          sources = YAML.load_file(@sources)
+          sources['puppet_enterprise::master::code_manager::sources'].delete username rescue nil
+
+          meep = Hocon::Parser::ConfigDocumentFactory.parse_file(@meep)
+          meep = meep.remove_value("\"puppet_enterprise::master::code_manager::sources\".#{username}")
+
+          # Ruby 1.8.7, why don't you just go away now
+          File.open(@sources, 'w') { |f| f.write(sources.to_yaml) }
+          File.open(@meep, 'w')    { |f| f.write(meep.render)     }
+          $logger.info "Removed Code Manager source for #{username}"
+        end
+      end
+    rescue => e
+      $logger.error "Cannot remove Code Manager source for #{username}"
+      $logger.error e.backtrace
+      return false
+    end
+
+    true
+  end
+
+  def deploy(username)
+    environment = Puppetfactory::Helpers.environment_name(username)
+
+    output, status = Open3.capture2e(@puppet, 'code', 'deploy', environment, '--wait')
+    unless status.success?
+      $logger.error "Failed to deploy environment #{environment} for #{username}"
+      $logger.error output
+      return false
+    end
+
+    $logger.info "Deployed environment #{environment} for #{username}"
+    true
+  end
+
+  def redeploy(username)
+    begin
+      if username == 'production'
+        raise "Can't redeploy production environment"
+      end
+      delete(username)
+      deploy(username)
+
+    rescue => e
+      raise "Error redeploying environment #{username}: #{e.message}"
+    end
+
+    true
+  end
+
+end

data/lib/puppetfactory/plugins/console_user.rb

@@ -0,0 +1,62 @@
+require 'json'
+require 'puppetfactory'
+
+class Puppetfactory::Plugins::ConsoleUser < Puppetfactory::Plugins
+
+  def initialize(options)
+    super(options)
+
+    @puppet   = options[:puppet]
+    @suffix   = options[:usersuffix]
+    auth_info = options[:auth_info] || {}
+
+    @ca_certificate_path = auth_info[:ca_certificate_path] || "#{options[:confdir]}/ssl/ca/ca_crt.pem",
+    @certificate_path    = auth_info[:certificate_path]    || "#{options[:confdir]}/ssl/certs/#{options[:master]}.pem",
+    @private_key_path    = auth_info[:private_key_path]    || "#{options[:confdir]}/ssl/private_keys/#{options[:master]}.pem"
+    @classifier_url      = options[:classifier]            || "http://#{options[:master]}:4433/classifier-api"
+  end
+
+  def create(username, password)
+    output, status = Open3.capture2e(@puppet, 'resource', 'rbac_user', username,
+                              'ensure=present',
+                              "display_name=#{username}",
+                              'roles=Operators',
+                              "email=#{username}@#{@suffix}",
+                              "password=#{password}")
+
+    unless status.success
+      $logger.error "Could not create PE Console user #{username}: #{output}"
+      return false
+    end
+
+    $logger.info "Console user #{username} created successfully"
+    true
+  end
+
+  def delete(username)
+    output, status = Open3.capture2e(@puppet, 'resource', 'rbac_user', username, 'ensure=absent')
+    unless status.success?
+      $logger.warn "Could not remove PE Console user #{username}: #{output}"
+      return false
+    end
+
+    $logger.info "Console user #{username} removed successfully"
+    true
+  end
+
+  def userinfo(username, extended = false)
+    return unless extended
+
+    output, status = Open3.capture2e(PUPPET, 'resource', 'rbac_user', username)
+    unless status.success?
+      $logger.error "Could not query Puppet user #{username}: #{output}"
+      return false
+    end
+
+    {
+      :username     => username,
+      :console_user => output =~ /present/,
+    }
+  end
+
+end

data/lib/puppetfactory/plugins/dashboard.rb

@@ -0,0 +1,128 @@
+require 'puppetfactory'
+
+class Puppetfactory::Plugins::Dashboard < Puppetfactory::Plugins
+  attr_accessor :current_test
+
+  def initialize(options)
+    super(options)
+    return unless options[:puppetfactory]
+
+    @server   = options[:puppetfactory]
+    @path     = options[:dashboard_path]     || '/etc/puppetfactory/dashboard'
+    @interval = options[:dashboard_interval] || 5 * 60  # test interval in seconds
+
+    # TODO: finish a real mutex implementation and avoid the current (small) race condition
+    #set :semaphore, Mutex.new
+    @current_test = 'summary'
+    @test_running = false
+
+    start_testing()
+
+    @server.get '/dashboard' do
+      protected!
+
+      # we can't call methods directly, because this block will execute in the scope
+      # of the Puppetfactory server. Use the plugin system instead.
+      @current   = plugin(:Dashboard, :current_test)
+      @available = plugin(:Dashboard, :available_tests)
+      @test_data = plugin(:Dashboard, :test_data)
+
+      return 'No testing data' unless @available and @test_data
+
+      erb :dashboard
+    end
+
+    @server.get '/dashboard/details/:user' do |user|
+      plugin(:Dashboard, :user_test_html, user)
+    end
+
+    @server.get '/dashboard/details/:user/:result' do |user, result|
+      plugin(:Dashboard, :user_test_html, user, result)
+    end
+
+    @server.get '/dashboard/update' do
+      $logger.info "Triggering dashboard update."
+
+      if plugin(:Dashboard, :update_results)
+        {'status' => 'success'}.to_json
+      else
+        {'status' => 'fail', 'message' => 'Already running'}.to_json
+      end
+    end
+
+    @server.get '/dashboard/set/:current' do |current|
+      $logger.info "Setting current test to #{current}."
+
+      plugin(:Dashboard, :current_test=, current)
+
+      {'status' => 'success'}.to_json
+    end
+
+  end
+
+  def tabs(privileged = false)
+    return unless privileged
+
+    { 'dashboard' => 'Testing Dashboard' }
+  end
+
+  def update_results()
+    return false if @test_running
+    @test_running = true
+
+    Dir.chdir(@path) do
+      case @current_test
+      when 'all', 'summary'
+        system('rake', 'generate')
+      else
+        system('rake', 'generate', "current_test=#{@current_test}")
+      end
+    end
+
+    @test_running = false
+    true
+  end
+
+  def available_tests()
+    Dir.chdir(@path) { `rake list`.split } rescue []
+  end
+
+  def test_data()
+    JSON.parse(File.read("#{@path}/output/summary.json")) rescue {}
+  end
+
+  def user_test_html(user, result = @current_test)
+    begin
+    if result == 'summary'
+      File.read("#{@path}/output/html/#{user}.html")
+    else
+      File.read("#{@path}/output/html/#{result}/#{user}.html")
+    end
+    rescue Errno::ENOENT
+      'No results found'
+    end
+  end
+
+  # class method so the template can call it
+  def self.test_completion(data)
+    total  = data['example_count'] rescue 0
+    failed = data['failure_count'] rescue 0
+    passed = total - failed
+    percent = passed.to_f / total * 100.0 rescue 0
+
+    [total, passed, percent]
+  end
+
+  private
+  def start_testing()
+    Thread.new do
+      loop do
+        $logger.info "Updating dashboard after #{@interval} seconds."
+        update_results()
+        sleep(@interval)
+      end
+    end
+  end
+
+
+end

data/lib/puppetfactory/plugins/docker.rb

@@ -0,0 +1,193 @@
+require 'erb'
+require 'time'
+require 'docker'
+require 'etc'
+require 'json'
+require 'puppetfactory'
+
+class Puppetfactory::Plugins::Docker < Puppetfactory::Plugins
+
+  def initialize(options)
+    super(options)
+
+    @weight = 5
+
+    @confdir      = options[:confdir]
+    @environments = options[:environments]
+    @puppetcode   = options[:puppetcode]
+    @master       = options[:master]
+    @modulepath   = options[:modulepath]
+    @templatedir  = options[:templatedir]
+    @container    = options[:container_name] || 'centosagent'
+    @group        = options[:docker_group]   || 'docker'
+    @docker_ip    = options[:docker_ip]      || `facter ipaddress_docker0`.strip
+    @privileged   = options[:privileged]     || true
+  end
+
+  def create(username, password)
+    begin
+      environment = "#{@environments}/#{Puppetfactory::Helpers.environment_name(username)}"
+
+      binds = [
+        "/var/yum:/var/yum",
+        "/home/#{username}/puppet:#{@confdir}",
+        "/sys/fs/cgroup:/sys/fs/cgroup:ro"
+      ]
+
+      case @modulepath
+      when :readonly
+        binds.push("#{environment}:#{@puppetcode}:ro")
+      when :readwrite
+        binds.push("#{environment}:#{@puppetcode}")
+      when :none
+        #pass
+      else
+        raise "Uknown modulepath setting (#{@modulepath})"
+      end
+
+      container = ::Docker::Container.create(
+        "Cmd" => [
+          "/usr/lib/systemd/systemd"
+        ],
+        "Tty" => true,
+        "Domainname" => "puppetlabs.vm",
+        "Env" => [
+          "RUNLEVEL=3",
+          "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+          "HOME=/root/",
+          "TERM=xterm"
+        ],
+        "ExposedPorts" => {
+          "80/tcp" => {
+          }
+        },
+        "Hostname" => "#{username}",
+        "Image" => "#{@container}",
+        "HostConfig" => {
+          "Privileged" => @privileged,
+          "Binds" => binds,
+          "ExtraHosts" => [
+            "#{@master} puppet:#{@docker_ip}"
+          ],
+          "PortBindings" => {
+            "80/tcp" => [
+              {
+                "HostPort" => "#{user_port(username)}"
+              }
+            ]
+          },
+        },
+        "Name" => "#{username}"
+      )
+
+      container.rename(username) # Set container name so we can identify it
+      init_scripts(username)     # Create init scripts so container restarts on boot
+      container.start
+
+    rescue => e
+      # fatal error, so we stop execution here
+      raise "Error creating container #{username}: #{e.message}"
+    end
+
+    $logger.info "Container #{username} created"
+    true
+  end
+
+  def delete(username)
+    begin
+      remove_init_scripts(username)
+
+      container = ::Docker::Container.get(username)
+      output = container.delete(:force => true)
+    rescue => e
+      $logger.warn "Error removing container #{username}: #{e.message}"
+      return false
+    end
+
+    $logger.info "Container #{username} removed"
+    true
+  end
+
+  def repair(username)
+    begin
+      container = ::Docker::Container.get(username)
+      container.delete(:force => true)
+
+      create(username, nil)
+    rescue => e
+      raise "Error reparing container #{username}: #{e.message}"
+    end
+
+    $logger.info "Container #{username} repaired"
+    true
+  end
+
+  def userinfo(username, extended = false)
+    user = {
+      :username => username,
+      :port     => user_port(username),
+      :url      => sandbox_url(username),
+    }
+
+    if extended
+      user_container = ::Docker::Container.get(username).json rescue {}
+      user[:container_status] = massage_container_state(user_container['State'])
+    end
+
+    user
+  end
+
+  def login
+    require 'etc'
+    username = Etc.getpwuid(Process.euid).name
+    exec("docker exec -it #{username} su -")
+  end
+
+  private
+  def sandbox_url(username)
+    "/port/#{user_port(username)}"
+  end
+
+  # TODO: We need a better way of doing this, since we're not guaranteed to always have system users.
+  #       See plugins/shell_user.rb for the other side of this coupling.
+  def user_port(username)
+    Etc.getpwnam(username).uid + 3000
+  end
+
+  def massage_container_state(state)
+    return {'Description' => 'No container.'} if state.nil?
+
+    if state['OOMKilled']
+      state['Description'] = 'Halted because host machine is out of memory.'
+    elsif state['Restarting']
+      state['Description'] = 'Container is restarting.'
+    elsif state['Paused']
+      state['Description'] = 'Container is paused.'
+    elsif state['Running']
+      state['Description'] = "Running since #{Time.parse(state['StartedAt']).strftime("%b %d at %I:%M%p")}"
+    else
+      state['Description'] = 'Halted.'
+    end
+    state
+  end
+
+  def init_scripts(username)
+    service_file = "/etc/systemd/system/docker-#{username}.service"
+    File.open(service_file,"w") do |f|
+      f.write ERB.new(File.read("#{@templatedir}/init_scripts.erb")).result(binding)
+    end
+    File.chmod(0644, service_file)
+    system('chkconfig', "docker-#{username}", 'on')
+
+    $logger.info "Init scripts created and enabled for container #{username}"
+  end
+
+  def remove_init_scripts(username)
+    service_file = "/etc/systemd/system/docker-#{username}.service"
+    system('chkconfig', "docker-#{username}", 'off')
+    FileUtils.rm(service_file) if File.exist? service_file
+
+    $logger.info "Init scripts for container #{username} removed"
+  end
+
+end