indocker 0.1.12 → 0.1.17

data/lib/indocker/artifacts/base.rb

@@ -0,0 +1,26 @@
+class Indocker::Artifacts::Base
+  def build_source_path(*args)
+    raise StandardError.new('not implemented')
+  end
+
+  def is_git?
+    false
+  end
+
+  private
+
+    def build_all_files(files: [], source_path: nil, target_path: nil)
+      all_files = files
+
+      if source_path && target_path
+        all_files.push(
+          Indocker::Artifacts::DTO::FileDTO.new(
+            source_path: source_path,
+            target_path: target_path,
+          )
+        )
+      end
+
+      all_files
+    end
+end

data/lib/indocker/artifacts/dto/file_dto.rb

@@ -0,0 +1,8 @@
+class Indocker::Artifacts::DTO::FileDTO
+  attr_reader :source_path, :target_path
+
+  def initialize(source_path:, target_path:)
+    @source_path = source_path
+    @target_path = target_path
+  end
+end

data/lib/indocker/artifacts/git.rb

@@ -1,13 +1,17 @@
-class Indocker::Artifacts::Git
-  attr_reader :name, :remote_name, :remote_url, :branch, :source_path, :target_path
+class Indocker::Artifacts::Git < Indocker::Artifacts::Base
+  attr_reader :name, :remote_name, :remote_url, :branch, :files
 
-  def initialize(name:, remote_name:, remote_url:, branch:, source_path:, target_path:)
+  def initialize(name:, remote_name:, remote_url:, branch:, files: [], source_path: nil, target_path: nil)
     @name        = name
     @remote_name = remote_name
     @remote_url  = remote_url
     @branch      = branch
-    @source_path = source_path
-    @target_path = target_path
+
+    @files = build_all_files(
+      files:       files,
+      source_path: source_path,
+      target_path: target_path,
+    )
   end
 
   def repository
@@ -22,4 +26,12 @@ class Indocker::Artifacts::Git
   def project_name(url)
     url.split('/').last.gsub('.git', '')
   end
+
+  def is_git?
+    true
+  end
+
+  def build_source_path(path)
+    File.join(self.repository.clone_path, path)
+  end
 end

data/lib/indocker/artifacts/remote.rb

@@ -0,0 +1,17 @@
+class Indocker::Artifacts::Remote < Indocker::Artifacts::Base
+  attr_reader :name, :files
+
+  def initialize(name:, files: [], source_path: nil, target_path: nil)
+    @name = name
+
+    @files       = build_all_files(
+      files:       files,
+      source_path: source_path,
+      target_path: target_path,
+    )
+  end
+
+  def build_source_path(path)
+    path
+  end
+end

data/lib/indocker/artifacts/services/synchronizer.rb

@@ -0,0 +1,59 @@
+class Indocker::Artifacts::Services::Synchronizer
+  def initialize(logger:, progress:)
+    @logger   = logger
+    @progress = progress
+  end
+
+  def call(clonner, artifact_servers)
+    @logger.info("Syncing git artifacts")
+
+    remote_operations = []
+
+    artifact_servers.each do |artifact, servers|
+      remote_operations += servers.map do |server|
+        @progress.start_syncing_artifact(server, artifact)
+
+        thread = Thread.new do
+          server.synchronize do
+            session = Indocker::SshSession.new(
+              host: server.host,
+              user: server.user,
+              port: server.port,
+              logger: @logger
+            )
+
+            if artifact.is_git?
+              @logger.info("Pulling git artifact  #{artifact.name.to_s.green} for #{server.user}@#{server.host}")
+              result = clonner.clone(session, artifact.repository)
+
+              if result.exit_code != 0
+                @logger.error("Artifact repository :#{artifact.repository.name} was not clonned")
+                @logger.error(result.stderr_data)
+                exit 1
+              end
+            end
+
+            artifact.files.each do |artifact_item|
+              source_path = artifact.build_source_path(artifact_item.source_path)
+
+              result = session.exec!("mkdir -p #{artifact_item.target_path}")
+              result = session.exec!("cp #{source_path} #{artifact_item.target_path}")
+
+              if !result.success?
+                @logger.error(result.stdout_data)
+                @logger.error(result.stderr_data)
+                exit 1
+              end
+            end
+
+            @progress.finish_syncing_artifact(server, artifact)
+          end
+        end
+
+        Indocker::Launchers::DTO::RemoteOperationDTO.new(thread, server, :artifact_sync)
+      end
+    end
+
+    remote_operations
+  end
+end

data/lib/indocker/build_context.rb

@@ -1,55 +1,18 @@
 require 'fileutils'
 
 class Indocker::BuildContext
-  attr_reader :session, :server, :configuration, :helper, :logger
+  attr_reader :configuration, :logger, :global_logger, :helper
 
-  def initialize(configuration:, build_server:, logger:, global_logger:)
+  def initialize(configuration:, logger:, global_logger:)
     @configuration = configuration
     @logger = logger
     @helper = Indocker::BuildContextHelper.new(@configuration, @build_server)
-    @server = build_server
     @global_logger = global_logger
-    @compiled_images = Hash.new(false)
-  end
-
-  def create_session!
-    return unless @server
-
-    @session = Indocker::SshSession.new(
-      host: @server.host,
-      user: @server.user,
-      port: @server.port,
-      logger: @logger
-    )
-  end
-
-  def exec!(command)
-    @session.exec!(command)
-  end
-
-  def close_session
-    @session.close if @session
-  end
-
-  def image_compiled?(image)
-    @compiled_images[image]
-  end
-
-  def set_busy(flag)
-    @busy = !!flag
-  end
-
-  def busy?
-    !!@busy
-  end
-
-  def set_compiled(image)
-    @compiled_images[image] = true
   end
 
   def build_image(image, build_dir, args: [])
     image_name = image.image_name
-    registry = image.registry
+    registry   = image.registry
     tag        = image.tag
 
     FileUtils.cd(build_dir) do
@@ -79,7 +42,9 @@ class Indocker::BuildContext
       end
 
       Indocker::Docker.tag(image.local_registry_url, image.registry_url)
-      Indocker::Docker.tag(image.local_registry_url, image.local_registry_url)
+      if image.registry_url != image.local_registry_url
+        Indocker::Docker.tag(image.local_registry_url, image.local_registry_url)
+      end
 
       if !image.registry.is_local?
         Indocker::Docker.push(image.registry_url)

data/lib/indocker/build_context_helper.rb

@@ -4,7 +4,7 @@ class Indocker::BuildContextHelper
   def initialize(configuration, build_server)
     @configuration = configuration
     @build_server = build_server
-    @clonned_repositories = Hash.new(false)
+    @cloned_repositories = Hash.new(false)
   end
 
   def image_url(image_sym)

data/lib/indocker/container_deployer.rb

@@ -5,7 +5,7 @@ class Indocker::ContainerDeployer
     @configuration = configuration
     @logger = logger
 
-    @server_pool = Indocker::ServerPool.new(
+    @server_pool = Indocker::ServerPools::DeployServerPool.new(
       configuration: @configuration,
       logger: logger
     )
@@ -14,10 +14,6 @@ class Indocker::ContainerDeployer
     @deployed_servers = {}
   end
 
-  def create_sessions!
-    @server_pool.create_sessions!
-  end
-
   def deploy(container, force_restart, skip_force_restart, progress)
     return if @deployed_containers[container]
 
@@ -37,30 +33,23 @@ class Indocker::ContainerDeployer
       end
 
       exec_proc.call do
-        deploy_context = @server_pool.get(server)
+        deploy_server = @server_pool.create_connection!(server)
         @logger.info("Deploying container: #{container.name.to_s.green} to #{server.user}@#{server.host}")
 
-        command_output  = @logger.debug? ? "" : " > /dev/null"
-        debug_options   = @logger.debug? ? "-d" : ""
-
-        if force_restart && !skip_force_restart.include?(container.name)
-          force_restart_options = force_restart ? "-f" : ""
-        end
-
-        result = deploy_context
-          .session
-          .exec!(
-            "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/run -C #{Indocker.configuration_name} -c #{container.name} #{debug_options} #{command_output} #{force_restart_options}"
+        result = deploy_server
+          .run_container_remotely(
+            configuration_name: Indocker.configuration_name,
+            container_name:     container.name,
+            force_restart:      force_restart && !skip_force_restart.include?(container.name)
           )
 
-        Indocker::SshResultLogger
-          .new(@logger)
-          .log(result, "#{container.name.to_s.green} deployment for server #{server.name} failed")
-
-        exit 1 if result.exit_code != 0
+        if result.exit_code != 0
+          exit 1 
+        end
+        
         @logger.info("Container deployment to #{server.user}@#{server.host} finished: #{container.name.to_s.green}")
 
-        deploy_context.close_session
+        deploy_server.close_session
         progress.finish_deploying_container(container, server)
       end
     end

data/lib/indocker/crontab_redeploy_rules_builder.rb

@@ -1,14 +1,13 @@
 class Indocker::CrontabRedeployRulesBuilder
-  CRONTAB = <<-CRONTAB
-SHELL=/bin/bash
-PATH=/usr/local/bundle/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
-
-%{rules}
+  CRONTAB = <<~CRONTAB
+    SHELL=/bin/bash
+    PATH=/usr/local/bundle/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 
+    %{rules}
   CRONTAB
 
   LOG_FILE      = "/var/log/indocker-redeploy-%{env}.log"
-  COMMAND       = "export TERM=xterm;#{Indocker.deploy_dir}/indocker/bin/deploy -C %{env} -f -B -y -c %{container_name}"
+  COMMAND       = "export TERM=xterm;%{deploy_dir}/indocker/bin/deploy -C %{env} -f -B -y -c %{container_name}"
   REDEPLOY_RULE = %Q{%{schedule} echo `date` "- %{command}..." >> %{log_file}; %{command} 1>/dev/null 2>>%{log_file}; echo `date` "- done, exitcode = $?" >> %{log_file}}
 
   def initialize(configuration:, logger:)
@@ -41,6 +40,7 @@ PATH=/usr/local/bundle/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sb
     COMMAND % {
       env:            env,
       container_name: container.name,
+      deploy_dir: Indocker.deploy_dir
     }
   end
 

data/lib/indocker/deploy_context.rb

@@ -2,42 +2,14 @@ require 'digest'
 require 'fileutils'
 
 class Indocker::DeployContext
-  attr_reader :server, :session
+  attr_reader :configuration, :logger
 
-  def initialize(logger:, configuration:, server:)
+  def initialize(logger:, configuration:)
     @logger = logger
     @configuration = configuration
-    @server = server
     @restart_policy = Indocker::Containers::RestartPolicy.new(configuration, logger)
   end
 
-  def create_session!
-    return unless @server
-    
-    @session = Indocker::SshSession.new(
-      host: @server.host,
-      user: @server.user,
-      port: @server.port,
-      logger: @logger
-    )
-  end
-
-  def exec!(command)
-    @session.exec!(command)
-  end
-
-  def close_session
-    @session.close if @session
-  end
-
-  def set_busy(flag)
-    @busy = !!flag
-  end
-
-  def busy?
-    !!@busy
-  end
-
   def deploy(container, force_restart)
     @logger.info("Deploying container: #{container.name.to_s.green}")
     @logger.debug("Deploy dir: #{Indocker.deploy_dir}")
@@ -46,14 +18,14 @@ class Indocker::DeployContext
 
     container.networks.each do |network|
       Indocker::Docker.create_network(
-        Indocker::NetworkHelper.name(@configuration.name, network)
+        Indocker::Networks::NetworkHelper.name(@configuration.name, network)
       )
     end
 
     container.volumes.each do |volume|
       if volume.is_a?(Indocker::Volumes::External)
         Indocker::Docker.create_volume(
-          Indocker::VolumeHelper.name(@configuration.name, volume)
+          Indocker::Volumes::VolumeHelper.name(@configuration.name, volume)
         )
       end
     end

data/lib/indocker/deployment_checker.rb

@@ -109,13 +109,15 @@ class Indocker::DeploymentChecker
     { missing_containers: total_missing_containers, invalid_containers: total_invalid_containers }
   end
 
-  def launched?(container_name, configuration:, servers:)
+  def launched?(container_name, configuration:, servers: nil)
     container = Indocker.containers.detect { |c| c.name == container_name.to_sym }
     hostnames = (container.get_start_option(:scale) || 1).times.map do |number|
       Indocker::ContainerHelper.hostname(configuration.name, container, number)
     end
 
-    result = run(configuration: configuration, servers: servers, only_containers: [container.name])
+    servers ||= container.servers.map(&:name)
+
+    result = run(configuration: configuration, servers: container.servers.map(&:name), only_containers: [container.name])
     result[:missing_containers].empty?
   end
 end

data/lib/indocker/docker_run_args.rb

@@ -159,7 +159,7 @@ class Indocker::DockerRunArgs
         if volume.is_a?(Indocker::Volumes::Local)
           args.push("-v #{volume.local_path}:#{volume.path}")
         elsif volume.is_a?(Indocker::Volumes::External)
-          name = Indocker::VolumeHelper.name(configuration.name, volume)
+          name = Indocker::Volumes::VolumeHelper.name(configuration.name, volume)
           args.push("-v #{name}:#{volume.path}")
         elsif volume.is_a?(Indocker::Volumes::Repository)
           repository = configuration.repositories.fetch(volume.repository_name) do
@@ -173,7 +173,7 @@ class Indocker::DockerRunArgs
       end
 
       container.networks.each do |network|
-        name = Indocker::NetworkHelper.name(configuration.name, network)
+        name = Indocker::Networks::NetworkHelper.name(configuration.name, network)
         args.push("--network #{name}")
       end
 

data/lib/indocker/images/image_compiler.rb

@@ -61,7 +61,6 @@ class Indocker::Images::ImageCompiler
     end
 
     build_context.build_image(image, compile_dir)
-    build_context.set_compiled(image)
 
     @compiled_images[image] = true
   end

data/lib/indocker/{configuration_deployer.rb → launchers/configuration_deployer.rb}

@@ -2,7 +2,7 @@ require 'timeout'
 require 'benchmark'
 require 'tempfile'
 
-class Indocker::ConfigurationDeployer
+class Indocker::Launchers::ConfigurationDeployer
   REMOTE_OPERATION_TIMEOUT = 60
 
   def initialize(logger:, global_logger:)
@@ -14,13 +14,11 @@ class Indocker::ConfigurationDeployer
     @progress = Indocker::DeploymentProgress.new(
       Indocker.logger.level == Logger::DEBUG ? nil : Logger.new(STDOUT)
     )
+    @compiled_images = Hash.new(false)
   end
 
   # Launch deployment & measure the benchmark
   def run(configuration:, deployment_policy:)
-    build_context_pool = nil
-    deployer = nil
-
     time = Benchmark.realtime do
       if deployment_policy.force_restart
         @logger.warn("WARNING. All containers will be forced to restart.")
@@ -45,13 +43,12 @@ class Indocker::ConfigurationDeployer
   def run!(configuration:, deployment_policy:)
     containers = find_containers_to_deploy(configuration, deployment_policy)
 
-    clonner = Indocker::Repositories::Clonner.new(configuration, @logger)
-    build_context_pool = Indocker::BuildContextPool.new(configuration: configuration, logger: @logger, global_logger: @global_logger)
+    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_context_pool.create_sessions!
-    deployer.create_sessions!
+    build_server_pool.create_sessions!
 
     build_servers = configuration
       .build_servers
@@ -83,24 +80,24 @@ class Indocker::ConfigurationDeployer
     remote_operations = sync_env_files(deploy_servers, configuration.env_files)
     wait_remote_operations(remote_operations)
 
-    remote_operations = pull_repositories(clonner, build_servers, configuration.repositories)
+    remote_operations = pull_repositories(cloner, build_servers, configuration.repositories)
     wait_remote_operations(remote_operations)
 
-    remote_operations = sync_artifacts(clonner, configuration.artifact_servers)
+    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_context_pool, 
-        container, 
-        containers, 
-        deployment_policy.skip_build, 
-        deployment_policy.skip_deploy, 
-        deployment_policy.force_restart, 
+        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
@@ -109,7 +106,7 @@ class Indocker::ConfigurationDeployer
       .list
       .each { |t| t.join if t != Thread.current }
   ensure
-    build_context_pool.close_sessions if build_context_pool
+    build_server_pool.close_sessions if build_server_pool
     deployer.close_sessions if deployer
   end
 
@@ -130,7 +127,7 @@ class Indocker::ConfigurationDeployer
 
   def find_containers_to_deploy(configuration, deployment_policy)
     load_enabled_containers(configuration)
-    
+
     containers = []
 
     deployment_policy.deploy_tags.each do |tag|
@@ -261,23 +258,25 @@ class Indocker::ConfigurationDeployer
   def collect_soft_dependent_containers(containers, configuration)
     result = containers
 
-    result += containers.map do |container|
-      container.soft_dependent_containers.reject do |soft_dependent_container|
-        configuration.enabled_containers.include?(soft_dependent_container.name) &&
-        Indocker.launched?(soft_dependent_container.name)
-      end
-    end.flatten
+    soft_dependent_containers = containers
+      .map(&:soft_dependent_containers)
+      .flatten
+      .uniq(&:name)
 
+    result +=  soft_dependent_containers.select do |container|
+      configuration.enabled_containers.include?(container.name) &&
+        !Indocker.launched?(container.name)
+    end
 
-    result.uniq
+    result
   end
 
-  def compile_image(configuration, image, build_context)
-    return if build_context.image_compiled?(image)
+  def compile_image(configuration, image, build_server)
+    return if @compiled_images[image]
 
     image.dependent_images.each do |dependent_image|
-      next if build_context.image_compiled?(dependent_image)
-      compile_image(configuration, dependent_image, build_context)
+      next if @compiled_images[image]
+      compile_image(configuration, dependent_image, build_server)
     end
 
     compiler = Indocker::Images::ImageCompiler.new
@@ -287,37 +286,35 @@ class Indocker::ConfigurationDeployer
     result = nil
 
     time = Benchmark.realtime do
-      result = build_context
-        .session
-        .exec!(
-          "cd #{Indocker::IndockerHelper.indocker_dir} && ./bin/remote/compile -C #{Indocker.configuration_name} -i #{image.name} -s #{@logger.debug? ? '-d' : ''}"
+      result = build_server
+        .compile_image_remotely(
+          configuration_name: Indocker.configuration_name,
+          image_name:         image.name
         )
     end
 
-    Indocker::SshResultLogger
-      .new(@logger)
-      .log(result, "#{image.name.to_s.green} image compilation failed")
-
-    exit 1 if result.exit_code != 0
+    if result.exit_code != 0
+      exit 1
+    end
 
     @logger.info("Image compilation completed #{image.name.to_s.green}. Time taken: #{time}")
 
-    build_context.set_compiled(image)
+    @compiled_images[image] = true
   end
 
-  def recursively_deploy_container(configuration, deployer, build_context_pool, container, 
+  def recursively_deploy_container(configuration, deployer, build_server_pool, container,
     containers, skip_build, skip_deploy, force_restart, skip_force_restart)
 
     container.dependent_containers.each do |container|
       recursively_deploy_container(
-        configuration, 
-        deployer, 
-        build_context_pool, 
-        container, 
-        containers, 
-        skip_build, 
+        configuration,
+        deployer,
+        build_server_pool,
+        container,
+        containers,
+        skip_build,
         skip_deploy,
-        force_restart, 
+        force_restart,
         skip_force_restart
       )
     end
@@ -327,32 +324,25 @@ class Indocker::ConfigurationDeployer
     @progress.start_building_container(container)
 
     if !skip_build
-      build_context = build_context_pool.get
+      build_server = build_server_pool.get
 
-      build_context.set_busy(true)
-      compile_image(configuration, container.image, build_context)
-      build_context.set_busy(false)
+      build_server.set_busy(true)
+      compile_image(configuration, container.image, build_server)
+      build_server.set_busy(false)
     end
 
     @progress.finish_building_container(container)
 
     if !skip_deploy
-      deployer.deploy(container, force_restart, skip_force_restart, @progress)
+      deploy_container(deployer, container, force_restart, skip_force_restart)
     end
   end
 
-  class RemoteOperation
-    attr_reader :thread, :server, :operation, :message
-
-    def initialize(thread, server, operation, message = nil)
-      @thread = thread
-      @server = server
-      @operation = operation
-      @message = message
-    end
+  def deploy_container(deployer, container, force_restart, skip_force_restart)
+    deployer.deploy(container, force_restart, skip_force_restart, @progress)
   end
 
-  def pull_repositories(clonner, servers, repositories)
+  def pull_repositories(cloner, servers, repositories)
     @logger.info("Clonning/pulling repositories")
 
     remote_operations = []
@@ -381,10 +371,10 @@ class Indocker::ConfigurationDeployer
             )
           elsif repository.is_git?
             @logger.info("Pulling repository #{alias_name.to_s.green} for #{server.user}@#{server.host}")
-            result = clonner.clone(session, repository)
+            result = cloner.clone(session, repository)
 
             if result.exit_code != 0
-              @logger.error("Repository :#{repository.name} was not clonned")
+              @logger.error("Repository :#{repository.name} was not cloned")
               @logger.error(result.stderr_data)
               exit 1
             end
@@ -397,57 +387,20 @@ class Indocker::ConfigurationDeployer
           @progress.finish_syncing_repository(server, alias_name)
         end
 
-        RemoteOperation.new(thread, server, :repository_pull)
+        Indocker::Launchers::DTO::RemoteOperationDTO.new(thread, server, :repository_pull)
       end
     end
 
     remote_operations
   end
 
-  def sync_artifacts(clonner, artifact_servers)
-    @logger.info("Syncing git artifacts")
-
-    remote_operations = []
-
-    artifact_servers.each do |artifact, servers|
-      remote_operations += servers.map do |server|
-        @progress.start_syncing_artifact(server, artifact)
-
-        thread = Thread.new do
-          server.synchronize do
-            session = Indocker::SshSession.new(
-              host: server.host,
-              user: server.user,
-              port: server.port,
-              logger: @logger
-            )
-
-            @logger.info("Pulling git artifact  #{artifact.name.to_s.green} for #{server.user}@#{server.host}")
-            result = clonner.clone(session, artifact.repository)
-
-            if result.exit_code != 0
-              @logger.error("Artifact repository :#{artifact.repository.name} was not clonned")
-              @logger.error(result.stderr_data)
-              exit 1
-            end
-
-            source_path = File.join(artifact.repository.clone_path, artifact.source_path)
-            result = session.exec!("mkdir -p #{artifact.target_path}")
-            result = session.exec!("cp -r #{source_path} #{artifact.target_path}")
-
-            if !result.success?
-              @logger.error(result.stdout_data)
-              @logger.error(result.stderr_data)
-              exit 1
-            end
-
-            @progress.finish_syncing_artifact(server, artifact)
-          end
-        end
+  def sync_artifacts(cloner, artifact_servers)
+    artifacts_synchronizer = Indocker::Artifacts::Services::Synchronizer.new(
+      logger:   @logger,
+      progress: @progress,
+    )
 
-        RemoteOperation.new(thread, server, :artifact_sync)
-      end
-    end
+    remote_operations = artifacts_synchronizer.call(cloner, artifact_servers)
 
     remote_operations
   end
@@ -505,7 +458,7 @@ class Indocker::ConfigurationDeployer
         @progress.finish_syncing_binaries(server)
       end
 
-      RemoteOperation.new(thread, server, :indocker_sync)
+      Indocker::Launchers::DTO::RemoteOperationDTO.new(thread, server, :indocker_sync)
     end
   end
 
@@ -546,7 +499,7 @@ class Indocker::ConfigurationDeployer
           @progress.finish_syncing_env_file(server, alias_name)
         end
 
-        RemoteOperation.new(thread, server, :env_file_sync)
+        Indocker::Launchers::DTO::RemoteOperationDTO.new(thread, server, :env_file_sync)
       end
     end