run-redmine 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e5bafcf93d6a08ba073f415c92d301221055763039061bba94e727885c84bcc
+  data.tar.gz: 563893a52c53338d930e44283a4a90a52f0d2841158d2e6cf8e6a209032d8930
+SHA512:
+  metadata.gz: bde20117075026555bf0bdf1d6455b82c2fee1ba85ddde144b793d2afe7137ad2e2874f9b1ae21816070290a9ca36e9766671cb881e610b63d09c521622e2b7c
+  data.tar.gz: dd6ebb52211082fa02ac7f3107cdd96ea3fec4ec2ffc4436d8e2c70a84d48039797e2aa912d42b4c1ed5d7f96aa28da082a4fa358c95c07f264919f7bdaa93b7

data/bin/redmine

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'redmine'

data/docker/Dockerfile

@@ -0,0 +1,73 @@
+FROM ubuntu:16.04
+MAINTAINER Andrei.Malyshev@kodep.ru
+ENV PATH ~/.rbenv/shims:~/.rbenv/bin:$PATH
+ENV MAKEOPTS "-j8"
+ENV RUBY_BUILD_CACHE_PATH yes
+
+RUN echo 'LANG="ru_RU.UTF-8"' >> /etc/default/locale
+RUN echo '1.01'
+RUN apt-get update && apt-get -y install locales && locale-gen ru_RU && locale-gen ru_RU.UTF-8
+
+RUN apt-get install -y \
+  git-core \
+  autoconf \
+  bash \
+  bison \
+  bzip2 \
+  ca-certificates \
+  coreutils \
+  curl \
+  gcc \
+  git \
+  libc-dev \
+  libffi-dev \
+  libxml2-dev \
+  libxslt-dev \
+  libssl-dev \
+  libreadline-dev \
+  make \
+  subversion \
+  libmagickwand-dev \
+  openssh-client \
+  postgresql \
+  libpq-dev \
+  sudo \
+  software-properties-common \
+  graphicsmagick-libmagick-dev-compat \
+  imagemagick \
+  libsqlite3-dev \
+  tree \
+  screen
+RUN git clone --depth 1 git://github.com/rbenv/rbenv.git ~/.rbenv \
+&&  git clone --depth 1 git://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
+RUN mv /bin/sh /bin/sh.bk && ln /bin/bash /bin/sh
+
+ARG ruby_version=2.5.1
+ENV RUBY_VERSION=$ruby_version
+
+RUN rbenv install $RUBY_VERSION
+RUN mkdir -p /var/www
+WORKDIR /var/www/
+RUN git clone https://github.com/redmine/redmine.git
+WORKDIR /var/www/redmine
+
+ARG redmine_version=3.4.4
+ENV REDMINE_VERSION=$redmine_version
+
+RUN git checkout $REDMINE_VERSION
+RUN rbenv local ${RUBY_VERSION}
+ADD ./database.yml /var/www/redmine/config
+RUN gem install bundler && bundle --without=test development --retry=5
+
+ENV RAILS_ENV=development
+ADD ./pg/pg_hba.conf /etc/postgresql/9.5/main
+RUN rake generate_secret_token
+ADD ./run.sh /root/run.sh
+RUN chmod +x /root/run.sh
+
+RUN gem install redmine && rbenv rehash
+
+ARG port=3000
+ENV PORT=$port
+EXPOSE $port
+ENTRYPOINT /root/run.sh

data/docker/database.yml

@@ -0,0 +1,7 @@
+development:
+  adapter: postgresql
+  database: redmine
+  host: localhost
+  username: postgres
+  encoding: utf8
+  pool: 5

data/docker/pg/pg_hba.conf

@@ -0,0 +1,15 @@
+local   all             postgres                                trust
+
+# TYPE  DATABASE        USER            ADDRESS                 METHOD
+
+# "local" is for Unix domain socket connections only
+local   all             all                                     trust
+# IPv4 local connections:
+host    all             all             127.0.0.1/32            trust
+# IPv6 local connections:
+host    all             all             ::1/128                 md5
+# Allow replication connections from localhost, by a user with the
+# replication privilege.
+#local   replication     postgres                                peer
+#host    replication     postgres        127.0.0.1/32            md5
+#host    replication     postgres        ::1/128                 md5

data/docker/run.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -x
+env
+cd /var/www/redmine
+service postgresql start
+echo "Migrations"
+bundle exec rake db:create && rake db:migrate
+echo "Pulling plugins"
+redmine install-plugins
+echo "Server"
+bundle exec rails s -b 0.0.0.0 -p $PORT

data/lib/redmine.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative './redmine/banner'
+require_relative './redmine/cli/runner'
+
+Redmine::Banner.print
+Redmine::CLI::Runner.new.run

data/lib/redmine/banner.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Redmine
+  module Banner
+    def print
+      puts 'Redmine launcher V 1.0'
+    end
+
+    module_function :print
+  end
+end

data/lib/redmine/cli/arguments.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Redmine
+  module CLI
+    class Arguments
+      attr_accessor :command, :instance_name, :config_path, :plugins_path
+    end
+  end
+end

data/lib/redmine/cli/command_factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../commands/start'
+require_relative '../commands/pull_plugins'
+
+module Redmine
+  module CLI
+    class CommandFactory
+      def initialize(args, config)
+        @arguments = args
+        @config    = config
+      end
+
+      def command
+        case @arguments.command
+        when Redmine::CLI::Parser::COMMAND_START
+          Redmine::Commands::Start.new(@arguments, @config)
+        when Redmine::CLI::Parser::COMMAND_LIST
+          Redmine::Commands::List.new
+        when Redmine::CLI::Parser::COMMAND_INSTALL_PLUGINS
+          Redmine::Commands::PullPlugins.new(@arguments)
+        else
+          raise Redmine::CLI::UnclearCommand, @arguments.command
+        end
+      end
+    end
+  end
+end

data/lib/redmine/cli/parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+require_relative './arguments'
+
+require_relative './../commands/start'
+require_relative './../commands/list'
+
+module Redmine
+  module CLI
+    class UnclearCommand < StandardError; end
+    class Parser
+      COMMANDS = [
+        COMMAND_START           = 'start',
+        COMMAND_LIST            = 'list',
+        COMMAND_SHOW            = 'show',
+        COMMAND_SHELL           = 'shell',
+        COMMAND_PULL            = 'pull',
+        COMMAND_INSTALL_PLUGINS = 'install-plugins'
+      ].freeze
+
+      attr_reader :arguments
+
+      def initialize(args)
+        parse(args)
+      end
+
+      private
+
+      def parse(args)
+        @arguments = ::Redmine::CLI::Arguments.new
+        # options = OpenStruct.new
+        opt_parser = OptionParser.new do |opts|
+        end
+
+        opt_parser.parse!(args)
+        parse_remainings(args)
+      end
+
+      def parse_remainings(args)
+        command = args.shift
+        case command
+        when COMMAND_START
+          @arguments.command = COMMAND_START
+        when COMMAND_LIST
+          @arguments.command = COMMAND_LIST
+        when COMMAND_SHOW
+          process_show_command(args)
+        when COMMAND_SHELL
+          process_shell_command(args)
+        when COMMAND_PULL
+          process_pull_command(args)
+        when COMMAND_INSTALL_PLUGINS
+          process_install_plugins_command(args)
+        else
+          puts "Unknown command #{command}"
+          raise UnclearCommand, command
+        end
+      end
+
+      def process_show_command(args)
+        @arguments.command = COMMAND_SHOW
+        @arguments.instance_name = args.shift
+      end
+
+      def process_shell_command(args)
+        @arguments.command = COMMAND_SHELL
+        @arguments.instance_name = args.shift
+      end
+
+      def process_pull_command(args)
+        @arguments.command = COMMAND_PULL
+        @arguments.instance_name = args.shift
+      end
+
+      def process_install_plugins_command(args)
+        @arguments.command = COMMAND_INSTALL_PLUGINS
+        @arguments.config_path = args.shift
+        @arguments.plugins_path = args.shift
+      end
+    end
+  end
+end

data/lib/redmine/cli/runner.rb

@@ -0,0 +1,44 @@
+
+# frozen_string_literal: true
+
+require_relative '../config'
+require_relative './parser'
+require_relative './command_factory'
+
+module Redmine
+  module CLI
+    class Runner
+      def run
+        perform
+        # run_docker
+      end
+
+      private
+
+      def cli_args
+        ARGV
+      end
+
+      def config
+        @config ||= Redmine::Config.new(config_filename)
+      rescue
+        puts $!.message
+        puts $!.backtrace
+        puts "Invalid or missing #{config_filename}"
+      end
+
+      def arguments
+        @arguments ||= Redmine::CLI::Parser.new(cli_args).arguments
+      end
+
+      def perform
+        command = CommandFactory.new(arguments, config).command
+        command.execute
+      end
+
+      def config_filename
+        'config.yml'
+      end
+    end
+  end
+end

data/lib/redmine/commands/docker/build.rb

@@ -0,0 +1,15 @@
+module Redmine
+  module Commands
+    module Docker
+      class Build
+        def initialize(config)
+          @config = config
+        end
+
+        def command_line
+          "cd docker && docker build -t redmineup/demo-base --build-arg ruby_version=#{@config.ruby_version} --build-arg redmine_version=#{@config.redmine_version} ."
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/docker/copy_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+module Redmine
+  module Commands
+    module Docker
+      class CopyConfig
+        def initialize(config)
+          @config = config
+        end
+
+        def command_line
+          "cat << EOF >#{Dir.tmpdir}/config.yml\n#{@config.yaml}\nEOF\ndocker cp #{Dir.tmpdir}/config.yml #{@config.name}:/config.yml; rm -f #{Dir.tmpdir}/config.yml"
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/docker/create.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Redmine
+    module Commands
+      module Docker
+        class Create
+          def initialize(config)
+            @config = config
+          end
+  
+          def command_line
+            "docker create --rm --name=#{@config.name} -e PORT=#{@config.port} -p #{@config.port}:#{@config.port} --mount source=redmine-pg,target=/var/lib/postgresql/9.5/main redmineup/demo-base"
+          end
+        end
+      end
+    end
+  end
+  

data/lib/redmine/commands/docker/create_volume.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Redmine
+  module Commands
+    module Docker
+      class CreateVolume
+        def initialize(config)
+          @config = config
+        end
+
+        def command_line
+          "docker volume create redmine-pg-#{@config.name}"
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/docker/start.rb

@@ -0,0 +1,15 @@
+module Redmine
+  module Commands
+    module Docker
+      class Start
+        def initialize(config)
+          @config = config
+        end
+
+        def command_line
+          "docker start #{@config.name}"          
+        end
+      end
+    end
+  end
+end

data/lib/redmine/commands/list.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require_relative './shell'
+
+module Redmine
+  module Commands
+    DOCKER_LIST_COMMAND = 'docker ps'
+    class List
+      def results
+        parse(Shell.new.execute('docker ps'))
+      end
+
+      def execute
+        Redmine::Commands::ListPrinter.new.print_results(results)
+      end
+
+      private
+
+      def parse(docker_ps_output)
+        results = docker_ps_output.split("\n")[1..-1].map do |line|
+          process_line(line)
+        end
+        results.select { |result| result.name =~ /^redmine-run__/ }
+      end
+
+      def process_line(line)
+        line_tokens = line.split(/\s{2,}/)
+        OpenStruct.new(
+          container_id: line_tokens[0],
+          image: line_tokens[1],
+          command: line_tokens[2],
+          created: line_tokens[3],
+          status: line_tokens[4],
+          ports: line_tokens[5],
+          name: line_tokens[6]
+        )
+      end
+    end
+  end
+end

data/lib/redmine/commands/list_printer.rb

@@ -0,0 +1,24 @@
+module Redmine
+  module Commands
+    class ListPrinter
+      def print(results)
+        banner
+        results.map { |result| print_result(result) }
+        footer
+      end
+
+      def banner
+        puts 'RUNNING REDMINE INSTANCES:'
+        puts '=========================='
+      end
+
+      def print_result(result)
+        puts "\t#{result.name.gsub(/^redmine-run__/, '')}"
+      end
+
+      def footer
+        puts "\n\n"
+      end
+    end
+  end
+end

data/lib/redmine/commands/pull_plugins.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require_relative '../utils/plugin_installer'
+
+module Redmine
+  module Commands
+    class PullPlugins
+      def initialize(args)
+        @args = args
+      end
+
+      def execute
+        config.plugins.values.each do |plugin|
+          installer = Redmine::Utils::PluginInstaller.new(
+            @args.plugins_path,
+            OpenStruct.new(plugin)
+          )
+          installer.install
+        end
+      end
+
+      private
+
+      def config
+        @config ||= Redmine::Config.new(@args.config_path)
+      end
+    end
+  end
+end

data/lib/redmine/commands/shell.rb

@@ -0,0 +1,9 @@
+module Redmine
+  module Commands
+    class Shell
+      def execute(cmd)
+        Kernel.system cmd
+      end
+    end
+  end
+end

data/lib/redmine/commands/start.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+require_relative './docker/build'
+require_relative './docker/create_volume'
+require_relative './docker/create'
+require_relative './docker/copy_config'
+require_relative './docker/start'
+
+module Redmine
+  module Commands
+    class Start
+      attr_reader :config, :arguments
+
+      def initialize(arguments, config)
+        @arguments = arguments
+        @config    = config
+      end
+
+      def execute
+        run_command Redmine::Commands::Docker::Build.new(config).command_line
+        run_command Redmine::Commands::Docker::CreateVolume.new(config).command_line
+        run_command Redmine::Commands::Docker::Create.new(config).command_line
+        run_command Redmine::Commands::Docker::CopyConfig.new(config).command_line
+        run_command Redmine::Commands::Docker::Start.new(config).command_line
+      end
+
+      private
+
+      def run_command(command_line)
+        puts "+ #{command_line}"
+        Open3.popen3(command_line) do |input, output, error, process_thread|
+          Thread.new {
+            until input.closed?
+              inp = gets.chomp
+              puts inp
+              input.puts inp
+            end
+          }
+
+          t_err = Thread.new {
+            until error.eof?
+              putc error.readchar
+            end
+          }
+
+          t_out = Thread.new {
+            until output.eof?
+              putc output.readchar
+            end
+          }
+
+          Process::waitpid(process_thread.pid) rescue nil 
+          # "rescue nil" is there in case process already ended.
+
+          t_err.join
+          t_out.join
+        end
+      end
+    end
+  end
+end

data/lib/redmine/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Redmine
+  class Config
+    def initialize(filename)
+      @filename = filename
+      parse
+    end
+
+    def ruby_version
+      @config['ruby']['version']
+    end
+
+    def redmine_version
+      @config['redmine']['version']
+    end
+
+    def port
+      @config['server']['port']
+    end
+
+    def name
+      "redmine-run__#{@config['name']}"
+    end
+
+    def plugins
+      @config['plugins']
+    end
+
+    def yaml
+      YAML.dump(@config)
+    end
+
+    private
+
+    def parse
+      content = File.read(@filename)
+      @config = YAML.safe_load(content)
+    end
+  end
+end

data/lib/redmine/utils/plugin_installer.rb

@@ -0,0 +1,49 @@
+module Redmine
+  module Utils
+    class PluginInstaller
+      def initialize(plugins_folder, plugin_props)
+        @plugins_folder = plugins_folder
+        @plugin         = plugin_props
+      end
+
+      def install
+        if folder_exists?
+          update_plugin
+        else
+          clone_plugin
+        end
+      end
+
+      private
+
+      def folder_exists?
+        File.directory?(dest_dir)
+      end
+
+      def dest_dir
+        File.join(@plugins_folder, @plugin.folder)
+      end
+
+      def shell
+        @shell ||= Redmine::Commands::Shell.new
+      end
+
+      def clone_plugin
+        shell.execute(
+          "git clone #{@plugin.git} #{dest_dir}"
+        )
+      end
+
+      def update_plugin
+        shell.execute(
+          "cd #{dest_dir}; git fetch -a; git reset --hard #{commit_specification}"
+        )
+      end
+
+      def commit_specification
+        return @plugin.tag if @plugin.tag
+        return "origin/#{@plugin.branch}" if @plugin.branch
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: run-redmine
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrei Malyshev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-25 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: Andrei.Malyshev@kodep.ru
+executables:
+- redmine
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/redmine
+- docker/Dockerfile
+- docker/database.yml
+- docker/pg/pg_hba.conf
+- docker/run.sh
+- lib/redmine.rb
+- lib/redmine/banner.rb
+- lib/redmine/cli/arguments.rb
+- lib/redmine/cli/command_factory.rb
+- lib/redmine/cli/parser.rb
+- lib/redmine/cli/runner.rb
+- lib/redmine/commands/docker/build.rb
+- lib/redmine/commands/docker/copy_config.rb
+- lib/redmine/commands/docker/create.rb
+- lib/redmine/commands/docker/create_volume.rb
+- lib/redmine/commands/docker/start.rb
+- lib/redmine/commands/list.rb
+- lib/redmine/commands/list_printer.rb
+- lib/redmine/commands/pull_plugins.rb
+- lib/redmine/commands/shell.rb
+- lib/redmine/commands/start.rb
+- lib/redmine/config.rb
+- lib/redmine/utils/plugin_installer.rb
+homepage: https://redmineup.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Run redmine in one line
+test_files: []