Class: Yadecli::Service::ComposerService

Inherits:
Object
  • Object
show all
Defined in:
lib/yadecli/service/composer_service.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ ComposerService

Returns a new instance of ComposerService.



17
18
19
20
21
 
# File 'lib/yadecli/service/composer_service.rb', line 17

def initialize
  @composer_project_client = Yadecli::Client::ComposerProjectClient.new
  @composer_service_client = Yadecli::Client::ComposerServiceClient.new
  @composer_container_client = Yadecli::Client::ComposerContainerClient.new
end

Instance Method Details

#install(project_name, branch_name = nil, options) ⇒ Object

install composer project with name



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/yadecli/service/composer_service.rb', line 93

def install(project_name, branch_name = nil, options)
  CliUtil.print_header('YadeCli Composer Install',
                       ["Going to install Yade composer project #{project_name}", ''])

  composer_project = @composer_project_client.get_by_name(project_name)

  #   # delete already installed when option --clean given
  #   uninstall(options, true) if options[:clean]

  #   # truncate log file
  #   File.open(@log_file, 'w') { |file| file.truncate(0) }

  # 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(' | ')

  puts ''
  puts '  Use the following commands to manage the service(s)'
  puts "    Start : bin/yadecli composer start #{composer_project.name} #{service_names}"
  puts "    Stop  : bin/yadecli composer stop  #{composer_project.name} #{service_names}"

  pull_container(composer_project) if options[:pull]

  # if options[:setup]
  #   if SystemUtil.os == :linux
  #     setup_services
  #   else
  #     puts ''
  #     puts 'WARNING: Setting up services on systems other then linux is not supported.'.colorize(:yellow)
  #   end
  # end
end

#list ⇒ Object

list composer projects from gitlab



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/yadecli/service/composer_service.rb', line 38

def list
  CliUtil.print_header('YadeCli Composer List',
                       ['This are the available Yade composer projects you can install', ''])

  composer_projects = @composer_project_client.list

  # print table
  table = TTY::Table.new header: ['Id', 'Name', 'Services', 'Installed', 'Branches', 'Git Url']

  # add as rows to table
  composer_projects.each do |p|
    project_id = p.id
    project_name = p.name
    project_installed = p.installed?

    composer_services = @composer_service_client.get_by_composer_project_id(project_id)
    service_names = composer_services.collect(&:name).join(', ')

    gitlab_client = Yadecli::Client::GitlabClient.new

    branches = gitlab_client.get_branch_names(p.git_repo_name)
    default_branch = gitlab_client.get_default_branch(p.git_repo_name)

    if project_installed
      current_branch = FileUtil.git_current_branch(p.install_dir)
    else
      current_branch = nil
    end

    branches = branches.map do |b|
      if b == default_branch && b == current_branch
        "#{b} (Default, Current)"
      elsif b == default_branch && b != current_branch
        "#{b} (Default)"
      elsif b == current_branch && b != default_branch
          "#{b} (Current)"
      else
        b
      end
    end

    table << [project_id, project_name, service_names , project_installed, branches.join(', '), p.gitUrl]
  end

  renderer = TTY::Table::Renderer::ASCII.new(table, padding: [0, 1])
  puts renderer.render

  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

#log_service(project_name, service_name, options) ⇒ Object

log the containers output of the composer service with the given name



292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'lib/yadecli/service/composer_service.rb', line 292

def 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 stopp when you use the -f option'])

  sleep 1

  composer_project = @composer_project_client.get_by_name(project_name)
  composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)

  composer_service = composer_services.select { |s| s.name == service_name }.first

  composer_containers = @composer_container_client.get_by_composer_service_id(composer_service.id)

  container_names = composer_containers.map(&:name).join(' ')

  begin
    cmdline = 'docker-compose logs'
    cmdline += ' -f' if options[:follow]
    cmdline += " #{container_names}"

    cmd = TTY::Command.new(uuid: false)

    cmd.run(cmdline, chdir: install_dir)
  rescue TTY::Command::ExitError => e
    puts e
  end
end

#setup ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/yadecli/service/composer_service.rb', line 23

def setup
  CliUtil.print_header('YadeCli Composer Setup',
                       ['Answer the following questions to setup Composer on this host:', ''])

  AppConfig[:git_username] = UserInput.ask(' * Gitlab Username?', :git_username)
  AppConfig[:git_password] = UserInput.ask(' * Gitlab Password?', :git_password)
  AppConfig[:git_token] = UserInput.ask(' * Gitlab Api Token?', :git_token)
  AppConfig[:docker_registry_url] = UserInput.ask(' * Docker Registry Url?', :docker_registry_url)
  AppConfig[:docker_registry_username] = UserInput.ask(' * Docker Registry Username?', :docker_registry_username)
  AppConfig[:docker_registry_password] = UserInput.ask(' * Docker Registry Password?', :docker_registry_password)

  AppConfig.write!
end

#start_service(project_name, service_name) ⇒ Object

starts the composer service with the given name



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/yadecli/service/composer_service.rb', line 213

def start_service(project_name, service_name)
  CliUtil.print_header('YadeCli Composer Start',
                       ['Going to start composer service:',
                        " ↳ Composer Project : #{project_name}",
                        " ↳ Service Name     : #{service_name}"])

  begin
    composer_project = @composer_project_client.get_by_name(project_name)
    composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)

    # load project dotenv
    dotenv_file = "#{composer_project.install_dir}/.env"
    Dotenv.load(dotenv_file)

    # check required envs are set fom .env file or system environment variables

    composer_service = composer_services.select { |s| s.name == service_name }.first

    composer_service.requiredEnvs&.split(',').each do |re|
      if ENV[re] == nil
        puts ''
        puts "Unable to start service. Required environment variable #{re} is not set.".colorize(:red)
        puts "Either specify the variable and a value in #{dotenv_file} or as a system environment variable an try to run again.".colorize(:red)

        exit 1
      end
    end

    composer_containers = @composer_container_client.get_by_composer_service_id(composer_service.id)

    cmdline = "docker-compose up -d #{composer_containers.map(&:name).join(' ')}"

    cmd = TTY::Command.new(output: Yadecli.LOGGER)

    puts ''
    print "Executing command '#{cmdline}'... "

    cmd.run(cmdline, chdir: composer_project.install_dir)

    puts 'done'.colorize(:green)
  rescue TTY::Command::ExitError => e
    puts 'failed'.colorize(:red)
  end
end

#stop_service(project_name, service_name, options) ⇒ Object

stops the composer service with the given name



259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/yadecli/service/composer_service.rb', line 259

def stop_service(project_name, service_name, options)
  CliUtil.print_header('Composer Service Stop',['Going to stop composer service:',
                        " ↳ Composer Project : #{project_name}",
                        " ↳ Service Name     : #{service_name}"])

  begin
    composer_project = @composer_project_client.get_by_name(project_name)
    composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)

    composer_service = composer_services.select { |s| s.name == service_name }.first

    composer_containers = @composer_container_client.get_by_composer_service_id(composer_service.id)

    container_names = composer_containers.map(&:name).join(' ')

    cmdline = "docker-compose stop #{container_names}"
    cmdline += " && docker-compose rm -f #{container_names}" if options[:rm]
    cmdline += ' && docker-compose down -v' if options[:down]

    cmd = TTY::Command.new(output: Yadecli.LOGGER)

    puts ''
    print "Executing command '#{cmdline}'... "

    cmd.run(cmdline, chdir: composer_project.install_dir)

    puts 'done'.colorize(:green)
  rescue TTY::Command::ExitError => e
    puts 'failed'.colorize(:red)
  end
end

#switch(project_name, target_branch, options) ⇒ Object

switch to branch



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/yadecli/service/composer_service.rb', line 154

def switch(project_name, target_branch, options)
  CliUtil.print_header('Composer Switch',
                       ["Going to switch branch of composer project #{project_name} to #{target_branch}", ''])

  composer_project = @composer_project_client.get_by_name(project_name)

  message = "Switching to branch #{target_branch}"
  message += ' and pull changes' if options[:pull]

  print message

  cmdline = "git fetch && git checkout -B #{target_branch}"
  cmdline += " && git pull origin #{target_branch}" if options[:pull]

  begin
    cmd = TTY::Command.new(output: Yadecli.LOGGER)

    cmd.run(cmdline, chdir: composer_project.install_dir)

    puts ' done'.colorize(:green)
  rescue TTY::Command::ExitError => e
    puts ' failed'.colorize(:red)
    puts e
  end
end

#uninstall(name, options, suppress_header = false) ⇒ Object

uninstall a composer project



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/yadecli/service/composer_service.rb', line 181

def uninstall(name, options, suppress_header = false)
  CliUtil.print_header('YadeCli Composer Uninstall',
                       ["Going to uninstall composer project #{name}", '']) unless suppress_header

  composer_project = @composer_project_client.get_by_name(name)

  # unless CliUtil.check_root
  #   puts ''
  #   puts 'ERROR: The composer uninstall must run with sudo.'.colorize(:red)
  #   exit 2
  # end

  answer = false
  unless options[:yes]
    prompt = TTY::Prompt.new
    answer = prompt.yes?("Do you really want to uninstall the #{composer_project.name} composer project?".colorize(:mode => :bold))
  end

  if options[:yes] || answer
    FileUtils.rm_rf(composer_project.install_dir)
    # FileUtils.rm_f("/etc/systemd/system/#{@name}.service")
  else
    puts 'There is nothing more I can do for you. Bye.'
    exit(1)
  end

  puts ''
  puts 'Composer project successfully uninstalled'.colorize(:color => :green, :mode => :bold)
  puts ''
end