yadecli 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a44a9ea70d28da9ff038f8cdedebd2dd4bed6cbe675779ea04365b5fd125b153
-  data.tar.gz: 383afa33fde904b3a921f64305c4a3dc83c8b6396d14872d6d0da0d05d5ec339
+  metadata.gz: 6709b5385d663fd644c167d3e225e8c0fa9909acabb9111f572b71f7baf26887
+  data.tar.gz: ad6776bb1dff0d7d8f0fc1124637d10df6768cd0f3e4591f64106ae328ae62a7
 SHA512:
-  metadata.gz: aa291dc050459a4712674344e72bc34b759c72e9e70baaac7b4bd2be36a26a67ec2ed191db5e31efb71ce8de48ad18bbed945c04efb0d28860aff7294c347e82
-  data.tar.gz: d6152e28590b6b2bffb1c7e29fdb403864d352f61dffb126cddc2cc85411f1ca3508e906d8aa48a46d118901bd6633f1c5813bc78fed79799dd38265c93bd4d3
+  metadata.gz: 98a614da2705e764cdce869d5bf396181af93995546196c796e074846a149dd9e60c84b4080dc4cfbc3c7517a73b3721766d5148749b1c33b02ee50d34885d89
+  data.tar.gz: f1af5277f437d9369b9ce05c9ec3536ee5497cddbe6c1b255ee5539e44fba87e4839f1ca1a7da2fe10f8de93943fbc5566c13943b185b07843264c98d0d6b24b

data/.gitignore

@@ -6,8 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
-
 # rspec failure tracking
 .rspec_status
-
-*.log
+*.log
+.DS_Store

data/Gemfile

@@ -4,3 +4,8 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in yadecli.gemspec
 gemspec
+
+gem 'yade-common', :path => "#{ENV['HOME']}/projekte/yade/src/yade-common"
+gem 'yade-composer-rest-client', :path => "#{ENV['HOME']}/projekte/yade/src/yade-composer-rest-client"
+gem 'yade-domain-rest-client', :path => "#{ENV['HOME']}/projekte/yade/src/yade-domain-rest-client"
+gem 'yade-project-rest-client', :path => "#{ENV['HOME']}/projekte/yade/src/yade-project-rest-client"

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    yadecli (0.1.3)
+    yadecli (0.1.4)
       activemodel (~> 5.2)
       artii (~> 2.1)
       colorize (~> 0.8)
       dotenv (~> 2.5)
       gitlab (~> 3.6)
       httparty (~> 0.13)
+      mutations (~> 0.8)
       net-ssh (~> 5.0)
       rest-client (~> 2.0)
       settingslogic (~> 2.0)
@@ -15,6 +16,41 @@ PATH
       tty-command (~> 0.8)
       tty-prompt (~> 0.16)
       tty-table (~> 0.10)
+      yade-composer-rest-client (~> 0.1)
+      yade-domain-rest-client (~> 0.1)
+      yade-project-rest-client (~> 0.1)
+
+PATH
+  remote: /Users/seba/projekte/yade/src/yade-common
+  specs:
+    yade-common (0.1.2)
+      activemodel (~> 5.2)
+      httparty (~> 0.15)
+      settingslogic (~> 2.0)
+
+PATH
+  remote: /Users/seba/projekte/yade/src/yade-composer-rest-client
+  specs:
+    yade-composer-rest-client (0.1.2)
+      activemodel (~> 5.2)
+      httparty (~> 0.15)
+      yade-common (~> 0.1)
+
+PATH
+  remote: /Users/seba/projekte/yade/src/yade-domain-rest-client
+  specs:
+    yade-domain-rest-client (0.1.2)
+      activemodel (~> 5.2)
+      httparty (~> 0.15)
+      yade-common (~> 0.1)
+
+PATH
+  remote: /Users/seba/projekte/yade/src/yade-project-rest-client
+  specs:
+    yade-project-rest-client (0.1.2)
+      activemodel (~> 5.2)
+      httparty (~> 0.15)
+      yade-common (~> 0.1)
 
 GEM
   remote: https://rubygems.org/
@@ -83,6 +119,8 @@ GEM
     multi_json (1.13.1)
     multi_test (0.1.2)
     multi_xml (0.6.0)
+    mutations (0.8.3)
+      activesupport
     necromancer (0.4.0)
     net-ssh (5.0.2)
     netrc (0.11.0)
@@ -123,7 +161,7 @@ GEM
       unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.10.0)
     settingslogic (2.0.9)
-    strings (0.1.3)
+    strings (0.1.4)
       strings-ansi (~> 0.1.0)
       unicode-display_width (~> 1.4.0)
       unicode_utils (~> 1.4.0)
@@ -174,6 +212,10 @@ DEPENDENCIES
   rspec (~> 3.0)
   rspec-json_expectations (~> 2.1)
   rubocop (~> 0.58.0)
+  yade-common!
+  yade-composer-rest-client!
+  yade-domain-rest-client!
+  yade-project-rest-client!
   yadecli!
 
 BUNDLED WITH

data/lib/yadecli/cli/application.rb

@@ -11,14 +11,29 @@ module Yadecli
 
       class_option 'verbose', type: :boolean, default: false
 
-      desc 'connect NAME', 'Connect to a yade backend'
-      def connect(url)
-        Yadecli::Service::ConnectService.new.connect url
+      desc 'version', 'Print Version'
+      def version
+        puts Yadecli::VERSION
+      end
+
+      desc 'connect URL', 'Connect to a yade backend'
+      def connect(yade_url)
+        CliUtil.print_header('Yade Connect',
+                             ["Going to connect to yade backend", ''])
+
+        outcome = Yadecli::Command::ConnectCommand.run(yade_url: yade_url)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'login AUTH_URL USERNAME PASSWORD', 'Login to a yade'
       def login(auth_url, username, password)
-        Yadecli::Service::AuthenticationService.new.login auth_url, username, password
+        CliUtil.print_header('Yade Login',
+                             ["Going to log in user #{username}", ''])
+
+        outcome = Yadecli::Command::LoginCommand.run(auth_url: auth_url, auth_username: username, auth_password: password)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'host TYPE', 'Manage hosts'

data/lib/yadecli/cli/composer.rb

@@ -11,57 +11,113 @@ module Yadecli
       # setup command
       desc 'setup', 'Setup yade composer on this host'
       def setup
-        Yadecli::Service::ComposerService.new.setup
+        CliUtil.print_header('YadeCli Composer Setup',
+                             ['Answer the following questions to setup Composer on this host:', ''])
+
+        outcome = Yadecli::Command::Composer::ComposerSetupCommand.run
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       # list command
       desc 'list', 'List the available Yade composer projects'
       def list
-        Yadecli::Service::ComposerService.new.list
+        CliUtil.print_header('YadeCli Composer List',
+                             ['This are the available Yade composer projects you can install', ''])
+
+        outcome = Yadecli::Command::Composer::ComposerListCommand.run
+
+        CliUtil.print_command_outcome(outcome)
+
+        puts ''
+        puts 'You can install any of the listed project with the following command:'
+        puts ''
+        puts '  bin/yadecli composer install <name> <branch> [--pull] [--setup] [--clean]'.colorize(:mode => :bold)
+        puts ''
       end
 
       # install command
       desc 'install', 'Install a Yade composer project'
       method_option :clean, default: false, aliases: '-c', desc: 'Clean install, will delete a existing composer project'
       method_option :yes, default: false, aliases: '-y', desc: 'Will answer yes to all questions, This will run a git pull on installed projects without asking'
-      method_option :pull, default: false, aliases: '-p', desc: 'Will run a git pull on a already installed project'
+      method_option :pull, default: false, aliases: '-p', desc: 'Will pull the container belonging to the project'
       def install(project_name, branch_name = nil)
-        Yadecli::Service::ComposerService.new.install(project_name, branch_name, options)
+        CliUtil.print_header('YadeCli Composer Install',
+                             ["Going to install Yade composer project #{project_name}", ''])
+
+        outcome = Yadecli::Command::Composer::ComposerInstallCommand.run(project_name: project_name,
+                                                                         branch_name: branch_name,
+                                                                         options: options)
+        CliUtil.print_command_outcome(outcome)
       end
 
       # switch branch command
       desc 'switch', 'Switch the branch of a installed Composer project'
       method_option :pull, default: false, aliases: '-p', desc: 'Will run a git pull after switching the branch'
       def switch(project_name, target_branch)
-        Yadecli::Service::ComposerService.new.switch(project_name, target_branch, options)
+        CliUtil.print_header('Composer Switch',
+                             ["Going to switch branch of composer project #{project_name} to #{target_branch}", ''])
+
+        outcome = Yadecli::Command::Composer::ComposerSwitchCommand.run(project_name: project_name,
+                                                                        target_branch: target_branch,
+                                                                        options: options)
+        CliUtil.print_command_outcome(outcome)
       end
 
       # uninstall command
       desc 'uninstall', 'Uninstall a Yade composer project'
       method_option :yes, default: false, aliases: '-y', desc: 'Will answer yes to all questions, This will uninstall the project without asking'
-      def uninstall(name)
-        Yadecli::Service::ComposerService.new.uninstall(name, options)
+      def uninstall(project_name)
+        CliUtil.print_header('YadeCli Composer Uninstall',
+                             ["Going to uninstall composer project #{project_name}", ''])
+
+        outcome = Yadecli::Command::Composer::ComposerUninstallCommand.run(project_name: project_name,
+                                                                           options: options)
+        CliUtil.print_command_outcome(outcome)
       end
 
       # start command
-      desc 'start', 'Start a Yade Composer service'
-      def start(project_name = nil, service_name = nil)
-        Yadecli::Service::ComposerService.new.start_service(project_name, service_name)
+      desc 'start', 'Start a Yade composer service'
+      def start(project_name, service_name)
+        CliUtil.print_header('YadeCli Composer Start',
+                             ['Going to start composer service:',
+                              " ↳ Composer Project : #{project_name}",
+                              " ↳ Service Name     : #{service_name}"])
+
+        outcome = Yadecli::Command::Composer::ComposerStartCommand.run(project_name: project_name,
+                                                                       service_name: service_name,
+                                                                       options: options)
+        CliUtil.print_command_outcome(outcome)
       end
 
       # stop command
       desc 'stop', 'Stop a Yade Composer service'
-      method_option :rm, default: false, aliases: '-r', desc: 'Remoce the docker container after stopping'
+      method_option :rm, default: false, aliases: '-r', desc: 'Remove the docker container after stopping'
       method_option :down, default: false, aliases: '-r', desc: 'Run docker-compose down -v'
-      def stop(project_name = nil, service_name = nil)
-        Yadecli::Service::ComposerService.new.stop_service(project_name, service_name, options)
+      def stop(project_name, service_name)
+        CliUtil.print_header('Composer Service Stop',['Going to stop composer service:',
+                                                      " ↳ Composer Project : #{project_name}",
+                                                      " ↳ Service Name     : #{service_name}"])
+
+        outcome = Yadecli::Command::Composer::ComposerStopCommand.run(project_name: project_name,
+                                                                      service_name: service_name,
+                                                                      options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       # log container output of service
       desc 'log', 'Stop a Yade Composer service'
       method_option :follow, default: false, aliases: '-f', desc: 'Log the docker containers output of the service'
       def log(project_name, service_name)
-        Yadecli::Service::ComposerService.new.log_service(project_name, service_name, options)
+        CliUtil.print_header('Composer Service Log',["Going to show logs for composer service #{service_name}.",
+                                                     'Hit ctrl + c to stop when you use the -f option'])
+
+        outcome = Yadecli::Command::Composer::ComposerLogCommand.run(project_name: project_name,
+                                                                     service_name: service_name,
+                                                                     options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
     end
   end

data/lib/yadecli/cli/host.rb

@@ -4,24 +4,38 @@ require 'thor'
 
 module Yadecli
   module Cli
-
-    # Build
+    # Host
     class Host < Thor
 
       desc 'list', 'List available Yade hosts'
       def list
-        Yadecli::Service::HostService.new.list
+        CliUtil.print_header'Yade list hosts',
+                            ['This are the available hosts', '']
+
+        outcome = Yadecli::Command::Host::HostListCommand.run
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'bootstrap', 'Bootstrap a Yade host to prepare it for provisioning'
       method_option :setup, default: true, aliases: '-s', desc: 'Setup Yade bootstrap repository on host and install plugins'
       def bootstrap(host_fqdn)
-        Yadecli::Service::HostService.new.bootstrap(host_fqdn, options)
+        CliUtil.print_header'Yade bootstrap host',
+                            ["Going to bootstrap Yade host #{host_fqdn}", '']
+
+        outcome = Yadecli::Command::Host::HostBootstrapCommand.run(host_fqdn: host_fqdn, options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'provision', 'Provision a Yade host'
       def provision(host_fqdn)
-        Yadecli::Service::HostService.new.provision(host_fqdn, options)
+        CliUtil.print_header'Yade provision host',
+                            ["Going to provision Yade host #{host_fqdn}", '']
+
+        outcome = Yadecli::Command::Host::HostProvisionCommand.run(host_fqdn: host_fqdn, options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
     end
   end

data/lib/yadecli/cli/module.rb

@@ -10,13 +10,24 @@ module Yadecli
 
       desc 'list', 'List available modules'
       def list(project_name)
-        Yadecli::Service::ModuleService.new.list(project_name)
+        CliUtil.print_header'YadeCli List Modules', ["This are the available modules for the Yade project #{project_name}", '']
+
+        outcome = Yadecli::Command::Module::ModuleListCommand.run(project_name: project_name)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'install', 'Install a module for the project given by name'
       method_option :yes, aliases: '-y', desc: 'Answering yes to all question, will do a update if module already installed'
-      def install(project_name, module_name)
-        Yadecli::Service::ModuleService.new.install(project_name, module_name, options)
+      method_option :all, aliases: '-a', desc: 'Install all modules of the project'
+      def install(project_name, *module_names)
+        CliUtil.print_header'YadeCli Install Module',
+                            ["Going to install module #{module_names.join(', ')} for Yade project #{project_name}"]
+
+        outcome = Yadecli::Command::Module::ModuleInstallCommand.run(project_name: project_name,
+                                                                     module_names: module_names, options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
     end

data/lib/yadecli/cli/project.rb

@@ -10,31 +10,53 @@ module Yadecli
 
       desc 'list', 'List available projects'
       def list
-        Yadecli::Service::ProjectService.new.list
+        CliUtil.print_header'YadeCli Projects', ['This are the available Yade projects', '']
+
+        outcome = Yadecli::Command::Project::ProjectListCommand.run
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'install', 'Install a project'
       method_option :yes, aliases: '-y', desc: 'Answering yes to all question, will do a update if project already installed'
       def install(project_name)
-        Yadecli::Service::ProjectService.new.install(project_name, options)
+        CliUtil.print_header'YadeCli Install Project',
+                            ["Going to install Yade project #{project_name}", '']
+
+        outcome = Yadecli::Command::Project::ProjectInstallCommand.run(project_name: project_name, options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'uninstall', 'Uninstall a project'
       method_option :yes, aliases: '-y', desc: 'Answering yes to all question, will do a unattended uninstall'
       def uninstall(project_name)
-        Yadecli::Service::ProjectService.new.uninstall(project_name, options)
+        CliUtil.print_header'YadeCli Uninstall Project',
+                            ["Going to uninstall Yade project #{project_name}", '']
+
+        outcome = Yadecli::Command::Project::ProjectUninstallCommand.run(project_name: project_name, options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'setup', 'Setup a project'
-      #method_option :yes, aliases: '-y', desc: 'Answering yes to all question, will do a unattended uninstall'
       def setup(project_name)
-        Yadecli::Service::ProjectService.new.setup(project_name, options)
+        CliUtil.print_header'YadeCli Project Setup',
+                            ["Going to setup Yade project #{project_name}"]
+
+        outcome = Yadecli::Command::Project::ProjectSetupCommand.run(project_name: project_name, options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
       desc 'start', 'Start a project'
-      #method_option :yes, aliases: '-y', desc: 'Answering yes to all question, will do a unattended uninstall'
-      def start(project_name)
-        Yadecli::Service::ProjectService.new.start(project_name, options)
+      def start(project_name, selection = nil)
+        CliUtil.print_header'YadeCli Project Start',['Going to start Yade Project']
+
+        outcome = Yadecli::Command::Project::ProjectStartCommand.run(project_name: project_name, selection: selection,
+                                                                     options: options)
+
+        CliUtil.print_command_outcome(outcome)
       end
 
     end

data/lib/yadecli/cli/response/project_start_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# project start response
+class ProjectStartResponse
+  include ActiveModel::Model
+  include ActiveModel::Serializers::JSON
+
+  attr_accessor :project, :project_home, :selection
+
+  validates_presence_of 'project', 'project_home', 'selection'
+
+  def attributes
+    instance_values
+  end
+
+  def write(path)
+    File.open(path, 'w') { |file| file.write(self.as_json(include: :project).to_json) }
+  end
+end

data/lib/yadecli/cli/task.rb

@@ -8,13 +8,17 @@ module Yadecli
     class Task < Thor
 
       desc 'list', 'List the available tasks of a xxx'
-      def list(module_name = nil)
-        Yadecli::Service::BuildTaskService.new.list(module_name)
+      def list(project_name, module_name = nil)
+        CliUtil.print_header'YadeCli Tasks', ['This are the available Yade tasks', '']
+
+        Yadecli::Command::Task::TaskListCommand.run(project_name: project_name, module_name: module_name)
+
+        #CliUtil.print_command_outcome(outcome)
       end
 
-      # desc 'pdf', 'Build html output'
-      # def pdf
-      #   p 'Building pdf...'
+      # desc 'exec', 'Execute a module task'
+      # def exec(module_name, task_name)
+      #   #Yadecli::Service::BuildTaskService.new.exec(module_name, task_name)
       # end
     end
   end

data/lib/yadecli/client/gitlab_client.rb

@@ -12,16 +12,14 @@ module Yadecli
       # request yade token
       def initialize
         Gitlab.configure do |config|
-          config.endpoint       = AppConfig[:git_api_url]   # API endpoint URL, default: ENV['GITLAB_API_ENDPOINT']
-          config.private_token  = AppConfig[:git_token]     # user's private token or OAuth2 access token, default: ENV['GITLAB_API_PRIVATE_TOKEN']
+          config.endpoint       = Yade::Common::Config::ComposerConfig[:git_api_url]
+          config.private_token  = Yade::Common::Config::ComposerConfig[:git_token]
         end
-
-        #Gitlab.http_proxy('squid.dzbw.de', 3128)
       end
 
       # get branch names from gitlab project given by name
       def get_branch_names(repository_name)
-        projects = Gitlab.projects
+        projects = Gitlab.projects(search: repository_name)
 
         project = projects.select { |p| repository_name == p.name }.first
 
@@ -32,7 +30,7 @@ module Yadecli
 
       # get branch names from gitlab project given by name
       def get_default_branch(repository_name)
-        projects = Gitlab.projects
+        projects = Gitlab.projects(search: repository_name)
 
         project = projects.select { |p| repository_name == p.name }.first
 

data/lib/yadecli/command/composer/composer_install_command.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'mutations'
+require 'uri'
+
+module Yadecli
+  module Command
+    module Composer
+      class ComposerInstallCommand < Mutations::Command
+
+        required do
+          string :project_name, empty: false
+        end
+
+        optional do
+          string :branch_name, empty: false
+          hash :options do
+            string :* # Allows any key to pass through. Useful for dynamic key / value objects
+          end
+        end
+
+        #
+        def execute
+          composer_project_client = Yade::Composer::Rest::Client::ComposerProjectClient.new
+          composer_service_client = Yade::Composer::Rest::Client::ComposerServiceClient.new
+
+          composer_project = composer_project_client.get_by_name(self.project_name)
+
+          # delete already installed when option --clean given
+          FileUtils.rm_rf(composer_project.install_dir) if options[:clean]
+
+          # check preconditions
+          check_install_preconditions(options)
+
+          # check already installed
+          already_installed = composer_project.installed?
+
+          # ask for branch if not given from commandline
+          branch_name = UserInput.select_branch(composer_project.git_repo_name) if branch_name == nil && !already_installed && !options[:yes]
+
+          if already_installed
+            puts "Composer project #{project_name} already installed.".colorize(color: :blue, mode: :bold)
+            puts '  ↳ Doing a git pull.'
+
+            pull_repository(composer_project, options)
+          else
+            puts "Composer project #{project_name} will be installed.".colorize(color: :blue, mode: :bold)
+            puts '  ↳ Doing a git clone.'
+
+            clone_repository(composer_project, branch_name)
+          end
+
+          puts ''
+          if already_installed
+            puts "  Successfully updated '#{composer_project.name}' at #{composer_project.install_dir}."
+          else
+            puts "  Successfully installed '#{composer_project.name}' to #{composer_project.install_dir}."
+          end
+
+          composer_services = composer_service_client.get_by_composer_project_id(composer_project.id)
+          service_names = composer_services.collect(&:name).join(' | ')
+
+          pull_container(composer_project) if options[:pull]
+
+          """
+  Use the following commands to manage the service(s)
+    Start : bin/yadecli composer start #{composer_project.name} #{service_names}
+    Stop  : bin/yadecli composer stop  #{composer_project.name} #{service_names}
+          """
+        end
+
+        private
+
+        # check install preconditions
+        def check_install_preconditions(options)
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+          cmd.run('test -x /usr/bin/docker') if SystemUtil.os == 'linux'
+          cmd.run('test -x /usr/local/bin/docker') if SystemUtil.os == 'macosx'
+
+          cmd.run('test -x /usr/local/bin/docker-compose')
+        end
+
+        # clone repository
+        def clone_repository(composer_project, branch_name)
+          username = Yade::Common::Config::ComposerConfig[:git_username]
+          password = Yade::Common::Config::ComposerConfig[:git_password]
+
+          git_url = URI.parse(composer_project.gitUrl)
+
+          scheme = git_url.scheme
+          host = git_url.host
+          path = git_url.path
+
+          url_with_auth = "#{scheme}://#{username}:#{password}@#{host}#{path}"
+
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+          cmdline = "git clone --depth=1 "
+          cmdline += "-b #{branch_name} " if branch_name != nil
+          cmdline += "#{url_with_auth} #{composer_project.install_dir}"
+
+          cmd.run(cmdline, only_output_on_error: true)
+        end
+
+        # pull repository
+        def pull_repository(composer_project, options)
+          if options[:yes]
+            answer = true
+          else
+            puts ''
+            answer = TTY::Prompt.new.yes?('Do you want to pull the changes for the repository?')
+          end
+
+          if answer
+            cmd = TTY::Command.new(output: Yadecli.LOGGER)
+            cmd.run('git pull', only_output_on_error: true, chdir: composer_project.install_dir)
+          else
+            puts 'There is nothing more I can do for you. Bye.'
+            exit(1)
+          end
+        end
+
+        # pull container
+        def pull_container(composer_project)
+          # make shure we are logged in to the docker registry
+          docker_login
+
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+          puts ''
+          puts 'Pulling docker images:'.colorize(color: :blue)
+
+          doco = YAML.load_file("#{composer_project.install_dir}/docker-compose.yml")
+
+          has_failed_pulls = false
+          doco['services'].each do |k, v|
+            cmdline = "docker-compose pull #{k}"
+
+            print " ↳  #{cmdline}... "
+            begin
+              cmd.run(cmdline, chdir: composer_project.install_dir)
+
+              puts 'done'.colorize(:green)
+            rescue TTY::Command::ExitError => e
+              puts 'failed'.colorize(:red)
+              has_failed_pulls = true
+            end
+          end
+
+          puts ''
+          puts 'Successfully pulled all docker containers.'.colorize(:green) unless has_failed_pulls
+          puts "Failed to pull for at least on container. See log at #{Dir.pwd}/composer.log".colorize(:red) if has_failed_pulls
+        end
+
+        # docker login
+        def docker_login
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+          cmdline = "docker login #{Yade::Common::Config::ComposerConfig[:docker_registry_url]} -u #{Yade::Common::Config::ComposerConfig[:docker_registry_username]} -p #{Yade::Common::Config::ComposerConfig[:docker_registry_password]}"
+
+          cmd.run(cmdline, only_output_on_error: true)
+        end
+      end
+    end
+  end
+end