jenkins-peace 1.0.0

data/lib/jenkins/peace/content_downloader.rb

@@ -0,0 +1,71 @@
+require 'ruby-progressbar'
+require 'net/http'
+require 'uri'
+
+module Jenkins
+  module Peace
+    class ContentDownloader
+
+      attr_reader :target_file
+      attr_reader :logger
+
+
+      def initialize(target_file, logger)
+        @target_file = target_file
+        @logger      = logger
+      end
+
+
+      def download(url, limit = 10)
+        raise ArgumentError, 'too many HTTP redirects' if limit == 0
+
+        start_http_session(url) do |http, uri|
+          response = http.request_head(uri.path)
+          case response
+          when Net::HTTPSuccess
+            download_content(url)
+          when Net::HTTPRedirection
+            redirect = response['location']
+            logger.info "Redirected to : '#{redirect}'"
+            download(redirect, limit - 1)
+          else
+            logger.error response.value
+          end
+        end
+      rescue => e
+        logger.error "Error while downloading '#{url}' : #{e.message}"
+      end
+
+
+      def download_content(url)
+        logger.info "Downloading   : '#{url}'"
+        start_http_session(url) do |http, uri|
+          response = http.request_head(uri.path)
+          progressbar = build_progress_bar(response['content-length'].to_i)
+          File.open(target_file, 'wb') do |file|
+            http.get(uri.path) do |chunk|
+              file.write chunk
+              progressbar.progress += chunk.length
+            end
+          end
+        end
+      rescue => e
+        logger.error "Error while downloading '#{url}' : #{e.message}"
+      end
+
+
+      def build_progress_bar(total)
+        ProgressBar.create(title: 'Downloading', starting_at: 0, total: total, format: '%a |%b>%i| %p%% %t')
+      end
+
+
+      def start_http_session(url)
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          yield http, uri
+        end
+      end
+
+    end
+  end
+end

data/lib/jenkins/peace/thor_extensions.rb

@@ -0,0 +1,86 @@
+module Jenkins
+  module Peace
+    module ThorExtensions
+
+      def warn(message)
+        say message, :yellow
+      end
+
+
+      def info(message)
+        say message, :green
+      end
+
+
+      def green(string)
+        set_color string, :green
+      end
+
+
+      def red(string)
+        set_color string, :red
+      end
+
+
+      def bold(string)
+        set_color string, :bold
+      end
+
+
+      def success_message
+        info 'Done !'
+      end
+
+
+      def yes_no_question(question, &block)
+        answer = yes? question, :bold
+        if answer
+          yield if block_given?
+          success_message
+        else
+          warn 'Canceled !'
+        end
+      end
+
+
+      def download_it_first!
+        warn "War file doesn't exist, you should install it first with : jenkins.peace install <version>"
+        warn 'Exiting !'
+      end
+
+
+      def check_conflicts_and_call_method(method, version, check_method = :exists?, &block)
+        war_file = Jenkins::Peace.build_war_file(version)
+        yield war_file if block_given?
+        message = "#{method.capitalize}ing Jenkins war file version : '#{version}'"
+        if war_file.send(check_method)
+          yes_no_question('Overwrite existing file?') do
+            info message
+            Jenkins::Peace.send(method, version, true)
+          end
+        else
+          info message
+          Jenkins::Peace.send(method, version)
+          success_message
+        end
+      end
+
+
+      def formated_war_files_list
+        list = []
+        Jenkins::Peace.list.each do |war_file|
+          installed = war_file.installed? ? green(war_file.installed?) : red(war_file.installed?)
+          version = war_file.latest_version? ? "latest (#{war_file.real_version})" : war_file.version
+          list << [green(version), war_file.location, war_file.classpath, installed]
+        end
+        list
+      end
+
+
+      def formated_headers
+        [bold('Version'), bold('Location'), bold('Classpath'), bold('Installed')]
+      end
+
+    end
+  end
+end

data/lib/jenkins/peace/version.rb

@@ -0,0 +1,5 @@
+module Jenkins
+  module Peace
+    VERSION = '1.0.0'
+  end
+end

data/lib/jenkins/peace/war_file.rb

@@ -0,0 +1,151 @@
+require 'socket'
+
+module Jenkins
+  module Peace
+    class WarFile
+
+      JENKINS_VERSION_REGEX = /jenkins-core-(1\.\d{3}).jar/
+
+      attr_reader :version
+      attr_reader :lib_path
+      attr_reader :base_path
+      attr_reader :base_url
+      attr_reader :server_path
+      attr_reader :logger
+
+      attr_reader :file_name
+      attr_reader :base_dir
+      attr_reader :lib_dir
+      attr_reader :klass_path
+      attr_reader :plugins_path
+      attr_reader :location
+      attr_reader :url
+
+
+      def initialize(version, opts = {})
+        @version      = version
+        @lib_path     = opts.fetch(:lib_path, '')
+        @base_path    = opts.fetch(:base_path, '')
+        @base_url     = opts.fetch(:base_url, '')
+        @server_path  = opts.fetch(:server_path, '')
+        @logger       = opts.fetch(:logger, $stdout)
+
+        @file_name    = 'jenkins.war'
+        @base_dir     = File.join(base_path, version)
+        @lib_dir      = File.join(lib_path, version)
+        @klass_path   = File.join(lib_dir, '**/*.jar')
+        @plugins_path = File.join(lib_dir, 'WEB-INF', 'plugins')
+        @location     = File.join(base_dir, file_name)
+        @url          = File.join(base_url, version, file_name)
+      end
+
+
+      def latest_version?
+        version == 'latest'
+      end
+
+
+      def real_version
+        return version unless latest_version?
+        klass = find_core_librairy
+        klass.nil? ? nil : klass.match(JENKINS_VERSION_REGEX)[1]
+      end
+
+
+      def classpath
+        File.join(lib_dir, 'WEB-INF', 'lib', "jenkins-core-#{real_version}.jar")
+      end
+
+
+      def exists?
+        File.exists?(location)
+      end
+
+
+      def unpacked?
+        File.exists?(lib_dir) && File.exists?(classpath)
+      end
+
+
+      def installed?
+        exists? && unpacked?
+      end
+
+
+      def download!
+        FileUtils.mkdir_p base_dir
+        fetch_content(url, location)
+      end
+
+
+      def install!
+        download!
+        unpack!
+      end
+
+
+      def remove!
+        FileUtils.rm_rf base_dir
+        FileUtils.rm_rf lib_dir
+      end
+
+
+      def unpack!
+        FileUtils.mkdir_p(lib_dir)
+        execute_command("cd #{lib_dir} && jar xvf #{location}")
+      end
+
+
+      def start!(options = {})
+        control = options.fetch(:control, 3002).to_i
+        kill    = options.fetch(:kill, false)
+
+        if kill
+          TCPSocket.open('localhost', control) { |sock| sock.write('0') }
+        else
+          command = build_command_line(options)
+          exec(*command)
+        end
+      end
+
+
+      def build_command_line(options = {})
+        home    = options.fetch(:home, server_path)
+        port    = options.fetch(:port, 3001).to_i
+        control = options.fetch(:control, 3002).to_i
+        daemon  = options.fetch(:daemon, false)
+        logfile = options.fetch(logfile, nil)
+
+        java_tmp = File.join(home, 'javatmp')
+        FileUtils.mkdir_p java_tmp
+
+        ENV['HUDSON_HOME'] = home
+        cmd = ['java', "-Djava.io.tmpdir=#{java_tmp}", '-jar', location]
+        cmd << '--daemon' if daemon
+        cmd << "--httpPort=#{port}"
+        cmd << "--controlPort=#{control}"
+        cmd << "--logfile=#{File.expand_path(logfile)}" if logfile
+        cmd
+      end
+
+
+      private
+
+
+        def execute_command(command)
+          `#{command}`
+        end
+
+
+        def fetch_content(url, target_file, limit = 10)
+          ContentDownloader.new(target_file, logger).download(url)
+        end
+
+
+        def find_core_librairy
+          Dir[File.join(lib_dir, 'WEB-INF', 'lib', '*.jar')].select { |f| f =~ JENKINS_VERSION_REGEX }.first
+        end
+
+    end
+  end
+end

data/lib/jenkins_peace.rb

@@ -0,0 +1,7 @@
+require 'yaml'
+require 'jenkins/peace'
+require 'jenkins/peace/thor_extensions'
+require 'jenkins/peace/cli'
+require 'jenkins/peace/console_logger'
+require 'jenkins/peace/content_downloader'
+require 'jenkins/peace/war_file'

data/spec/lib/console_logger_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Jenkins::Peace::ConsoleLogger do
+
+  def helper
+    Jenkins::Peace::ConsoleLogger.new([])
+  end
+
+
+  describe '.info' do
+    it 'should render colored message' do
+      # allow_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:logger).and_return([])
+      expect(helper.info('foo')).to eq ["\e[32mfoo\e[0m\n"]
+    end
+  end
+
+
+  describe '.warn' do
+    it 'should render colored message' do
+      # allow_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:logger).and_return([])
+      expect(helper.warn('bar')).to eq ["\e[33mbar\e[0m\n"]
+    end
+  end
+
+
+  describe '.error' do
+    it 'should render colored message' do
+      # allow_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:logger).and_return([])
+      expect(helper.error('boo')).to eq ["\e[31mboo\e[0m\n"]
+    end
+  end
+
+end

data/spec/lib/content_downloader_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Jenkins::Peace::ContentDownloader do
+
+  VALID_URL    = 'http://jenkins.mirror.isppower.de/war/1.629/jenkins.war'
+  REDIRECT_URL = 'http://mirrors.jenkins-ci.org/war/latest/jenkins.war'
+  INVALID_URL  = 'http://mirrors.jenkins-ci.org/war/120000/jenkins.war'
+
+
+  def logger
+    Jenkins::Peace::ConsoleLogger.new([])
+  end
+
+
+  def build_content_downloader
+    Jenkins::Peace::ContentDownloader.new('/tmp/jenkins-test.war', logger)
+  end
+
+  let(:content_downloader) { build_content_downloader }
+
+
+  describe '#start_http_session' do
+    it 'should start a http session' do
+      uri = URI(VALID_URL)
+      expect(Net::HTTP).to receive(:start).with(uri.host, uri.port)
+      content_downloader.start_http_session(VALID_URL)
+    end
+  end
+
+
+  describe '#build_progress_bar' do
+    it 'should return a progress bar object' do
+      allow_any_instance_of(ProgressBar).to receive(:create)
+      content_downloader.build_progress_bar(100)
+    end
+  end
+
+
+  describe '#download' do
+    context 'when url is valid' do
+      it 'should download file' do
+        expect(content_downloader).to receive(:download_content).with(VALID_URL)
+        content_downloader.download(VALID_URL)
+      end
+    end
+
+    context 'when url is valid and redirecting' do
+      it 'should redirect' do
+        expect(content_downloader).to receive(:download_content)
+        expect_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:info)
+        content_downloader.download(REDIRECT_URL)
+      end
+    end
+
+    context 'when url is invalid' do
+      it 'should not download file' do
+        expect_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:error)
+        content_downloader.download(INVALID_URL)
+      end
+    end
+  end
+
+
+  describe '#download_content' do
+    context 'when url is valid' do
+      it 'should download file' do
+        expect_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:info).with("Downloading   : '#{VALID_URL}'")
+        expect(content_downloader).to receive(:start_http_session).with(VALID_URL)
+        content_downloader.download_content(VALID_URL)
+      end
+    end
+
+    context 'when url is invalid' do
+      it 'should not download file' do
+        expect_any_instance_of(Jenkins::Peace::ConsoleLogger).to receive(:error)
+        content_downloader.download_content(INVALID_URL)
+      end
+    end
+  end
+
+end

data/spec/lib/jenkins_peace_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe Jenkins::Peace do
+
+  def helper
+    Jenkins::Peace
+  end
+
+
+  def infos
+    {
+      base_path:          BASE_PATH,
+      war_files_cache:    WAR_FILES_CACHE,
+      war_unpacked_cache: WAR_UNPACKED_CACHE,
+      server_path:        SERVER_PATH,
+      jenkins_war_url:    JENKINS_WAR_URL
+    }
+  end
+
+
+  describe '.jenkins_war_url' do
+    it { expect(helper.jenkins_war_url).to eq JENKINS_WAR_URL }
+  end
+
+
+  describe '.base_path' do
+    it { expect(helper.base_path).to eq BASE_PATH }
+  end
+
+
+  describe '.war_files_cache' do
+    it { expect(helper.war_files_cache).to eq WAR_FILES_CACHE }
+  end
+
+
+  describe '.war_unpacked_cache' do
+    it { expect(helper.war_unpacked_cache).to eq WAR_UNPACKED_CACHE }
+  end
+
+
+  describe '.server_path' do
+    it { expect(helper.server_path).to eq SERVER_PATH }
+  end
+
+
+  describe '.infos' do
+    it { expect(helper.infos).to eq infos }
+  end
+
+
+  def stub_all_war_files_with_return(value)
+    expect_any_instance_of(Jenkins::Peace).to receive(:all_war_files).at_least(:once).and_return(value)
+  end
+
+
+  describe '.list' do
+    context 'when no war file is installed' do
+      it 'should return empty array' do
+        stub_all_war_files_with_return([])
+        expect(helper.list).to eq []
+      end
+    end
+
+    context 'when war files are installed' do
+      it 'should return a list of war files' do
+        stub_all_war_files_with_return(['1.629', '1.628', '1.630'])
+        allow_any_instance_of(Jenkins::Peace::WarFile).to receive(:installed?).and_return(true)
+        expect(helper.list.first).to be_instance_of(Jenkins::Peace::WarFile)
+        expect(helper.list.first.version).to eq '1.630'
+      end
+    end
+  end
+
+
+  describe '.latest_war_file' do
+    context 'when no war file is installed' do
+      it 'should return nil' do
+        stub_all_war_files_with_return([])
+        expect(helper.latest_war_file).to be nil
+      end
+    end
+
+    context 'when war files are installed' do
+      it 'should return the last war file installed' do
+        stub_all_war_files_with_return(['1.629', '1.628'])
+        allow_any_instance_of(Jenkins::Peace::WarFile).to receive(:installed?).and_return(true)
+        expect(helper.latest_war_file).to be_instance_of(Jenkins::Peace::WarFile)
+        expect(helper.latest_war_file.version).to eq '1.629'
+      end
+    end
+  end
+
+
+  describe '.latest_version' do
+    context 'when no war file is installed' do
+      it 'should return nil' do
+        stub_all_war_files_with_return([])
+        expect(helper.latest_version).to be nil
+      end
+    end
+
+    context 'when war files are installed' do
+      it 'should return the classpath of the last war file installed' do
+        stub_all_war_files_with_return(['1.629', '1.628'])
+        allow_any_instance_of(Jenkins::Peace::WarFile).to receive(:installed?).and_return(true)
+        expect(helper.latest_version).to eq File.join(ENV['HOME'], '.jenkins/wars/1.629/WEB-INF/lib/jenkins-core-1.629.jar')
+      end
+    end
+  end
+
+
+  describe '.clean!' do
+    it 'should remove all war files' do
+      stub_all_war_files_with_return(['1.629', '1.628'])
+      allow_any_instance_of(Jenkins::Peace::WarFile).to receive(:remove!)
+      helper.clean!
+    end
+  end
+
+
+  describe '.download' do
+    it 'should download a war file' do
+      expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:download!)
+      expect(helper.download('1.628')).to be_instance_of(Jenkins::Peace::WarFile)
+    end
+  end
+
+
+  describe '.install' do
+    it 'should install a war file' do
+      expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:install!)
+      expect(helper.install('1.628')).to be_instance_of(Jenkins::Peace::WarFile)
+    end
+  end
+
+
+  describe '.unpack' do
+    it 'should unpack a war file' do
+      expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:unpack!)
+      expect(helper.unpack('1.628')).to be_instance_of(Jenkins::Peace::WarFile)
+    end
+  end
+
+
+  describe '.remove' do
+    it 'should remove a war file' do
+      expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:exists?).and_return(true)
+      expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:remove!)
+      expect(helper.remove('1.628')).to be_instance_of(Jenkins::Peace::WarFile)
+    end
+  end
+
+
+  describe '.all_war_files' do
+    it 'should return a list of war files' do
+      expect(FileUtils).to receive(:mkdir_p).with(WAR_FILES_CACHE)
+      expect(Pathname).to receive(:new).with(WAR_FILES_CACHE).and_return(OpenStruct.new(children: []))
+      helper.all_war_files
+    end
+  end
+
+
+  describe 'check_for_presence_and_execute' do
+    context 'when file doesnt exist' do
+      it 'should check for file existence before executing method' do
+        war_file = helper.build_war_file('1.628')
+        expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:exists?).and_return(false)
+        expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:download!)
+        helper.check_for_presence_and_execute(war_file, :download!)
+      end
+    end
+
+    context 'when file exists' do
+      context 'and overwrite is false' do
+        it 'should do nothing' do
+          war_file = helper.build_war_file('1.628')
+          expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:exists?).at_least(:twice).and_return(true)
+          expect_any_instance_of(Jenkins::Peace::WarFile).to_not receive(:download!)
+          helper.check_for_presence_and_execute(war_file, :download!, false)
+        end
+      end
+
+      context 'and overwrite is true' do
+        it 'should execute method' do
+          war_file = helper.build_war_file('1.628')
+          expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:exists?).at_least(:twice).and_return(true)
+          expect_any_instance_of(Jenkins::Peace::WarFile).to receive(:download!)
+          helper.check_for_presence_and_execute(war_file, :download!, true)
+        end
+      end
+    end
+  end
+
+end