admiral-check 0.0.1

data/lib/admiral/layer.rb

@@ -0,0 +1,186 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/config'
+require 'net/ssh'
+require 'net/scp'
+require 'pp'
+
+module Admiral
+
+  module Layer
+    def self.uid_to_name(uid)
+      class_name = ''
+
+      l = uid.split('.')
+      l.each do |word|
+        class_name <<  word.capitalize
+      end
+
+      return class_name
+    end
+  end
+
+  class LayerBase
+
+    def self.inherited(subclass)
+      file = caller.first[/^[^:]+/]
+      $uid = File.basename(file,File.extname(file))
+      $location = File.dirname(file)
+    end
+
+    def initialize(description, config, ipaddress)
+      @description = description
+      @config = config
+      @ipaddress = ipaddress
+      @parameters = []
+    end
+
+    def add_parameter(name, description)
+       parameter = { 'name'=>name, 'description'=>description }
+       @parameters << parameter
+    end
+
+    def show_information
+       puts "Layer UID:   #{$uid}"
+       puts "Description: #{@description}"
+       if  @parameters.count > 0
+         puts "Paramaters:"
+         @parameters.each do | parameter |
+           puts "  #{parameter['name']} / #{parameter['description']}"
+         end
+       else
+         puts "No paramater"
+       end
+
+    end
+
+    def verify ()
+      @parameters.each do | parameter |
+        if not  @config.key?(parameter['name'])
+          STDERR.puts "Layer #{$uid} requires the parameter #{parameter['name']}, but it is not found"
+          return false
+        end
+      end
+      return true
+    end
+
+    def run()
+      puts "--- #{@description} ---"
+      username = @config['username']
+
+      layer_location   = $location
+      layer_uid        = $uid
+
+      layer_folder     = "#{layer_location}/#{layer_uid}.d"
+      layer_shell      = "#{layer_location}/#{layer_uid}.sh"
+      layer_perl       = "#{layer_location}/#{layer_uid}.pl"
+      layer_remote_dir = "/tmp/#{username}/"
+
+      if File.exists?(layer_folder)
+        upload(layer_folder, layer_remote_dir)
+      end
+
+      if File.exists?(layer_shell)
+        upload(layer_shell, layer_remote_dir)
+      end
+
+      if File.exists?(layer_perl)
+        upload(layer_perl, layer_remote_dir)
+      end
+
+      begin
+        success = do_action()
+      rescue Interrupt
+        STDERR.puts "Layer interrupted"
+        return false
+      rescue Errno::EACCES, Errno::ENOENT, Errno::ECONNREFUSED, IOError => e
+        STDERR.puts "Layer has error : #{e.message}"
+        return false
+      rescue Net::SSH::AuthenticationFailed
+        STDERR.puts "Layer has error : SSH - Authentication failed"
+        return false
+      end
+
+      return success
+    end
+
+    def do_action()
+      STDERR.puts "do_action must be implemented"
+      return false
+    end
+
+    def run_ssh_command(command, options = {})
+      username = @config['username']
+      keyfile = @config['keyfile']
+      proxy_url = @config['proxy_url']
+      allow_proxy = options.fetch(:allow_proxy, false)
+      env = options.fetch(:env, nil)
+
+      env_array = []
+      cmd = ""
+
+      if allow_proxy and  proxy_url
+        cmd << %Q[export http_proxy="#{proxy_url}";]
+        cmd << %Q[export https_proxy=$http_proxy;]
+      end
+
+      cmd << command
+
+      ssh_cmd = ""
+
+      if not env.nil?
+        env.each do |key, value|
+          ENV[key] = value
+          env_array << key
+        end
+      end
+
+      ssh_cmd << "sudo -E sh -c '#{cmd}'"
+
+      Net::SSH.start(@ipaddress, username, :host_key => "ssh-rsa", :keys => [ keyfile ], :user_known_hosts_file => '/dev/null', :send_env => env_array) do |ssh|
+
+        ssh.open_channel do |channel|
+          channel.exec(ssh_cmd) do |ch, success|
+            unless success
+              STDERR.puts "FAILED: couldn't execute command (#{command})"
+              return false
+            end
+
+            channel.on_data do |ch, data|
+              puts data
+            end
+
+            channel.on_extended_data do |ch, type, data|
+              STDERR.puts data
+            end
+
+            channel.on_request("exit-status") do |ch,data|
+              exit_code = data.read_long
+              if exit_code > 0
+                STDERR.puts "FAILED: command (#{command}) has failed"
+                return exit_code
+              end
+            end
+          end
+        end
+
+        ssh.loop
+        return 0
+      end
+    end
+
+    def upload(local, remote)
+
+      username = @config['username']
+      keyfile = @config['keyfile']
+
+      Net::SCP.upload!(@ipaddress, username,
+      local, remote,
+      :recursive => true,
+      :ssh => { :host_key => "ssh-rsa", :keys => [ keyfile ], :user_known_hosts_file => '/dev/null' })
+
+    end
+  end
+end

data/lib/admiral/layers/admiral.build.sh.rb

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+
+module Admiral
+  module Layers
+    class AdmiralBuildSh < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "Executing build script"
+
+        super(description, config, ipaddress)
+        add_parameter('build_script', 'Script file for build (ex: bootstap.sh)')
+        add_parameter('build_env', 'Hash of environmental variables (ex: {"param1"=>"value1", "param2"=>"value2"} )')
+      end
+
+      def do_action()
+        username     = @config['username']
+        build_script = @config['build_script']
+        build_env    = @config['build_env']
+
+        work_dir = "/tmp/#{username}/"
+
+        if not File.exists?(build_script)
+          STDERR.puts "File #{build_script} not found"
+          return false
+        end
+
+        upload(build_script, work_dir)
+
+        cmd = %Q[bash /tmp/#{username}/#{build_script}]
+
+        rc = run_ssh_command(cmd, :env => build_env)
+        return (rc == 0)
+      end
+    end
+  end
+end
+

data/lib/admiral/layers/admiral.exemple.test.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+
+module Admiral
+  module Layers
+    class AdmiralExempleTest < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "A simple test"
+
+        super(description, config, ipaddress)
+      end
+
+      def do_action()
+        cmd = "touch /tmp/simple-test"
+        run_ssh_command(cmd)
+
+        return true
+      end
+    end
+  end
+end
+

data/lib/admiral/layers/admiral.puppet.apply.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+
+module Admiral
+  module Layers
+    class AdmiralPuppetApply < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "Applying cookbooks"
+
+        super(description, config, ipaddress)
+        add_parameter('manifest', 'Manifest file (ex: prod.pp)')
+      end
+
+      def do_action
+
+        manifest      = @config['manifest']
+        manifests_dir = '/var/lib/puppet/manifests'
+        modules_dir   = '/var/lib/puppet/modules'
+
+        cmd = "puppet apply --verbose --modulepath=#{modules_dir} #{manifests_dir}/#{manifest}"
+
+        rc = run_ssh_command(cmd, :allow_proxy => false)
+        return (rc == 0)
+      end
+    end
+  end
+end
+

data/lib/admiral/layers/admiral.svn.proxy.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+
+module Admiral
+  module Layers
+    class AdmiralSvnProxy < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "Configuring proxy for SVN"
+
+        super(description, config, ipaddress)
+        add_parameter('svn_proxy_host', 'Hostname of the proxy needed to access to svn (ex: proxy.domain.com )')
+        add_parameter('svn_proxy_port', 'Port of the proxy (ex: 80)')
+        add_parameter('svn_proxy_user', 'Username for the proxy (ex: user)')
+        add_parameter('svn_proxy_password', 'Password for the proxy (ex: passwd)')
+      end
+
+      def do_action
+        svn_proxy_host      = @config['svn_proxy_host']
+        svn_proxy_port      = @config['svn_proxy_port']
+        svn_proxy_user      = @config['svn_proxy_user']
+        svn_proxy_password  = @config['svn_proxy_password']
+        username            = @config['username']
+
+        env = {
+          'svn_proxy_host'     => svn_proxy_host,
+          'svn_proxy_port'     => svn_proxy_port,
+          'svn_proxy_user'     => svn_proxy_user,
+          'svn_proxy_password' => svn_proxy_password,
+        }
+
+        cmd = "/tmp/#{username}/#{$uid}.sh"
+
+        rc = run_ssh_command(cmd, :env => env)
+        return (rc == 0)
+      end
+    end
+  end
+end
+

data/lib/admiral/layers/admiral.svn.proxy.sh

@@ -0,0 +1,9 @@
+#! /bin/sh
+
+cat <<EOF >> /etc/subversion/servers
+http-proxy-host = $svn_proxy_host
+http-proxy-port = $svn_proxy_port
+http-proxy-username = $svn_proxy_user
+http-proxy-password = $svn_proxy_password
+EOF
+

data/lib/admiral/layers/admiral.svn.puppet.cookbook.rb

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+require 'admiral/shell'
+
+module Admiral
+  module Layers
+    class AdmiralSvnPuppetCookbook < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "Retrieving cookbooks for applications from SVN"
+
+        super(description, config, ipaddress)
+        add_parameter('svn_cookbook_base_url', 'Root URL where are located the cookbooks in SVN (ex: https://domain.com/puppet-cookbooks)')
+        add_parameter('svn_user', 'Username for SVN')
+        add_parameter('svn_password', 'Password for SVN')
+        add_parameter('applications', 'List of hash that contains application code and source branch (ex: [ {"code"=>"appli1", "branch"=>"trunk"}, ]  )')
+      end
+
+      def do_action
+        svn_cookbook_base_url = @config['svn_cookbook_base_url']
+        svn_user              = @config['svn_user']
+        svn_password          = @config['svn_password']
+
+        modules_dir           = '/var/lib/puppet/modules/'
+
+        applications          = @config['applications']
+
+        applications.each do | application |
+          application_code   = application['code']
+          application_branch = application['branch']
+          cmd = "svn co --non-interactive --no-auth-cache  #{svn_cookbook_base_url}/#{application_code}/#{application_branch}/ #{modules_dir}/#{application_code}  --username=#{svn_user} --password=#{svn_password}; done"
+          puts " - Retrieving cookbook for project #{application_code} from #{application_branch}"
+
+          rc = run_ssh_command(cmd)
+          if rc > 0
+            return false
+          end
+        end
+
+        return true
+      end
+    end
+  end
+end
+

data/lib/admiral/layers/admiral.svn.puppet.manifest.rb

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+
+module Admiral
+  module Layers
+    class AdmiralSvnPuppetManifest < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "Retrieving manifest from SVN"
+
+        super(description, config, ipaddress)
+        add_parameter('svn_manifest_base_url', 'Root URL where are located the manifests in SVN (ex: https://domain.com/puppet-manifests)')
+        add_parameter('manifest_source', 'Path after the root URL (ex: production)')
+        add_parameter('svn_user', 'Username for SVN')
+        add_parameter('svn_password', 'Password for SVN')
+      end
+
+      def do_action
+        manifest_source       = @config['manifest_source']
+        manifests_dir         = '/var/lib/puppet/manifests'
+        svn_manifest_base_url = @config['svn_manifest_base_url']
+        svn_user              = @config['svn_user']
+        svn_password          = @config['svn_password']
+
+        cmd = "svn co --non-interactive --no-auth-cache #{svn_manifest_base_url}/#{manifest_source} #{manifests_dir}  --username=#{svn_user} --password=#{svn_password}"
+
+        rc = run_ssh_command(cmd)
+        return (rc == 0)
+      end
+    end
+  end
+end
+

data/lib/admiral/layers/admiral.test.chef.install.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+require 'admiral/layer'
+
+module Admiral
+  module Layers
+    class AdmiralTestChefInstall < Admiral::LayerBase
+      def initialize(config, ipaddress)
+        description = "Get and install chef"
+
+        super(description, config, ipaddress)
+      end
+
+      def do_action()
+
+        cmd = 'wget --no-check-certificate https://www.chef.io/chef/install.sh -O /tmp/install.sh && /bin/bash /tmp/install.sh'
+
+        rc = run_ssh_command(cmd, :allow_proxy => true)
+        return (rc == 0)
+      end
+    end
+  end
+end
+