environmate 0.1.0

data/lib/environmate/deployment.rb

@@ -0,0 +1,120 @@
+# This class controlls the deployment of puppet environments
+require 'lockfile'
+
+module Environmate
+  class Deployment
+
+    # create a new instance of Deployment
+    #
+    # * +user+         - The user who triggered the deployment
+    # * +puppet_env+   - The puppet environment to deploy
+    # * +revision+     - The revision which should be deployed in the environment
+    # * +old_revision+ - The revision the environment had previously
+    def initialize(user, puppet_env, revision, old_revision = nil)
+      @user         = user
+      @puppet_env   = puppet_env
+      @revision     = revision
+      @old_revision = old_revision
+    end
+
+    # Deploy a static environment
+    #
+    # * +token+      - The access token to deploy the environment
+    def deploy_static(token)
+      unless is_static_env?
+        @user.notify(:error, "'#{@puppet_env}' is not a static environment! Deployment aborted!")
+        return
+      end
+      return unless token_valid?(token)
+
+      @user.notify(:info, "Push of static environment '#{@puppet_env}' received, attempting to deploy...")
+      deploy
+    end
+
+    # Deploy a dynamic environment
+    def deploy_dynamic
+      if is_static_env?
+        @user.notify(:error, "'#{@puppet_env}' is a static environment. There should not be a branch of the same name")
+        return
+      end
+
+      @user.notify(:info, "Push of dynamic environment '#{@puppet_env}' received, attempting to deploy...")
+      deploy
+    end
+
+    # Checks if the puppet environment is a static environment
+    def is_static_env?
+      Environmate.configuration['static_environments'].keys.include?(@puppet_env)
+    end
+
+    # Checks if the token ist valid
+    #
+    # * +token+ - The token received from the hook
+    def token_valid?(token)
+      real_token = Environmate.configuration['static_environments'][@puppet_env]['token']
+      if real_token.nil?
+        @user.notify(:error, "No token set for '#{@puppet_env}'")
+        false
+      elsif real_token == token
+        true
+      else
+        @user.notify(:error, "Incorrect token for deployment of '#{@puppet_env}'")
+        false
+      end
+    rescue
+      @user.notify(:error, "Error while parsing configuration for '#{@puppet_env}'")
+      false
+    end
+
+    # Deploy the puppet environment
+    def deploy
+      lockfile_path    = Environmate.configuration['lockfile_path']
+      lockfile_options = Environmate.configuration['lockfile_options']
+      Lockfile.new(lockfile_path, lockfile_options) do
+        begin
+          if @revision.nil? || @revision.empty?
+            @user.notify(:info, 'Revision was empty. Only doing a cleanup...')
+            EnvironmentManager.master
+          else
+            @user.notify(:info, "Starting deployment of '#{@puppet_env}'...")
+            new_env = new_environment
+            @user.notify(:info, "Linking '#{@puppet_env}' => '#{@revision}'")
+            new_env.link(@puppet_env)
+            @user.notify(:info, "Done! Starting cleanup...")
+          end
+
+          EnvironmentManager.cleanup
+          @user.notify(:info, "Cleanup done!")
+        rescue Environmate::DeployError => e
+          @user.notify(:error, "Error during deployment: #{e.message}")
+        rescue => e
+          @user.notify(:error, 'Error during deployment. This is probably a bug')
+          @user.notify(:error, e.class)
+          @user.notify(:error, e.message)
+          @user.notify(:error, e.backtrace)
+        end
+      end
+    end
+
+    private
+
+    # check if the revision is already deployed, if not deploy it
+    def new_environment
+      new_env = EnvironmentManager.find(@revision)
+      if new_env.nil?
+        @user.notify(:info, "Revision '#{@revision}' not already deployed, trying to find optimal starting point for deployment")
+        env = EnvironmentManager.find(@old_revision) ||
+              EnvironmentManager.find(@puppet_env) ||
+              EnvironmentManager.master
+        @user.notify(:info, "Deploying '#{@revision}' from copy of '#{env.name}'")
+        new_env = env.copy(@revision)
+        @user.notify(:info, "Deployment of '#{@revision}' done!")
+      else
+        @user.notify(:info, "Revision '#{@revision}' is already deployed")
+      end
+      new_env
+    end
+
+  end
+end
+

data/lib/environmate/environment.rb

@@ -0,0 +1,105 @@
+require 'open3'
+require 'securerandom'
+
+module Environmate
+  class Environment
+    include Command
+
+    attr_reader :name
+
+    def initialize(env_path)
+      @env_path = env_path
+      @name     = File.basename(env_path)
+      @git      = GitRepository.new(env_path)
+      @install_modules_command = Environmate.configuration['install_modules_command']
+    end
+
+    # This will update the current repository and
+    # reset it to the specified revision.
+    #
+    # * +revision+ - The revision to update the repository to
+    def update(revision)
+      update_repo(revision)
+      update_submodules if has_submodules?
+      update_modules if has_puppetfile?
+    end
+
+    # This create a copy of the current repository
+    # under the specified revision name and update
+    # that environment to the specified revision.
+    #
+    # * +revision+ - The revision to update the repository to
+    def copy(revision)
+      new_path = new_env_path(revision)
+      command("cp -r #{@env_path} #{new_path}")
+      new_env = Environment.new(new_path)
+      new_env.update(revision)
+      new_env
+    end
+
+    # This will create a environment link to the repository
+    #
+    # * +puppet_env+ - The name of the link/environment
+    def link(puppet_env)
+      unless links.include?(puppet_env)
+        temp_link_path = new_env_path(SecureRandom.hex)
+        real_link_path = new_env_path(puppet_env)
+        # relinking is not atomic in linux, but mv is
+        # so we create a temporary link and rename it
+        File.symlink(@env_path, temp_link_path)
+        File.rename(temp_link_path, real_link_path)
+      end
+    end
+
+    # get a list of all the links to this environment
+    def links
+      found_links = EnvironmentManager.links.find_all do |link,target|
+        target == @name
+      end
+      found_links.map{|link, target| link}
+    end
+
+    def delete
+      FileUtils.remove_entry_secure(@env_path)
+    end
+
+    def valid?
+      @git.valid?
+    end
+
+    private
+
+    def update_repo(revision)
+      @git.fetch
+      @git.reset_hard
+      @git.clean
+      @git.checkout(revision)
+    end
+
+    def update_submodules
+      @git.submodule_update
+    end
+
+    def update_modules
+      Dir.chdir(@env_path) do
+        command(@install_modules_command)
+      end
+    end
+
+    def has_submodules?
+      gitmodules = File.join(@env_path, '.gitmodules')
+      File.exist?(gitmodules)
+    end
+
+    def has_puppetfile?
+      puppetfile = File.join(@env_path, 'Puppetfile')
+      File.exist?(puppetfile)
+    end
+
+    def new_env_path(revision)
+      base_dir = Environmate.configuration['environment_path']
+      File.join(base_dir, revision)
+    end
+
+  end
+end

data/lib/environmate/environment_manager.rb

@@ -0,0 +1,117 @@
+module Environmate
+  class EnvironmentManager
+    include Command
+
+    def self.find(env_name)
+      environments.find do |env|
+        env.name == env_name ||
+        env.links.any?{|link| File.basename(link) == env_name}
+      end
+    end
+
+    def self.environments
+      env_dir_entries('directory').map do |dir|
+        env = Environment.new(dir)
+        env.valid? ? env : nil
+      end.compact
+    end
+
+    def self.orphan_dirs
+      env_dir_entries('directory').map do |dir|
+        env = Environment.new(dir)
+        env.valid? ? nil : env
+      end.compact
+    end
+
+    def self.links
+      Hash[env_dir_entries('link').map do |dir|
+        target = File.readlink(dir)
+        [File.basename(dir), File.basename(target)]
+      end]
+    end
+
+    # get the master environment and make sure it is created
+    # and updated.
+    def self.master
+      master_path       = Environmate.configuration['master_path']
+      master_repository = Environmate.configuration['master_repository']
+      master_branch     = Environmate.configuration['master_branch']
+      unless File.exists?(File.join(master_path,'.git'))
+        git = GitRepository.new(master_path)
+        git.clone(master_repository)
+      end
+      master_env = Environment.new(master_path)
+      master_env.update("origin/#{master_branch}")
+      master_env
+    end
+
+    # cleanup old links and environments
+    def self.cleanup
+      cleanup_links
+      cleanup_environments
+      cleanup_orphan_dirs
+    end
+
+    # puppet environment name from branch name
+    def self.env_from_branch(branch)
+      prefix = Environmate.configuration['dynamic_environments_prefix']
+      if branch.start_with?(prefix)
+        branch.gsub(prefix, '').gsub(/(\/|\-)/,'_')
+      else
+        nil
+      end
+    end
+
+    private
+
+    # returns an array of environments which has remote branches
+    def self.envs_with_branches
+      env_path = Environmate.configuration['master_path']
+      git = GitRepository.new(env_path)
+      git.remote_branches.map do |branch|
+        env_from_branch(branch)
+      end.compact
+    end
+
+    # returns an array of direcories in the environement path
+    def self.env_dir_entries(ftype)
+      env_path = Environmate.configuration['environment_path']
+      Dir[env_path + '/*'].map do |dir|
+        File.ftype(dir) == ftype ? dir : nil
+      end.compact
+    end
+
+    # cleanup all the old links
+    def self.cleanup_links
+      env_path    = Environmate.configuration['environment_path']
+      static_envs = Environmate.configuration['static_environments'].keys
+      valid_links = envs_with_branches + static_envs
+      old_links = links.keys - valid_links
+      old_links.each do |old_link|
+        old_link_path = File.join(env_path, old_link)
+        Environmate.log.debug("Cleanup: Removing old link #{old_link_path}")
+        File.delete(old_link_path)
+      end
+    end
+
+    # cleanup all the old environments
+    def self.cleanup_environments
+      used_envs = links.values.uniq
+      environments.each do |env|
+        unless used_envs.include?(env.name)
+          Environmate.log.debug("Cleanup: Removing old environment #{env.name}")
+          env.delete
+        end
+      end
+    end
+
+    # cleanup all orphan directories
+    def self.cleanup_orphan_dirs
+      orphan_dirs.each do |env|
+        Environmate.log.debug("Cleanup: Removing orphan dir #{env.name}")
+        env.delete
+      end
+    end
+
+  end
+end

data/lib/environmate/errors.rb

@@ -0,0 +1,5 @@
+
+module Environmate
+  class DeployError < StandardError
+  end
+end

data/lib/environmate/git_repository.rb

@@ -0,0 +1,66 @@
+require 'open3'
+
+module Environmate
+  class GitRepository
+    include Command
+
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def submodule_update
+      #git('submodule update --init') if submodules_outdated?
+      git('submodule update --init')
+    end
+
+    def fetch
+      git('fetch --prune')
+    end
+
+    def reset_hard(revision = 'HEAD')
+      git("reset --hard #{revision}")
+    end
+
+    def clean
+      git('clean -dff')
+    end
+
+    def checkout(revision)
+      git("checkout #{revision}")
+    end
+
+    def remote_branches
+      git('branch -r').each_line.map do |branch|
+        branch[/^\s+origin\/(\S+).*$/, 1]
+      end.compact
+    end
+
+    def clone(url)
+      command("git clone #{url} #{@dir}")
+    end
+
+    def valid?
+      status
+      true
+    rescue
+      false
+    end
+
+    private
+
+    def git(cmd)
+      Dir.chdir(@dir) do
+        command("git #{cmd}")
+      end
+    end
+
+    def status
+      git('status')
+    end
+
+    def submodules_outdated?
+      !status.each_line.grep(/modified:.*\(new commits\)/).empty?
+    end
+
+  end
+end

data/lib/environmate/log.rb

@@ -0,0 +1,16 @@
+#
+# Logger Helper
+#
+require 'logger'
+
+module Environmate
+
+  def self.log
+    @log ||= Logger.new(STDOUT)
+  end
+
+  def self.logger=(logger)
+    @log = logger
+  end
+
+end

data/lib/environmate/user.rb

@@ -0,0 +1,44 @@
+#
+# This class represents a user which triggered the hook.
+#
+require 'xmpp4r'
+
+module Environmate
+  class User
+
+    def initialize(email = nil)
+      @email         = email
+      @xmpp_client   = Environmate::Xmpp.client
+      @xmpp_settings = Environmate.configuration['xmpp']
+      if @xmpp_settings && @xmpp_settings['users'].has_key?(@email)
+        @xmpp_user   = @xmpp_settings['users'][@email]
+        Envionmate.log.info("Xmpp user found #{@xmpp_user}")
+      end
+      @response      = []
+    end
+
+    # Send a message to the user
+    #
+    # * +severity+ - Message severity (log level)
+    # * +message+  - The message
+    def notify(severity, message)
+      Environmate.log.log(Logger.const_get(severity.to_s.upcase), message)
+      @response << [severity, message]
+      if @xmpp_client && @xmpp_user
+        xmpp_message = Jabber::Message.new(@xmpp_user, format(severity, message))
+        @xmpp_client.send(xmpp_message)
+      end
+    end
+
+    def format(severity, message)
+      "#{severity.to_s.upcase}: #{message}"
+    end
+
+    # Get array of messages for the response
+    def response
+      @response
+    end
+
+  end
+end
+