Class: Indocker::Launchers::ConfigurationDeployer

Inherits:
Object
  • Object
show all
Defined in:
lib/indocker/launchers/configuration_deployer.rb

Constant Summary collapse

REMOTE_OPERATION_TIMEOUT = 
60

Instance Method Summary collapse

Constructor Details

#initialize(logger:, global_logger:) ⇒ ConfigurationDeployer

Returns a new instance of ConfigurationDeployer.



8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/indocker/launchers/configuration_deployer.rb', line 8

def initialize(logger:, global_logger:)
  Thread.abort_on_exception = true # abort all threads if exception occurs

  @logger = logger
  @global_logger = global_logger

  @progress = Indocker::DeploymentProgress.new(
    Indocker.logger.level == Logger::DEBUG ? nil : Logger.new(STDOUT)
  )
  @compiled_images = Hash.new(false)
end

Instance Method Details

#run(configuration:, deployment_policy:) ⇒ Object

Launch deployment & measure the benchmark



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/indocker/launchers/configuration_deployer.rb', line 21

def run(configuration:, deployment_policy:)
  time = Benchmark.realtime do
    if deployment_policy.force_restart
      @logger.warn("WARNING. All containers will be forced to restart.")
    end

    if deployment_policy.skip_build
      @logger.warn("WARNING. Images build step will be skipped")
    end

    if deployment_policy.skip_deploy
      @logger.warn("WARNING. Images deploy step will be skipped")
    end

    run!(configuration: configuration, deployment_policy: deployment_policy)
  end

  @global_logger.info("Deployment finished".green)
  @global_logger.info("Total time taken: #{time.round}s".green)
end

#run!(configuration:, deployment_policy:) ⇒ Object

The main flow of the deployment would happen in this method.



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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/indocker/launchers/configuration_deployer.rb', line 43

def run!(configuration:, deployment_policy:)
  containers = find_containers_to_deploy(configuration, deployment_policy)

  cloner = Indocker::Repositories::Cloner.new(configuration, @logger)
  build_server_pool = Indocker::ServerPools::BuildServerPool.new(configuration: configuration, logger: @logger)
  deployer = Indocker::ContainerDeployer.new(configuration: configuration, logger: @logger)

  @global_logger.info("Establishing ssh sessions to all servers...")
  build_server_pool.create_sessions!

  build_servers = configuration
    .build_servers
    .uniq { |s| s.host }

  deploy_servers = containers
    .map(&:servers)
    .flatten
    .uniq { |s| s.host }

  servers = (deploy_servers + build_servers).uniq { |s| s.host }

  @progress.setup(
    binaries_servers: servers,
    build_servers:    build_servers,
    deploy_servers:   deploy_servers,
    env_files:        configuration.env_files.keys,
    repositories:     configuration.repositories.keys,
    force_restart:    deployment_policy.force_restart,
    skip_build:       deployment_policy.skip_build,
    skip_deploy:      deployment_policy.skip_deploy,
    containers:       containers,
    artifact_servers: configuration.artifact_servers,
  )

  remote_operations = sync_indocker(servers)
  wait_remote_operations(remote_operations)

  remote_operations = sync_env_files(deploy_servers, configuration.env_files)
  wait_remote_operations(remote_operations)

  remote_operations = pull_repositories(cloner, build_servers, configuration.repositories)
  wait_remote_operations(remote_operations)

  remote_operations = sync_artifacts(cloner, configuration.artifact_servers)
  wait_remote_operations(remote_operations)

  update_crontab_redeploy_rules(configuration, build_servers.first)

  containers.uniq.each do |container|
    recursively_deploy_container(
      configuration,
      deployer,
      build_server_pool,
      container,
      containers,
      deployment_policy.skip_build,
      deployment_policy.skip_deploy,
      deployment_policy.force_restart,
      deployment_policy.skip_force_restart
    )
  end

  Thread
    .list
    .each { |t|
      if t != Thread.current
        t.join if !t.stop?
      end
    }
ensure
  build_server_pool.close_sessions if build_server_pool
  deployer.close_sessions if deployer
end