Module: Indocker

Defined in:
lib/indocker.rb,
lib/indocker/version.rb

Defined Under Namespace

Modules: Artifacts, Concerns, Configurations, Containers, EnvFiles, Images, Launchers, Networks, Registries, Repositories, ServerPools, Volumes Classes: BuildContext, BuildContextHelper, BuildServer, ContainerDeployer, ContainerHelper, ContextArgs, CrontabRedeployRulesBuilder, DeployContext, DeploymentChecker, DeploymentPolicy, DeploymentProgress, Docker, DockerRunArgs, EnvFileHelper, HashMerger, IndockerHelper, LoggerFactory, Rsync, Server, Shell, SshResultLogger, SshSession

Constant Summary collapse

VERSION = 
"0.1.15"

Class Method Summary collapse

Class Method Details

.add_artifact(artifact) ⇒ Object 



148
149
150
 
# File 'lib/indocker.rb', line 148

def add_artifact(artifact)
  artifacts.push(artifact)
end

.add_build_server(build_server) ⇒ Object 



231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/indocker.rb', line 231

def add_build_server(build_server)
  if !build_server.is_a?(Indocker::BuildServer)
    raise ArgumentError.new("should be an instance of Indocker::BuildServer, got: #{build_server.inspect}")
  end

  existing = build_servers.detect {|s| s == build_server}

  if existing
    raise ArgumentError.new("build server with name #{build_server.name} was already defined")
  end

  build_servers.push(build_server)
end

.add_registry(registry) ⇒ Object 



160
161
162
163
164
165
166
 
# File 'lib/indocker.rb', line 160

def add_registry(registry)
  if !registry.is_a?(Indocker::Registries::Abstract)
    raise ArgumentError.new("should be an instance of Indocker::Registries::Abstract, got: #{registry.inspect}")
  end

  registries.push(registry)
end

.add_repository(repository) ⇒ Object 



152
153
154
155
156
157
158
 
# File 'lib/indocker.rb', line 152

def add_repository(repository)
  if !repository.is_a?(Indocker::Repositories::Abstract)
    raise ArgumentError.new("should be an instance of Indocker::Repositories::Abstract, got: #{repository.inspect}")
  end

  repositories.push(repository)
end

.add_server(server) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/indocker.rb', line 168

def add_server(server)
  if !server.is_a?(Indocker::Server)
    raise ArgumentError.new("should be an instance of Indocker::Server, got: #{server.inspect}")
  end

  existing = servers.detect {|s| s == server}

  if existing
    raise ArgumentError.new("server with name #{server.name} was already defined")
  end

  servers.push(server)
end

.artifacts ⇒ Object 



265
266
267
 
# File 'lib/indocker.rb', line 265

def artifacts
  @artifacts ||= []
end

.build_configuration(name) ⇒ Object 



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
 
# File 'lib/indocker.rb', line 289

def build_configuration(name)
  builder = Indocker::Configurations::ConfigurationBuilder.new(
    name: name,
    repositories: repositories,
    registries: registries,
    servers: servers,
    build_servers: build_servers,
    volumes: volumes,
    networks: networks,
    env_files: env_files,
    containers: containers,
  )

  @configuration = builder.configuration
  builder
end

.build_helper(&proc) ⇒ Object 



443
444
445
 
# File 'lib/indocker.rb', line 443

def build_helper(&proc)
  Indocker::BuildContextHelper.class_exec(&proc)
end

.build_servers ⇒ Object 



269
270
271
 
# File 'lib/indocker.rb', line 269

def build_servers
  @build_servers ||= []
end

.check(servers: []) ⇒ Object 



363
364
365
366
367
368
369
370
 
# File 'lib/indocker.rb', line 363

def check(servers: [])
  Indocker::DeploymentChecker
    .new(Indocker.logger)
    .run(
      configuration: configuration,
      servers: servers,
    )
end

.compile(images:, skip_dependent:) ⇒ Object 



383
384
385
386
387
388
389
390
391
 
# File 'lib/indocker.rb', line 383

def compile(images:, skip_dependent:)
  Indocker::Launchers::ImagesCompiler
    .new(Indocker.logger)
    .compile(
      configuration: configuration,
      image_list: images,
      skip_dependent: skip_dependent,
    )
end

.configuration ⇒ Object 



277
278
279
 
# File 'lib/indocker.rb', line 277

def configuration
  @configuration || (raise ArgumentError.new("no configuration provided"))
end

.configuration_name ⇒ Object 



451
452
453
 
# File 'lib/indocker.rb', line 451

def configuration_name
  @configuration_name || (raise ArgumentError.new("configuration was not specified"))
end

.container_files ⇒ Object 



190
191
192
 
# File 'lib/indocker.rb', line 190

def container_files
  @container_files || (raise ArgumentError.new("container files were not found. Set bounded contexts dir"))
end

.containers ⇒ Object 



285
286
287
 
# File 'lib/indocker.rb', line 285

def containers
  @containers ||= []
end

.define_container(name) ⇒ Object 



325
326
327
328
329
330
331
332
333
 
# File 'lib/indocker.rb', line 325

def define_container(name)
  builder = Indocker::Containers::ContainerBuilder.new(
    name: name,
    configuration: configuration,
  )

  containers.push(builder.container)
  builder
end

.define_env_file(env_file) ⇒ Object 



214
215
216
217
218
219
220
221
 
# File 'lib/indocker.rb', line 214

def define_env_file(env_file)
  if env_files.detect {|ef| ef.name == env_file.name}
    Indocker.logger.error("env file :#{env_file.name} was already defined")
    exit 1
  end

  env_files.push(env_file)
end

.define_image(name) ⇒ Object 



306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
 
# File 'lib/indocker.rb', line 306

def define_image(name)
  path = caller[0].split(':').first

  if !(path =~ /\/image.rb$/)
    Indocker.logger.error("image :#{name} should be defined in image.rb file")
    exit 1
  end

  builder = Indocker::Images::ImageBuilder.new(
    name: name,
    configuration: configuration,
    dir: path.split('image.rb').first
  )

  images.push(builder.image)

  builder
end

.define_network(name) ⇒ Object 



182
183
184
185
186
187
188
 
# File 'lib/indocker.rb', line 182

def define_network(name)
  if networks.detect {|n| n.name == name}
    raise ArgumentError.new("network :#{name} was already defined")
  end

  networks.push(Indocker::Networks::Network.new(name))
end

.define_volume(volume) ⇒ Object 



223
224
225
226
227
228
229
 
# File 'lib/indocker.rb', line 223

def define_volume(volume)
  if volumes.detect { |v| v.name == volume.name}
    raise ArgumentError.new("volume :#{volume.name} was already defined")
  end

  volumes.push(volume)
end

.deploy(containers: [], skip_tags: [], tags: [], skip_dependent: false, skip_containers: [], servers: [], skip_build: false, skip_deploy: false, force_restart: false, skip_force_restart: [], auto_confirm: false, require_confirmation: false) ⇒ Object 



335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'lib/indocker.rb', line 335

def deploy(containers: [], skip_tags: [], tags: [], skip_dependent: false, 
  skip_containers: [], servers: [], skip_build: false, skip_deploy: false,
  force_restart: false, skip_force_restart: [], auto_confirm: false, 
  require_confirmation: false)

  deployment_policy = Indocker::DeploymentPolicy.new(
    deploy_containers:    containers,
    deploy_tags:          tags,
    servers:              servers,
    skip_dependent:       skip_dependent,
    skip_containers:      skip_containers,
    skip_build:           skip_build,
    skip_deploy:          skip_deploy,
    skip_tags:            skip_tags,
    force_restart:        force_restart,
    skip_force_restart:   skip_force_restart,
    auto_confirm:         auto_confirm,
    require_confirmation: require_confirmation,
  )

  Indocker::Launchers::ConfigurationDeployer
    .new(logger: Indocker.logger, global_logger: Indocker.global_logger)
    .run(
      configuration:     configuration,
      deployment_policy: deployment_policy
    )
end

.deploy_dir ⇒ Object 



132
133
134
135
136
137
138
 
# File 'lib/indocker.rb', line 132

def deploy_dir
  if @deploy_dir
    @deploy_dir
  else
    raise ArgumentError.new("deploy dir was not specified")
  end
end

.dockerignore ⇒ Object 



439
440
441
 
# File 'lib/indocker.rb', line 439

def dockerignore
  @dockerignore || []
end

.env_files ⇒ Object 



273
274
275
 
# File 'lib/indocker.rb', line 273

def env_files
  @env_files ||= []
end

.export_command ⇒ Object 



112
113
114
 
# File 'lib/indocker.rb', line 112

def export_command
  @export_command
end

.global_build_args ⇒ Object 



403
404
405
 
# File 'lib/indocker.rb', line 403

def global_build_args
  Indocker::ContextArgs.new(nil, configuration.global_build_args, nil)
end

.global_logger ⇒ Object

Global logger would output data without dependency on how we deploy the progress Currently it will always output data to stdout



427
428
429
 
# File 'lib/indocker.rb', line 427

def global_logger
  @global_logger ||= Indocker::LoggerFactory.create(STDOUT, @log_level)
end

.helper ⇒ Object 



407
408
409
 
# File 'lib/indocker.rb', line 407

def helper
  Indocker::BuildContextHelper.new(Indocker.configuration, nil)
end

.image_files ⇒ Object 



194
195
196
 
# File 'lib/indocker.rb', line 194

def image_files
  @image_files || (raise ArgumentError.new("image files were not found. Set bounded contexts dir"))
end

.images ⇒ Object 



281
282
283
 
# File 'lib/indocker.rb', line 281

def images
  @images ||= []
end

.launched?(contaner_name, servers: []) ⇒ Boolean

Returns:

  • (Boolean) 


372
373
374
375
376
377
378
379
380
381
 
# File 'lib/indocker.rb', line 372

def launched?(contaner_name, servers: [])
  silent_logger = Logger.new(File.open(File::NULL, "w"))
  Indocker::DeploymentChecker
    .new(silent_logger, silent_logger)
    .launched?(
      contaner_name,
      configuration: configuration,
      servers: servers,
    )
end

.logger ⇒ Object

This logger outputs progress of the deployment It will not output anything for deployment without debug option



413
414
415
416
417
418
419
420
421
422
423
 
# File 'lib/indocker.rb', line 413

def logger
  @logger ||= begin
    logger_stdout = if @log_level == Logger::DEBUG
      STDOUT
    else
      File.open(File::NULL, "w")
    end

    Indocker::LoggerFactory.create(logger_stdout, @log_level)
  end
end

.networks ⇒ Object 



253
254
255
 
# File 'lib/indocker.rb', line 253

def networks
  @networks ||= []
end

.redeploy_crontab_path ⇒ Object 



128
129
130
 
# File 'lib/indocker.rb', line 128

def redeploy_crontab_path
  @redeploy_crontab_path
end

.registries ⇒ Object 



249
250
251
 
# File 'lib/indocker.rb', line 249

def registries
  @registries ||= []
end

.repositories ⇒ Object 



245
246
247
 
# File 'lib/indocker.rb', line 245

def repositories
  @repositories ||= []
end

.root_dir ⇒ Object 



140
141
142
143
144
145
146
 
# File 'lib/indocker.rb', line 140

def root_dir
  if @root_dir
    File.expand_path(@root_dir)
  else
    raise ArgumentError.new("root dir was not specified")
  end
end

.run(container_name, force_restart) ⇒ Object 



393
394
395
396
397
398
399
400
401
 
# File 'lib/indocker.rb', line 393

def run(container_name, force_restart)
  Indocker::Launchers::ContainerRunner
    .new(Indocker.logger)
    .run(
      configuration: configuration,
      container_name: container_name,
      force_restart: force_restart
    )
end

.servers ⇒ Object 



261
262
263
 
# File 'lib/indocker.rb', line 261

def servers
  @servers ||= []
end

.set_bounded_contexts_dir(path) ⇒ Object 



198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
 
# File 'lib/indocker.rb', line 198

def set_bounded_contexts_dir(path)
  @container_files = {}

  Dir[File.join(path, '**/container.rb')].map do |path|
    name = path.gsub('/container.rb', '').split('/').last.to_sym
    @container_files[name] = path
  end

  @image_files = {}

  Dir[File.join(path, '**/image.rb')].map do |path|
    name = path.gsub('/image.rb', '').split('/').last.to_sym
    @image_files[name] = path
  end
end

.set_configuration_name(name) ⇒ Object 



447
448
449
 
# File 'lib/indocker.rb', line 447

def set_configuration_name(name)
  @configuration_name = name
end

.set_deploy_dir(val) ⇒ Object 



116
117
118
 
# File 'lib/indocker.rb', line 116

def set_deploy_dir(val)
  @deploy_dir = val
end

.set_dockerignore(ignore_list) ⇒ Object 



435
436
437
 
# File 'lib/indocker.rb', line 435

def set_dockerignore(ignore_list)
  @dockerignore = ignore_list
end

.set_export_command(command) ⇒ Object 



108
109
110
 
# File 'lib/indocker.rb', line 108

def set_export_command(command)
  @export_command = command
end

.set_log_level(level) ⇒ Object 



431
432
433
 
# File 'lib/indocker.rb', line 431

def set_log_level(level)
  @log_level = level
end

.set_redeploy_crontab_path(val) ⇒ Object 



124
125
126
 
# File 'lib/indocker.rb', line 124

def set_redeploy_crontab_path(val)
  @redeploy_crontab_path = val
end

.set_root_dir(val) ⇒ Object 



120
121
122
 
# File 'lib/indocker.rb', line 120

def set_root_dir(val)
  @root_dir = val
end

.volumes ⇒ Object 



257
258
259
 
# File 'lib/indocker.rb', line 257

def volumes
  @volumes ||= []
end