admiral-check 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+## 0.0.1 - 2017-06-26
+
+ - Implementation of core features

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,16 @@
+Author:: Gattsu Blackswordsman (<gattsu.blackswordsman@gmail.com>)
+
+Copyright (C) 2014, Gattsu Blackswordsman
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/README.md

@@ -0,0 +1,20 @@
+# Admiral-Check
+
+A tool for deploying and testing under docker 
+
+
+
+
+
+## Author
+
+Created by [Gattsu][author]
+
+## License
+Apache 2.0 (see [LICENSE][license])
+
+
+
+[author]:           https://github.com/gattsublackswordsman
+[license]:          https://github.com/gattsublackswordsman/admiral-check/blob/master/LICENSE
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/admiral-check.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'admiral/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'admiral-check'
+  spec.version       = Admiral::ADMIRAL__VERSION
+  spec.authors       = ['Gattsu']
+  spec.email         = ['gattsu.blackswordsman@gmail.com']
+  spec.description   = %q{Deployment and testing tool}
+  spec.summary       = spec.description
+  spec.homepage      = 'https://github.com/gattsublackswordsman/admiral-check'
+  spec.license       = 'Apache 2.0'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = %w(admiral)
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'mixlib-shellout', '~> 1.6.1'
+  spec.add_runtime_dependency 'net-scp', '~> 1.1'
+  spec.add_runtime_dependency 'net-ssh', '~> 2.7'
+  spec.add_runtime_dependency 'safe_yaml', '~> 1.0'
+  spec.add_runtime_dependency 'thor', '~> 0.18'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/bin/admiral

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.join(File.dirname(__FILE__), %w{.. lib})
+require 'rubygems'
+
+require 'admiral/core'
+
+
+Admiral::Core.start

data/lib/admiral/config.rb

@@ -0,0 +1,96 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'yaml'
+
+module Admiral
+  class Config
+    attr_reader :platforms
+
+    def initialize
+
+      local_config_file = ".admiral.yml"
+      global_config_file = File.expand_path("~/.admiral.yml")
+
+      if not File.exist?(local_config_file)
+        STDERR.puts "File .admiral.yml must be present"
+        exit!
+      end
+
+      local_config = YAML.load_file(local_config_file)
+
+      if  File.exist?(global_config_file)
+        global_config = YAML.load_file(File.expand_path("~/.admiral.yml"))
+
+        common_global_config = global_config['common']
+        common_local_config  = local_config['common']
+
+        if common_global_config.nil?
+          if common_local_config.nil?
+            STDERR.puts "No common config defined"
+            exit!
+          else
+            common_config = common_local_config
+          end
+        else
+          if common_local_config.nil?
+            common_config = common_global_config
+          else
+            common_config = common_global_config.merge(common_local_config)
+          end
+        end
+      else
+        common_config = local_config['common']
+
+        if common_config.nil?
+          STDERR.puts "No common config defined"
+          exit!
+        end
+      end
+
+      @platforms = Hash.new
+      @platforms_name = []
+      @platforms_config = Hash.new
+
+      common_applications = common_config['applications']
+      common_applications = [] if not common_applications
+
+      if local_config['platforms'].nil?
+        STDERR.puts "No platforms defined"
+        exit!
+      end
+
+      local_config['platforms'].each do | platform |
+        platform_name = platform['name']
+        @platforms[platform_name] = platform
+        @platforms_name << platform_name
+
+        @platforms_config[platform_name] = common_config.clone
+        @platforms_config[platform_name].merge!(platform)
+
+        platform_applications = @platforms_config[platform_name]['applications']
+        platform_applications = [] if not platform_applications
+        platform_applications_codes = []
+
+        platform_applications.each do |application|
+          platform_applications_codes << application['code']
+        end
+
+        common_applications.each do |application|
+          if not platform_applications_codes.include?(application['code'])
+             @platforms_config[platform_name]['applications'].push(application)
+          end
+        end
+      end
+    end
+
+    def [](platform)
+      return @platforms_config[platform]
+    end
+
+    def platform?(platform)
+      return @platforms_config.key?(platform)
+    end
+  end
+end
+ 

data/lib/admiral/core.rb

@@ -0,0 +1,154 @@
+require "thor"
+require "admiral/docker"
+
+module Admiral
+
+  class Core < Thor
+
+    def initialize(*args)
+      super
+      @config = Admiral::Config.new()
+    end
+
+    desc "list", "List available platforms"
+    def list()
+      platforms = @config.platforms
+      platforms.keys.each do |  platform |
+        puts "#{platform}"
+      end
+    end
+
+    desc "create NAME", "Create a container for a platform"
+    def create(platform_name)
+
+       if  @config.platform?(platform_name)
+         Admiral::Docker::verify((@config[platform_name]))
+         Admiral::Docker::create(@config[platform_name])
+       else
+         STDERR.puts "Platform #{platform_name} don't exist"
+         exit!
+       end
+    end
+
+    desc "apply-layer PLATFORM LAYER", "Apply a layer in an existing container"
+    def apply_layer(platform_name, layer_uid)
+      Admiral::Docker::verify((@config[platform_name]))
+
+      if @config.platform?(platform_name)
+        container_id = Admiral::Docker::get_container_id(platform_name)
+        docker = @config[platform_name]['docker']
+        if container_id
+          ip_address = Admiral::Docker::get_ip_address(docker, container_id)
+          if ip_address
+            success = Admiral::Docker::apply_layer(@config[platform_name], layer_uid, ip_address)
+            if not success
+             STDERR.puts "failed to run the layer"
+             exit!
+            end
+          else
+            STDERR.puts "Failed to get IP address"
+            exit!
+          end
+        else
+          STDERR.puts "Failed to get container ID"
+          exit!
+        end
+      else
+        STDERR.puts "Platform #{platform_name} don't exist"
+        exit!
+      end
+    end
+
+    desc "login NAME", "Log in the container"
+    def login(platform_name)
+      Admiral::Docker::create(@config[platform_name])
+      if  @config.platform?(platform_name)
+        Admiral::Docker::login(@config[platform_name])
+      else
+        STDERR.puts "Platform #{platform_name} don't exist"
+        exit!
+      end
+    end
+
+    desc "test NAME", "Run the tests suite"
+    def test(platform_name)
+      if  @config.platform?(platform_name)
+        Admiral::Docker::create(@config[platform_name])
+        Admiral::Docker::test(@config[platform_name])
+        Admiral::Docker::destroy(@config[platform_name])
+      else
+        STDERR.puts "Platform #{platform_name} don't exist"
+        exit!
+      end
+    end
+
+    desc "destroy NAME", "Destroy a container"
+    def destroy(platform_name)
+      if  @config.platform?(platform_name)
+         Admiral::Docker::destroy(@config[platform_name])
+       else
+         STDERR.puts "Platform #{platform_name} don't exist"
+         exit!
+       end
+    end
+
+    desc "layer-info NAME", "Show informations about a layer"
+    def layer_info(layer_uid)
+      begin
+        require "admiral/layers/#{layer_uid}.rb"
+      rescue LoadError
+        STDERR.puts "Layer #{layer_uid} not found"
+        return false
+      end
+
+      begin
+        kclass = ::Admiral::Layers.const_get(Admiral::Layer.uid_to_name(layer_uid))
+      rescue NameError
+        STDERR.puts "Layer #{layer_uid} has a mistake"
+        return false
+      end
+      layer = kclass.new(nil, nil)
+      layer.show_information
+    end
+
+
+    desc "config-help", "Show configuration help"
+    def config_help()
+      puts <<-EOF
+
+  The configuration is located in .admiral.yml files.
+  The global configuration is in ~/ and the local configuration is in any other directory.
+
+  common:                                      # Configuration for all plaforms, in global or local configuration
+      docker:     unix:///var/run/docker.sock  # Docker socket
+      registry:   127.0.0.1:5000               # Docker registry
+      username:   admiral                      # Username for Admiral user in the container
+      password:   admiral                      # Password for Admiral
+      keyfile:    docker_id_rsa                # Private Key for Admiral connection in the container
+      pubkeyfile: docker_id_rsa.pub            # Associated public Key
+      volumes:                                 # Optional, list of volumes to export in the container
+       - guest: /path/in/the/guest             # Path of the volume in the container
+         host:  /path/in/the/host              # Optional, path of the real directory
+      layers:                                  # Layers for the configuration
+        - admiral.svn.puppet.manifest
+        - admiral.svn.puppet.cookbook
+        - admiral.puppet.apply
+      tests:                                   # Layers for the tests
+        - admiral.test.chef.install
+        - admiral.test.serverspec.install
+        - admiral.test.serverspec.upload
+        - admiral.test.serverspec.run
+
+  platforms:                                   # List of platforms' configuration, only in local configuration
+    - name:     my-server
+      image:    ubuntu16                       # Docker image
+      hostname: web.domain.lan
+      lsp:      false                          # A layer parameter
+      ...
+
+EOF
+
+    end
+  end
+end
+

data/lib/admiral/docker.rb

@@ -0,0 +1,368 @@
+# -*- encoding: utf-8 -*-
+#
+
+require 'admiral/config'
+require 'admiral/shell'
+require 'admiral/layer'
+
+module Admiral
+  module Docker
+
+    @@core_parameters = ['docker', 'image', 'username', 'password', 'keyfile', 'pubkeyfile', 'registry', 'layers', 'tests', 'hostname']
+
+    def self.verify (platform)
+      @@core_parameters.each do | parameter |
+        if not platform.key?(parameter)
+          STDERR.puts "Parameter #{parameter} not found"
+          exit!
+        end
+      end
+    end
+
+    def self.create (platform)
+
+      platform_name = platform['name']
+      image         = platform['image']
+      docker        = platform['docker']
+      hostname      = platform['hostname']
+      ssh_key_file  = platform['keyfile']
+      username      = platform['username']
+      password      = platform['password']
+      volumes       = platform['volumes']
+
+      last_container_id = get_container_id(platform_name)
+      if last_container_id
+        puts "Container exist : #{last_container_id}"
+      else
+        dockerfile = generate_dockerfile(platform)
+
+        volumes_cmd = ''
+
+        if volumes.kind_of?(Array)
+          volumes.each do | volume |
+            if not volume['guest']
+              STDERR.puts "ERROR: Volume must have 'guest' parameter"
+              exit!
+            else
+              if volume['host']
+                volumes_cmd << "-v #{volume['host']}:#{volume['guest']} "
+              else
+                volumes_cmd << "-v #{volume['guest']} "
+              end
+            end
+          end
+        end
+
+        puts "=== Create image ==="
+
+        begin
+          output = Admiral::Shell.local("docker -H #{docker} build --build-arg=USERNAME='#{username}' --build-arg=PASSWORD='#{password}' --no-cache -", {:input => dockerfile}, true)
+        rescue Interrupt
+            STDERR.puts "Creation interrupted"
+            exit!
+        end
+
+        if output
+
+          image_id = output.gsub(/.* /m, "")
+          puts "Image ID : #{image_id}"
+
+          Dir.mkdir(".states") unless File.exists?(".states")
+          f = File.open(".states/#{platform_name}.image", "w")
+          f.write("#{image_id}")
+          f.close
+
+          puts "=== Create container ==="
+          container_id = Admiral::Shell.local("docker -H #{docker} run -d -p 22 -h #{hostname} --privileged --cap-add ALL #{volumes_cmd} #{image_id}")
+
+          if container_id
+            puts "Container ID : #{container_id}"
+            Dir.mkdir(".states") unless File.exists?(".states")
+            f = File.open(".states/#{platform_name}.container", "w")
+            f.write("#{container_id}")
+            f.close
+
+            output = Admiral::Shell.local("docker  -H #{docker} inspect #{container_id}")
+            if output
+              ipaddress = extract_ipaddress(output)
+              puts "=== Configuring container ==="
+              success = self.apply_layers(platform, ipaddress)
+              if not success
+                STDERR.puts "Failed to apply configuration layers, run destroy"
+                destroy(platform)
+                exit!
+              end
+            else
+              STDERR.puts "Failed to log in container, run destroy"
+              destroy(platform)
+              exit!
+            end
+          else
+            STDERR.puts "Failed to create container, run destroy"
+            destroy(platform)
+            exit!
+          end
+        end
+      end
+    end
+
+    def self.test (platform)
+      platform_name = platform['name']
+      testdir = "test"
+      if Dir.exists?(testdir)
+        puts "=== Run tests ==="
+        container_id = get_container_id(platform['name'])
+        docker = platform['docker']
+
+        if container_id
+          output = Admiral::Shell.local("docker  -H #{docker} inspect #{container_id}")
+          if output
+            ipaddress = extract_ipaddress(output)
+            success = self.apply_test_layers(platform, ipaddress)
+            if not success
+              STDERR.puts "One or more tests failed, run destroy"
+              destroy(platform)
+              exit!
+            end
+          else
+            STDERR.puts "Failed to get IP address"
+            destroy(platform)
+            exit!
+          end
+        else
+          STDERR.puts "Failed to container ID"
+          destroy(platform)
+          exit!
+        end
+      else
+        STDERR.puts "Test directory not found"
+        destroy(platform)
+        exit!
+      end
+    end
+
+    def self.destroy (platform)
+      platform_name = platform['name']
+      docker = platform['docker']
+
+      last_container_id = get_container_id(platform_name)
+      if last_container_id
+        puts "Remove container #{last_container_id}"
+        Admiral::Shell.local("docker  -H #{docker} rm -f #{last_container_id}")
+        File.delete(".states/#{platform_name}.container")
+      else
+        puts "No container"
+      end
+
+      last_image_id = get_image_id(platform_name)
+
+      if last_container_id
+        puts "Remove image #{last_image_id}"
+        Admiral::Shell.local("docker  -H #{docker} rmi -f #{last_image_id}")
+        File.delete(".states/#{platform_name}.image")
+      else
+        puts "No image"
+      end
+    end
+
+    def self.login(platform)
+
+      container_id = get_container_id(platform['name'])
+      docker = platform['docker']
+
+      if container_id
+        output = Admiral::Shell.local("docker  -H #{docker} inspect #{container_id}")
+        if output
+          ipaddress = extract_ipaddress(output)
+          username  = platform['username']
+          keyfile   = platform['keyfile']
+          cmd       = "/bin/bash"
+
+          puts "Log in to #{ipaddress}"
+          Admiral::Shell.remote(ipaddress, username, keyfile, cmd)
+        else
+          puts "Failed to get ip address"
+        end
+      else
+         puts "No container"
+      end
+    end
+
+    def self.get_image_id(platform_name)
+       if File.exists?(".states/#{platform_name}.image")
+          f = File.open(".states/#{platform_name}.image", "r")
+          image_id = f.read()
+          f.close
+         return image_id
+       else
+         return nil
+       end
+    end
+
+    def self.get_container_id(platform_name)
+       if File.exists?(".states/#{platform_name}.container")
+          f = File.open(".states/#{platform_name}.container", "r")
+          container_id = f.read()
+          f.close
+         return container_id
+       else
+         return nil
+       end
+    end
+
+    def self.apply_layers(platform, ipaddress)
+
+      layers = platform['layers']
+
+      layers.each do | layer_uid |
+        begin
+          require "admiral/layers/#{layer_uid}.rb"
+        rescue LoadError
+          STDERR.puts "Layer #{layer_uid} not found"
+          return false
+        end
+
+        begin
+          kclass = ::Admiral::Layers.const_get(Admiral::Layer.uid_to_name(layer_uid))
+        rescue NameError
+          STDERR.puts "Layer #{layer_uid} has a mistake"
+          return false
+        end
+        layer = kclass.new(platform,ipaddress)
+
+        valid = layer.verify()
+        if not valid
+          return false
+        end
+
+        success = layer.run()
+        if not success
+          return false
+        end
+
+      end
+      return true
+    end
+
+    def self.apply_test_layers(platform, ipaddress)
+
+      layers = platform['tests']
+
+      layers.each do | layer_uid |
+        begin
+          require "admiral/layers/#{layer_uid}.rb"
+        rescue LoadError
+          STDERR.puts "Layer #{layer_uid} not found"
+          return false
+        end
+
+        begin
+          kclass = ::Admiral::Layers.const_get(Admiral::Layer.uid_to_name(layer_uid))
+        rescue NameError
+          STDERR.puts "Layer #{layer_uid} has a mistake"
+          return false
+        end
+        layer = kclass.new(platform,ipaddress)
+
+        valid = layer.verify()
+        if not valid
+          return false
+        end
+
+        success = layer.run()
+        if not success
+          return false
+        end
+
+      end
+      return true
+    end
+
+
+    def self.apply_layer(platform, layer_uid, ipaddress)
+
+      begin
+        require "admiral/layers/#{layer_uid}.rb"
+      rescue LoadError
+        STDERR.puts "Layer #{layer_uid} not found"
+        return false
+      end
+
+      begin
+        kclass = ::Admiral::Layers.const_get(Admiral::Layer.uid_to_name(layer_uid))
+      rescue NameError
+        STDERR.puts "Layer #{layer_uid} has a mistake"
+        return false
+      end
+      layer = kclass.new(platform,ipaddress)
+
+      valid = layer.verify()
+      if not valid
+        return false
+      end
+
+      return layer.run()
+    end
+
+
+    def self.generate_dockerfile(platform)
+      image      = platform["image"]
+      username   = platform['username']
+      password   = platform['password']
+      pubkeyfile = platform['pubkeyfile']
+      registry   = platform['registry']
+
+      begin
+        f = File.open(pubkeyfile, 'r')
+        public_key = f.read().chomp()
+        f.close
+      rescue Errno::ENOENT  => e
+         STDERR.puts "Error with public key : #{e.message}"
+         exit!
+      end
+
+      from = "FROM #{registry}/#{image}\n"
+
+      user = <<-eos
+        ARG USERNAME
+        ARG PASSWORD
+        RUN useradd -d /home/${USERNAME} -m -s /bin/bash ${USERNAME}
+        RUN echo ${USERNAME}:${PASSWORD} | chpasswd
+        RUN echo "${USERNAME} ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
+      eos
+
+      key = <<-eos
+        RUN mkdir /home/${USERNAME}/.ssh
+        RUN echo '#{public_key}' >> /home/${USERNAME}/.ssh/authorized_keys
+      eos
+
+      tmpdir = <<-eos
+        RUN mkdir /tmp/${USERNAME}/
+        RUN chown ${USERNAME}:${USERNAME} /tmp/${USERNAME}
+      eos
+
+      ssh_env = <<-eos
+        RUN echo "AcceptEnv *" >> /etc/ssh/sshd_config
+      eos
+
+      [from, user, key, tmpdir, ssh_env].join("\n")
+    end
+
+    def self.get_ip_address(docker, container_id)
+      container_info = Admiral::Shell.local("docker -H #{docker} inspect #{container_id}")
+      if container_info
+        data  = YAML.load(container_info).first
+        return data['NetworkSettings']['IPAddress']
+      else
+        return nil
+      end
+    end
+
+    def self.extract_ipaddress(container_info)
+      data  = YAML.load(container_info).first
+      return data['NetworkSettings']['IPAddress']
+    end
+
+  end
+end
+