Class: Cnvrg::CLI

Inherits:

Thor

Object
Thor
Cnvrg::CLI

show all

Defined in:: lib/cnvrg/cli.rb

Constant Summary collapse

INSTALLATION_URLS =

{docker: "https://docs.docker.com/engine/installation/", jupyter: "http://jupyter.readthedocs.io/en/latest/install.html"}

IP =

"localhost"

PORT =

Class Method Summary collapse

.is_thor_reserved_word?(word, type) ⇒ Boolean

Hackery.Take the run method away from Thor so that we can redefine it.

Instance Method Summary collapse

Class Method Details

.is_thor_reserved_word?(word, type) ⇒ `Boolean`

Hackery.Take the run method away from Thor so that we can redefine it.

Returns:

(Boolean)

# File 'lib/cnvrg/cli.rb', line 153

def is_thor_reserved_word?(word, type)
  return false if word == "run"
  super
end

Instance Method Details

#build(*cmd) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3966

def build(*cmd)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    working_dir = is_cnvrg_dir
    install_file = options["install"] || nil
    if !install_file.nil?
      commands = File.open(install_file).read.chop.gsub!("\n", ",").split(",")

    else
      commands = [cmd.join(" ")]
    end


    image = is_project_with_docker(working_dir)
    if image and image.is_docker
      container = image.get_container
      if !container

        say "Couldn't create container with image #{image.image_name}:#{image.image_tag}", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Project is not configured with any image", Thor::Shell::Color::RED
      exit(1)

    end
    commands.each do |c|
      if c.include? "pip"
        c.sub("pip", "/opt/ds/bin/pip")
      end
      if c.include? "pip3"
        c.sub("pip3", "/opt/ds3/bin/pip3")
      end

      say "Running #{c}", Thor::Shell::Color::BLUE
      command = ["/bin/bash", "-lc", "#{c}"]
      res = container.exec(command, tty: false)
      if res[2] != 0
        say "Could not run command: #{c}, #{res[1][0]}", Thor::Shell::Color::RED
        container.stop()
        log_end(0)

        exit(1)
      end
      say res[0].join("\n")
      image.store_image_build_commands(working_dir, c)
    end

    checks = Helpers.checkmark()
    say "Updating image", Thor::Shell::Color::BLUE
    # image.create_custom_image("",working_dir)
    container.stop()
    say "#{checks} Done", Thor::Shell::Color::GREEN

    log_end(0)
  rescue => e
    log_end(-1, e.message)
    say "Error occurred, aborting", Thor::Shell::Color::RED
    if container
      container.stop()
    end
  rescue SignalException
    log_End(-1)
    if container
      container.stop()
    end
    say "\nAborting"
    exit(1)
  end

end

#build_image(image_name) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3839

def build_image(image_name)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    instances = {"small" => options["small"], "medium" => options["medium"], "large" => options["large"],
                 "gpu" => options["gpu"], "gpuxl" => options["gpuxl"], "gpuxxl" => options["gpuxxl"]}
    instance_type = get_instance_type(instances)
    image_extend = options["image"]
    public = options["public"]
    base = options["base"]
    python3 = options["python3"]
    docker_path = options["docker_path"]
    owner = CLI.get_owner
    checks = Helpers.checkmark()
    tar_path = nil
    if !docker_path.nil? and !docker_path.empty?
      docker_path = File.absolute_path(docker_path)
      #create tar of the docker path: it could be a docker file, and it could be a docker folder
      tar_path = File.expand_path('~')+"/.cnvrg/tmp/docker_#{File.basename docker_path}.tar.gz"
      resp = create_docker_tar(docker_path, tar_path)
      if !resp
        log_message("Couldn't create tar from docker path", Thor::Shell::Color::RED)
        FileUtils.rm_rf tar_path
        exit(1)
      end
      files = Cnvrg::Files.new(owner, "")
      resp = Images.create_new_custom_image_with_docker(instance_type, owner, image_name, public, base, image_extend, python3, tar_path, files)
      if resp
      end
    else
      log_message("Creating machine for your custom image, this may take a few moments...", Thor::Shell::Color::BLUE)
      resp = Images.create_new_custom_image(instance_type, owner, image_name, public, base, image_extend, python3, nil)

    end

    if Cnvrg::CLI.is_response_success(resp, false)
      image_slug = resp["result"]["slug"]
      container = resp["result"]["machine_c"]
      log_message("#{checks} Created image and machine successfully", Thor::Shell::Color::GREEN)
      log_message("Connecting to machine", Thor::Shell::Color::BLUE)
      ssh = Ssh.new(resp)
      if !ssh.is_ssh
        log_message("Couldn't connect to machine,aborting", Thor::Shell::Color::RED)
        Images.revoke_custom_new_image(owner, image_slug)
      end
      log_message("run command until ctrl + c or quit is initiated", Thor::Shell::Color::BLUE)
      begin
        logs = []

        while true
          command = ask("$>")
          logs << {time: Time.now,
                   message: command,
                   type: "stdout"
          }
          if command.eql? "quit"
            log_message("Commiting Image..", Thor::Shell::Color::BLUE)
            break
          end
          res = ssh.exec_command(command)
          begin
            res_parsed = JSON.parse(res)
            res = res_parsed.join(",")
          end

          puts res
          logs << {time: Time.now,
                   message: res,
                   type: "stdout"
          }
          logs.flatten!

        end

      rescue SignalException
        log_message("Commiting Image..", Thor::Shell::Color::BLUE)

      end
      resp = Images.commit_custom_image(owner, image_slug, logs)
      if Cnvrg::CLI.is_response_success(resp, false)
        log_message("#{checks} Image commited successfuly, email will be sent when image is ready", Thor::Shell::Color::GREEN)
      else
        if image_slug
          Images.revoke_custom_new_image(owner, image_slug)
        end
        if ssh
          ssh.close_ssh()
        end
        log_message("Image couldn't be commited, rolling back changes", Thor::Shell::Color::RED)

        exit(1)
      end
      if ssh
        ssh.close_ssh()
      end


    end
  rescue => e
    log_message("Error occurd, aborting", Thor::Shell::Color::RED)

    log_error(e)
    if image_slug
      Images.revoke_custom_new_image(owner, image_slug)
    end
    if ssh
      ssh.close_ssh()
    end


  rescue SignalException
    if image_slug
      Images.revoke_custom_new_image(owner, image_slug)
    end
    if ssh
      ssh.close_ssh
    end
    say "\nAborting"
    exit(1)
  end

end

#clone(project_url) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1468

def clone(project_url)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    url_parts = project_url.split("/")
    project_index = Cnvrg::Helpers.look_for_in_path(project_url, "projects")
    slug = url_parts[project_index+1]
    owner = url_parts[project_index-1]
    remote = options["remote"] || false
    response = Cnvrg::API.request("users/#{owner}/projects/#{slug}/get_project", 'GET')
    Cnvrg::CLI.is_response_success(response)
    response = JSON.parse response["result"]
    project_name = response["title"]
    commit_to_clone = options["commit"] || nil

    log_message("Cloning #{project_name}", Thor::Shell::Color::BLUE)
    clone_resp = false
    if remote
      clone_resp = Project.clone_dir_remote(slug, owner, project_name)
      project_home = Dir.pwd
    else
      if (Dir.exists? project_name)
        log_message("Error: Conflict with dir #{project_name}", Thor::Shell::Color::RED)
        if no? "Sync to repository anyway? (current data might lost)", Thor::Shell::Color::YELLOW
          log_message("Remove dir in order to clone #{project_name}", Thor::Shell::Color::RED)
          exit(1)
        end

      end
      clone_resp = Project.clone_dir(slug, owner, project_name)
      project_home = Dir.pwd+"/"+project_name


    end

    if clone_resp
      @project = Project.new(project_home)
      @files = Cnvrg::Files.new(@project.owner, slug)
      response = @project.clone(remote, commit_to_clone)
      Cnvrg::CLI.is_response_success response
      working_dir = project_home
      docker_image = response["result"]["image"]
      current_commit = response["result"]["commit"]
      idx = {commit: response["result"]["commit"], tree: response["result"]["tree"]}
      File.open(working_dir + "/.cnvrg/idx.yml", "w+") { |f| f.write idx.to_yaml }
      if !docker_image.nil? and !docker_image.empty? and !remote
        local_images = Docker::Image.all
        docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.eql? "#{docker_image}:latest" }.flatten
        if docker_image_local.size == 0
          if yes? "Image wasn't found locally, pull image from cnvrg repository?", Thor::Shell::Color::YELLOW
            image = pull(docker_image)
            if image
              log_message("downloaded image: #{docker_image}", Thor::Shell::Color::BLUE)
              @image = Images.new(working_dir, docker_image)
            else
              log_message("Could not create a new project with docker, image was not found", Thor::Shell::Color::RED)
              @project.revert(working_dir)
              exit(1)
            end
          end

        elsif docker_image_local.size == 1
          log_message("found image: #{docker_image_local[0]}, setting it up..", Thor::Shell::Color::BLUE)
          @image = Images.new(working_dir, docker_image_local[0])
        elsif docker_image_local.size >1
          log_message("found #{docker_image_local.size} images, choose the image name you want to use", Thor::Shell::Color::BLUE)
          image_name = ask "#{docker_image_local.join("\n")}\n", Thor::Shell::Color::BLUE
          @image = Images.new(working_dir, image_name)
        end

      end

      successful_changes = []
      log_message("Downloading files", Thor::Shell::Color::BLUE)
      if !response["result"]["tree"].nil?
        parallel_options = {
            :progress => {
                :title => "Download Progress",
                :progress_mark => '=',
                :format => "%b>>%i| %p%% %t",
                :starting_at => 0,
                :total => response["result"]["tree"].size,
                :autofinish => true
            },
            in_processes: ParallelProcesses,
            in_thread: ParallelThreads
        }
        begin
          is_success = true
          clone_result = Parallel.map((response["result"]["tree"]), parallel_options) do |f|

            relative_path = f[0].gsub(/^#{@project.local_path}/, "")
            if f[0].end_with? "/"
              # dir
              if @files.download_dir(f[0], relative_path, project_home)
                f
                successful_changes << relative_path
              else
                is_success =false
                log_message("Could not create directory: #{f[0]}", Thor::Shell::Color::RED)
                raise Parallel::Kill
              end
            else
              # blob

              if @files.download_file_s3(f[0], relative_path, project_home, commit_sha1=current_commit)
                f
                successful_changes << relative_path
              else
                is_success =false
                log_message("Could not download file: #{f[0]}", Thor::Shell::Color::RED)
                raise Parallel::Kill

              end
            end
          end
        rescue Interrupt
          is_success =false
          log_message("Couldn't download, Rolling Back all changes.", Thor::Shell::Color::RED)

          @files.revoke_download([], response["result"]["tree"])
          exit(1)
        end


      end
      successful_changes = response["result"]["tree"]
      if !successful_changes.nil? and is_success
        Project.verify_cnvrgignore_exist(project_name,remote)
        log_message("Done.\nDownloaded  #{successful_changes.size}/#{response["result"]["tree"].size} files", Thor::Shell::Color::GREEN)
      else
        log_message("Couldn't download some files", Thor::Shell::Color::RED)

      end

    else

      log_message("Error: Couldn't create directory: #{project_name}", Thor::Shell::Color::RED)
      exit(1)
    end
  rescue SignalException
    say "\nAborting"
    exit(1)
  end

end

#clone_data(dataset_url) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 800

def clone_data(dataset_url)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    url_parts = dataset_url.split("/")
    project_index = Cnvrg::Helpers.look_for_in_path(dataset_url, "datasets")
    slug = url_parts[project_index+1]
    owner = url_parts[project_index-1]
    response = Cnvrg::API.request("users/#{owner}/datasets/#{slug}/clone", 'GET')

    Cnvrg::CLI.is_response_success(response)
    dataset_name = response["result"]["name"]

    if (Dir.exists? dataset_name)
      log_messgae("Error: Conflict with dir #{dataset_name}", Thor::Shell::Color::RED)
      if no? "Sync to repository anyway? (current data might lost)", Thor::Shell::Color::YELLOW
        log_message("Remove dir in order to clone #{dataset_name}", Thor::Shell::Color::RED)
        exit(1)
      end

    end
    if Dataset.clone(owner, dataset_name, slug)
      log_message("Cloning #{dataset_name}", Thor::Shell::Color::BLUE)

      commit_to_clone = options["commit"] || nil
      working_dir = "#{Dir.pwd}/#{dataset_name}"
      @dataset = Dataset.new(working_dir)
      @dataset.generate_idx()


      download_res = download_data(false, false, path = working_dir, in_dir=false)
      if !download_res
        exit(1)
      end


      check = Helpers.checkmark
      log_message("#{check} Clone finished successfully", Thor::Shell::Color::GREEN)

    else
      @dataset.revert(working_dir) unless @dataset.nil?
      log_message("Error creating dataset, please contact support.", Thor::Shell::Color::RED)
      exit(0)
    end
  rescue => e
    log_error(e)
  rescue SignalException

    say "\nAborting"
    exit(1)
  end
end

#commit_image ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4041

def commit_image
  verify_logged_in(true)
  log_start(__method__, args, options)

  begin
    image = is_project_with_docker(Dir.pwd)
    if image and image.is_docker
      container= image.get_container
      if !container

        say "Couldn't create container with image #{image.image_name}:#{image.image_tag}", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Project is not configured with any image", Thor::Shell::Color::RED
      exit(1)

    end
    project_home = get_project_home
    @project = Project.new(project_home)
    last_local_commit = @project.last_local_commit
    say "Commiting container into image", Thor::Shell::Color::BLUE
    new_image_name = "#{@project.slug}#{last_local_commit}:latest"
    image.update_image(new_image_name, container)
    new_image = container.commit('repo' => "#{@project.slug}#{last_local_commit}", 'tag' => "lastest")
    checks = Helpers.checkmark()
    say "#{checks} Done, image was updated", Thor::Shell::Color::GREEN
    log_end(0)
    return new_image.id
  rescue => e
    log_end(-1, e.message)
    say "\nError occurred, aborting"
    exit(1)
  rescue SignalException
    log_end(-1)
    say "\nAborting"
    exit(1)
  end
end

#config_flask_remote(image_name, port = 80) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4412

def config_flask_remote(image_name, port=80)
  local_images = Docker::Image.all

  docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.eql? "#{image_name}:latest" }.flatten
  if docker_image_local.empty?
    say "no image"
    exit(1)
  end

  begin
    login_content = options["login"]
    image_settings = {
        'Image' => "#{image_name}:latest",
        'User' => 'ds',
        'Cmd' => '/usr/local/cnvrg/start_super.sh',
        'WorkingDir' => '/home/ds/app',
        'ExposedPorts' => {
            '80/tcp' => {},
        },
        'HostConfig' => {
            'PortBindings' => {
                '80/tcp' => [
                    {'HostPort' => "#{port}", 'HostIp' => 'localhost'}
                ],
            },
        },
    }
    container = Docker::Container.create(image_settings)
    container.start()
    command = ["/bin/bash", "-lc", "sudo echo -e \"#{login_content}\" >/home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chown -R ds:ds /home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chmod 0600 /home/ds/.netrc"]
    container.exec(command, tty: true)
    say "#{container.id}:#{port}"
  rescue => e
    pus e
    if e.message.include? "is not running"
      return "port is taken"
    end
    puts "error"
    if container
      container.kill()
    end
    return false
  end
end

#config_flask_remote_gpu(image_name, port = 80) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4464

def config_flask_remote_gpu(image_name, port=80)
  local_images = Docker::Image.all

  docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.eql? "#{image_name}:latest" }.flatten
  if docker_image_local.empty?
    say "no image"
    exit(1)
  end

  begin
    login_content = options["login"]
    container_id = `nvidia-docker run -itd -p 80:80 -w /home/ds/app #{image_name}:latest /usr/local/cnvrg/start_super.sh`
    container_id = container_id.gsub("\n", "")
    container = Docker::Container.get(container_id)
    command = ["/bin/bash", "-lc", "sudo echo -e \"#{login_content}\" >/home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chown -R ds:ds /home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chmod 0600 /home/ds/.netrc"]
    container.exec(command, tty: true)
    say "#{container.id}:#{port}"
  rescue => e
    puts e
    if e.message.include? "is not running"
      return "port is taken"
    end
    puts "error"
    if container
      container.kill()
    end
    return false
  end
end

#config_netrc(container) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4330

def config_netrc(container)

  login_content = options["login"]

  container = Docker::Container.get(container)
  command = ["/bin/bash", "-lc", "sudo echo -e \"#{login_content}\" >/home/ds/.netrc"]
  container.exec(command, tty: true)
  command = ["/bin/bash", "-lc", "sudo chown -R ds:ds /home/ds/.netrc"]
  container.exec(command, tty: true)
  command = ["/bin/bash", "-lc", "sudo chmod 0600 /home/ds/.netrc"]
  container.exec(command, tty: true)
  say "OK"

end

#config_remote(image_name, port = 7654, tensport = 6006) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4265

def config_remote(image_name, port=7654, tensport=6006)
  local_images = Docker::Image.all

  docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.eql? "#{image_name}:latest" }.flatten
  if docker_image_local.empty?
    say "no image"
    exit(1)
  end

  begin
    login_content = options["login"]
    app_dir = options["app_dir"]
    cmd= options["cmd"]
    volume_from = options["volume"]

    image_settings = {
        'Image' => "#{image_name}:latest",

        'Cmd' => cmd,
        'WorkingDir' => app_dir,
        'ExposedPorts' => {
            '8888/tcp' => {},
        },
        'HostConfig' => {
            'Binds' => ["/var/run/docker.sock:/var/run/docker.sock", "/usr/bin/docker:/usr/bin/docker"],
            'PortBindings' => {
                '8888/tcp' => [
                    {'HostPort' => "#{port}", 'HostIp' => 'localhost'}
                ],
                '6006/tcp' => [
                    {'HostPort' => "#{tensport}", 'HostIp' => 'localhost'}
                ],
            },
        },
    }
    container = Docker::Container.create(image_settings)
    container.start()
    command = ["/bin/bash", "-lc", "sudo echo -e \"#{login_content}\" >/home/ds/.netrc"]
    container.exec(command, tty: true)
    # command = ["/bin/bash", "-lc", "mkdir /home/ds/.cnvrg"]
    # container.exec(command, tty: true)
    # command = ["/bin/bash", "-lc", "mkdir /home/ds/.cnvrg/tmp"]
    # container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chown -R ds:ds /home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chmod 0600 /home/ds/.netrc"]
    container.exec(command, tty: true)
    say "#{container.id}:#{port}##{tensport}"
  rescue => e
    puts e
    if e.message.include? "is not running"
      return config_remote(image_name, port-1, tensport-1)
    end

    if container
      container.kill()
    end
    return false
  end
end

#config_remote_gpu(image_name, port = 7654, tensport = 6006) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4351

def config_remote_gpu(image_name, port=7654, tensport=6006)
  local_images = Docker::Image.all

  docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.eql? "#{image_name}:latest" }.flatten
  if docker_image_local.empty?
    say "no image"
    exit(1)
  end

  begin
    login_content = options["login"]
    app_dir = options["app_dir"]
    cmd= options["cmd"]

    # image_settings = {
    #     'Image' => "#{image_name}:latest",
    #     'User' => 'ds',
    #     'Cmd' => cmd,
    #     'WorkingDir' => app_dir,
    #     'ExposedPorts' => {
    #         '8888/tcp' => {},
    #     },
    #     'HostConfig' => {
    #         'PortBindings' => {
    #             '8888/tcp' => [
    #                 {'HostPort' => "#{port}", 'HostIp' => 'localhost'}
    #             ],
    #             '6006/tcp' => [
    #                 {'HostPort' => "6006", 'HostIp' => 'localhost'}
    #             ],
    #         },
    #     },
    # }

    container_id = `nvidia-docker run -itd -p #{port}:8888 -p #{tensport}:6006 -w #{app_dir} -v /usr/bin/nvidia-smi:/usr/bin/nvidia-smi  -v /var/run/docker.sock:/var/run/docker.sock -v /usr/bin/docker:/usr/bin/docker #{image_name}:latest #{cmd} `
    container_id = container_id.gsub("\n", "")
    container = Docker::Container.get(container_id)
    # container.start()
    command = ["/bin/bash", "-lc", "sudo echo -e \"#{login_content}\" >/home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chown -R ds:ds /home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chmod 0600 /home/ds/.netrc"]
    container.exec(command, tty: true)
    say "#{container.id}:#{port}##{tensport}"
  rescue => e
    if e.message.include? "is not running"
      puts "running asgain with: #{port-1} #{tensport-1}"
      return config_remote_gpu(image_name, port-1, tensport-1)
    end

    if container
      container.kill()
    end
    return false
  end
end

#create_volume ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1396

def create_volume
  verify_logged_in(false)
  log_start(__method__, args, options)
  dataset_dir = is_cnvrg_dir(Dir.pwd)
  @dataset = Dataset.new(dataset_dir)
  @dataset.create_volume()

end

#data_init_container(owner, dataset_slug, dataset_name) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 903

def data_init_container(owner, dataset_slug, dataset_name)

  if Dataset.init_container(owner, dataset_slug, dataset_name)

    say "init finished successfully", Thor::Shell::Color::GREEN

  else
    say "error creating dataset, please contact support.", Thor::Shell::Color::RED
    exit(0)
  end
end

#data_jump(*commit_sha1) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2275

def data_jump(*commit_sha1)
  begin
    verify_logged_in()
    log_start(__method__, args, options)
    dataset_dir = is_cnvrg_dir(Dir.pwd)
    @dataset = Dataset.new(dataset_dir)

    @files = Cnvrg::Datafiles.new(@dataset.owner, @dataset.slug)
    if commit_sha1.nil? or commit_sha1.empty?
      commit_sha1 = @dataset.last_local_commit
    end
    response = @dataset.compare_commits(commit_sha1)
    successful_changes = []
    if !response["result"]["status"].nil?
      idx = {commit: response["result"]["commit"], tree: response["result"]["tree"]}
      File.open(dataset_dir + "/.cnvrg/idx.yml", "w+") { |f| f.write idx.to_yaml }
      status = response["result"]["status"]
      (status["delete"]).each do |f|
        relative_path = f[0].gsub(/^#{@dataset.local_path}/, "")
        FileUtils.rm_rf(relative_path)
      end
      # current_tree = Dir.entries(".").reject { |file| file.start_with? '.' }
      (status["dirs"]).each do |f|
        relative_path = f[0].gsub(/^#{@dataset.local_path}/, "")
        # dir
        if @files.download_dir(dataset_dir, relative_path)
          # current_tree.delete(relative_path[0, relative_path.size-1])
          successful_changes << relative_path
        end
      end
      (status["download"]).each do |f|
        relative_path = f["name"].gsub(/^#{@dataset.local_path}/, "")
        # dir
        if @files.download_file_s3(f["name"], relative_path, dataset_dir, f["sha1"])
          successful_changes << relative_path
        end
      end


      log_message("Done. Jumped to #{commit_sha1} completed successfully", Thor::Shell::Color::GREEN)
    end
  rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)

  rescue SignalException
    exit(1)
  end
end

#deploy(file_to_run, function) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3084

def deploy(file_to_run, function)
  verify_logged_in(true)
  log_start(__method__, args, options)
  working_dir = is_cnvrg_dir
  begin
    instances = {"small" => options["small"], "medium" => options["medium"], "large" => options["large"],
                 "gpu" => options["gpu"], "gpuxl" => options["gpuxl"], "gpuxxl" => options["gpuxxl"]}
    instance_type = get_instance_type(instances)

    schedule = options["schedule"] || ""


    if !schedule.nil? and !schedule.empty?

      local_timestamp = get_schedule_date

    end
    project = Project.new(working_dir)
    commit_to_run = options["commit"] || nil

    workers = options["workers"] || nil
    begin
      num_workers = workers.to_i
    rescue
      log_message("Number of workers should be a number between 1 to 10", Thor::Shell::Color::RED)
      exit(1)
    end
    file_as_input = options["file_as_input"] || false


    image = is_project_with_docker(working_dir)
    if !image or !image.is_docker
      # say "Couldn't find image related to project", Thor::Shell::Color::RED
      # default = yes? "use cnvrg default image?", Thor::Shell::Color::YELLOW
      # if default
      image = Images.new(working_dir, "cnvrg")
      image_slug = image.image_slug
      # else
      #   exit(0)
      # end
    else
      image_slug = image.image_slug
    end


    invoke :sync, [false], []

    res = project.deploy(file_to_run, function, nil, commit_to_run, instance_type, image_slug, schedule, local_timestamp, num_workers, file_as_input)

    if Cnvrg::CLI.is_response_success(res)

      # if res["result"]["machine"] == -1
      #   say "There are no available machines", Thor::Shell::Color::BLUE
      #   create = yes? "create new machine?", Thor::Shell::Color::YELLOW
      #   if create
      #     res = Cnvrg::API.request("users/#{image.owner}/machines/list", 'GET')
      #     if Cnvrg::CLI.is_response_success(res)
      #       instance_type = machine_options(res["result"]["aws_options"])
      #       if @image.new_machine(instance_type)
      #         say "Running remote experiment", Thor::Shell::Color::BLUE
      #
      #         # res = image.exec_remote(exec_args, exec_options, project.last_local_commit)
      #         # if Cnvrg::CLI.is_response_success(res)
      #
      #           check = Helpers.checkmark()
      #           say "#{check} Finished successfuly", Thor::Shell::Color::GREEN
      #           exit(0)
      #         # end
      #       end
      #     else
      #       say "No machines are avilable", Thor::Shell::Color::RED
      #       exit(0)
      #     end
      #
      #
      #   else
      #     say "Can't execute command on remote machine with local image", Thor::Shell::Color::RED
      #     exit(1)
      #
      #   end
      # else
      check = Helpers.checkmark()
      log_message("#{check} Deployment process is on: #{Cnvrg::Helpers.remote_url}/#{project.owner}/projects/#{project.slug}/deploys/show/#{res["result"]["deploy_slug"]}", Thor::Shell::Color::GREEN)

      exit(0)
      # end
    end
  rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)


  rescue SignalException
    exit_status = -1
    end_commit = project.last_local_commit

    res = @exp.end(log, exit_status, end_commit, "", "")
    say "\nAborting"

    exit(1)
  end
end

#download(sync = false, ignore_list = "") ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1992

def download(sync=false, ignore_list="")
  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    project_home = get_project_home
    @project = Project.new(project_home)
    @files = Cnvrg::Files.new(@project.owner, @project.slug)
    ignore = options[:ignore] || ""
    if ignore.nil? or ignore.empty?
      ignore = ignore_list
    end
    data_ignore = data_dir_include()
    if !data_ignore.nil?
      if ignore.nil? or ignore.empty?
        ignore = data_ignore
      else
        ignore ="#{ignore},#{data_ignore}"
      end
    end
    if !@project.update_ignore_list(ignore)
      log_message("Couldn't append new ignore files to .cnvrgignore", Thor::Shell::Color::YELLOW)
    end
    new_branch = options["new_branch"] || false
    res = @project.compare_idx(new_branch)["result"]

    result = res["tree"]

    commit = res["commit"]
    if result["updated_on_server"].empty? and result["conflicts"].empty? and result["deleted"].empty?
      log_message("Project is up to date", Thor::Shell::Color::GREEN, ((options["sync"] or sync) ? false : true))
      return true
    end
    # if result["added"].any? {|x| x.include? ".conflict"} or !result["conflicts"].empty?
    #   all = result["added"].select {|x| x.include? ".conflict"} +result["conflicts"].flatten
    #   if all.size == 1
    #     num = "1 conflict"
    #   else
    #     num =  "#{result["conflicts"].size} conflicts"
    #   end
    #   say "Project contains #{num}:", Thor::Shell::Color::RED
    #   say "#{all.join("\n")}"
    #   say "Please fix them, and retry", Thor::Shell::Color::RED
    #   exit(1)
    #   end
    update_count = 0
    update_total = result["updated_on_server"].size + result["conflicts"].size + result["deleted"].size


    successful_changes = []
    if update_total ==1
      log_message("Downloading #{update_total} file", Thor::Shell::Color::BLUE, !options["sync"])
    elsif update_total == 0
      log_message("Project is up to date", Thor::Shell::Color::GREEN, !options["sync"])
      return true
    elsif options["verbose"]
      log_message("Downloading #{update_total} files", Thor::Shell::Color::BLUE)
    else
      log_message("Syncing files", Thor::Shell::Color::BLUE, !options["sync"])

    end
    parallel_options = {
        :progress => {
            :title => "Download Progress",
            :progress_mark => '=',
            :format => "%b>>%i| %p%% %t",
            :starting_at => 0,
            :total => result["updated_on_server"].size,
            :autofinish => true
        },
        in_processes: ParallelProcesses,
        in_thread: ParallelThreads
    }
    if !result["conflicts"].empty?
      begin


        conflicts_result = Parallel.map(result["conflicts"], in_processes: ParallelProcesses, in_thread: ParallelThreads) do |f|

          relative_path = f.gsub(/^#{@project.local_path}/, "")
          log_message("downloading: #{f}.conflict", Thor::Shell::Color::BLUE, options["verbose"])

          if @files.download_file_s3(f, relative_path, project_home, commit_sha1=nil, conflict=true)
            f
          else
            log_message("Couldn't download: #{f}", Thor::Shell::Color::RED)
            raise Parallel::Kill

          end
        end
      rescue Interrupt

        log_message("Couldn't download, Rolling Back all changes.", Thor::Shell::Color::RED)

        @files.revoke_download(result["conflicts"], [])
        exit(1)
      end
    end


    successful_changes += conflicts_result.to_a
    if !result["updated_on_server"].empty?
      begin
        updated_on_server_result = Parallel.map(result["updated_on_server"], parallel_options) do |f|

          relative_path = f.gsub(/^#{@project.local_path}/, "")
          if f.end_with? "/"
            # dir
            log_message("downloading dir: #{f}", Thor::Shell::Color::BLUE, options["verbose"])

            if @files.download_dir(f, relative_path, project_home)
              f
            else
              log_message("Couldn't create directory: #{f}", Thor::Shell::Color::RED)
              raise Parallel::Kill


            end

          else
            # blob
            log_message("downloading file: #{f}", Thor::Shell::Color::BLUE, options["verbose"])

            if @files.download_file_s3(f, relative_path, project_home)
              f
            else


              log_message("Couldn't download: #{f}", Thor::Shell::Color::RED)
              raise Parallel::Kill


            end
          end


        end
        successful_changes += updated_on_server_result.to_a
      rescue Interrupt
        log_message("Couldn't download, Rolling Back all changes.", Thor::Shell::Color::RED)

        @files.revoke_download(result["conflicts"], result["updated_on_server"])
        exit(1)

      end
    end

    deleted = result["deleted"].to_a
    delete_res = @files.delete_commit_files_local(deleted)
    if !delete_res
      log_message("Couldn't delete #{deleted.join(" ")}", Thor::Shell::Color::RED)
      log_message("Couldn't download, Rolling Back all changes.", Thor::Shell::Color::RED)

      @files.revoke_download(result["conflicts"], result["updated_on_server"])
      exit(1)

    end
    successful_changes += deleted


    successful_changes = successful_changes.select { |x| not x.nil? }

    if update_total == successful_changes.size
      # update idx with latest commit
      @project.update_idx_with_commit!(commit)
      check = Helpers.checkmark()

      if options["verbose"]
        log_message("#{check} Done, Downloaded:", Thor::Shell::Color::GREEN)
        log_message(successful_changes.join("\n"), Thor::Shell::Color::GREEN)
        log_message("Total of #{successful_changes.size} / #{update_total} files.", Thor::Shell::Color::GREEN)
      else
        log_message("#{check} Downloaded changes successfully", Thor::Shell::Color::GREEN, ((sync or options["sync"]) ? false : true))
      end


    end
  rescue => e

    log_message("Error occurred, \nAborting", Thor::Shell::Color::BLUE)
    log_error(e)
    if successful_changes.nil?
      exit(1)
    end
    begin
      @files.revoke_download(result["conflicts"], result["updated_on_server"])
    end
    exit(1)
  rescue SignalException
    say "\nAborting", Thor::Shell::Color::BLUE
    if successful_changes.nil?
      exit(1)
    end
    begin
      @files.revoke_download(result["conflicts"], result["updated_on_server"])
    end
    exit(1)
  end
end

#download_built_image(image_name, image_slug) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4525

def download_built_image(image_name, image_slug)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    owner = Cnvrg::CLI.get_owner()
    path = File.expand_path('~')+"/.cnvrg/tmp/#{image_name}.tar.gz"
    @files = Cnvrg::Files.new(owner, "")

    log_message("Downloading image file", Thor::Shell::Color::BLUE)
    begin
      if @files.download_image(path, image_slug, owner)
        gzipRes = system("gunzip -f #{path}")
        if !gzipRes

          log_message("Couldn't create tar file from image", Thor::Shell::Color::RED)
          exit(1)
        else
          path = path.gsub(".gz", "")
          return path
        end

      else
        log_message("Couldn't download image #{image_name}", Thor::Shell::Color::RED)
        return false
      end
    rescue Interrupt
      say "The user has exited to process, aborting", Thor::Shell::Color::BLUE
      exit(1)
    end
  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#download_cnvrg_image(image_name, secret) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4609

def download_cnvrg_image(image_name, secret)
  verify_logged_in(false)

  begin
    @files = Cnvrg::Files.new("", "")

    say "Downloading image file", Thor::Shell::Color::BLUE
    begin
      if @files.download_cnvrg_image(image_name, secret)

        say "Successfully downloaded image #{image_name}", Thor::Shell::Color::GREEN

      else
        say "Couldn't download image #{image_name}", Thor::Shell::Color::RED
        return false
      end
    rescue Interrupt
      say "The user has exited to process, aborting", Thor::Shell::Color::BLUE
      exit(1)
    end
  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#download_data(verbose, sync, path = Dir.pwd, in_dir = true) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 919

def download_data(verbose, sync, path=Dir.pwd, in_dir=true)
  begin
    verify_logged_in(in_dir)
    log_start(__method__, args, options)
    if path.nil? or path.empty?
      path = Dir.pwd
    end
    dataset_dir = is_cnvrg_dir(path)
    @dataset = Dataset.new(dataset_dir)

    @files = Cnvrg::Datafiles.new(@dataset.owner, @dataset.slug)
    new_branch = options["new_branch"] || false

    res = @dataset.compare_idx(new_branch)["result"]

    result = res["tree"]

    commit = res["commit"]
    if result["updated_on_server"].empty? and result["conflicts"].empty? and result["deleted"].empty?
      log_message("Project is up to date", Thor::Shell::Color::GREEN, ((options["sync"] or sync)) ? false : true)
      return true
    end
    log_message("Downloading data", Thor::Shell::Color::BLUE)

    result = @dataset.downlowd_updated_data(@dataset.last_local_commit)

    delete = result["result"]["delete"]
    commits = result["result"]["commits"]
    updated_idx = result["result"]["idx"]
    parallel_options = {
        :progress => {
            :title => "Download Progress",
            :progress_mark => '=',
            :format => "%b>>%i| %p%% %t",
            :starting_at => 0,
            :total => commits.size,
            :autofinish => true
        },
        in_processes: ParallelProcesses,
        in_thread: ParallelThreads
    }

    begin
      tar_files = []
      download_result = Parallel.map(commits, parallel_options) do |c|

        file_name = @files.download_data_file(c, dataset_dir)

        if file_name.eql? false or file_name.nil?
          count = 0
          success_download = false
          while count < 3 and !success_download
            log_message("Couldn't download data files, retrying.. ", Thor::Shell::Color::BLUE)

            file_name = @files.download_data_file(c, dataset_dir)
            success_download = (file_name.eql? false or file_name.nil?)
            count +=1

          end
          if count > 3 or !success_download
            log_message("Couldn't download data files,revoking", Thor::Shell::Color::RED)

            raise Parallel::Kill
          end
        end
        file_path = "#{dataset_dir}/#{file_name}"
        tar_files << file_path
        success = extarct_tar(file_path, dataset_dir)
        if !success
          log_message("Couldn't extract data files,revoking", Thor::Shell::Color::RED)

          raise Parallel::Kill
        end

        FileUtils.rm_rf([file_path])

      end
    rescue Interrupt
      @files.revoke_download(tar_files, updated_idx[:tree].keys)
      return false
    end


    to_delete = []
    delete.each do |d|
      to_delete << "#{dataset_dir}/#{d}"
    end
    FileUtils.rm_rf(to_delete)

    @dataset.update_idx(updated_idx)


    check = Helpers.checkmark()
    log_message("#{check} Downloaded changes successfully", Thor::Shell::Color::GREEN)
    return true


  end
rescue => e
  log_message("Error occurd, \nAborting", Thor::Shell::Color::BLUE)
  log_error(e)
  @files.revoke_download(tar_files, updated_idx[:tree].keys)

  exit(1)
rescue SignalException
  say "\nAborting", Thor::Shell::Color::BLUE
  exit(1)
end

#download_image(image_name, image_slug) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4562

def download_image(image_name, image_slug)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    owner = Cnvrg::CLI.get_owner()
    path = File.expand_path('~')+"/.cnvrg/tmp/#{image_name}.zip"
    @files = Cnvrg::Files.new(owner, "")

    say "Downloading image file", Thor::Shell::Color::BLUE
    begin
      if @files.download_image(path, image_slug, owner)

        dir_path = File.expand_path('~')+"/.cnvrg/tmp/#{image_name}"
        FileUtils.rm_rf([dir_path])

        Zip::File.open(path) do |zip_file|
          zip_file.each do |entry|

            f_path=File.join(dir_path, entry.name)
            FileUtils.mkdir_p(File.dirname(f_path))
            zip_file.extract(entry, f_path)
          end
        end

        return dir_path

      else
        say "Couldn't download image #{image_name}", Thor::Shell::Color::RED
        log_end(1, "can't download image")
        return false
      end
    rescue Interrupt
      log_end(-1)
      say "The user has exited to process, aborting", Thor::Shell::Color::BLUE
      exit(1)
    end
  rescue SignalException
    log_end(-1)
    say "\nAborting"
    exit(1)
  ensure
    if !path.nil?
      FileUtils.rm(path)
    end
  end
end

#exec(*cmd) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2443

def exec(*cmd)

  log = []
  cpu_average =0
  memory_average = 0
  verify_logged_in(true)
  log_start(__method__, args, options)
  working_dir = is_cnvrg_dir
  script_path = get_cmd_path_in_dir(working_dir, Dir.pwd)


  sync_before = options["sync_before"]
  sync_after = options["sync_after"]
  print_log = options["log"]
  title = options["title"]
  commit = options["commit"] || nil
  image = options["image"] || nil
  indocker = options["indocker"] || false
  ignore = options[:ignore] || ""
  force = options[:force]


  email_notification = options["email_notification"]
  upload_output = options["upload_output"]
  upload_output = "1m" if upload_output.nil? or upload_output.empty?
  time_to_upload = calc_output_time(upload_output)
  project_home = get_project_home
  @project = Project.new(project_home)

  is_new_branch = @project.compare_commit(commit)
  begin
    if !commit.nil? and !commit.empty?
      invoke :jump, [commit], []
    else
      if sync_before
        # Sync before run

        invoke :sync, [false], :new_branch => is_new_branch, :ignore => ignore, :force => force
      end
    end
    #set image for the project
    if !image.nil? and !image.empty?
      invoke :set_image, [image]
    end
    if !indocker
      image_proj = is_project_with_docker(working_dir)


      if image_proj and image_proj.is_docker
        container= image_proj.get_container
        if !container
          log_message("Couldn't create container with image #{image_proj.image_name}:#{image_proj.image_tag}", Thor::Shell::Color::RED)
          exit(1)
        end


        exec_args = args.flatten.join(" ")
        options_hash = Hash[options]
        options_hash.except!("image", "indocker")
        exec_options = options_hash.map { |x| "--#{x[0]}=#{x[1]}" }.flatten.join(" ")
        command_to_run = copy_args.join(" ")
        command = ["/bin/bash", "-lc", "cnvrg exec --indocker #{exec_options} #{command_to_run} #{exec_args}"]
        puts container.exec(command, tty: true)
        container.stop()
        exit(0)
      end
    end
    remote = options["remote"]
    if remote
      docker_id = `cat /etc/hostname`
      docker_id = docker_id.strip()
    end
    is_on_gpu = options["gpu"]
    start_commit = @project.last_local_commit
    cmd = cmd.join("\s")

    @exp = Experiment.new(@project.owner, @project.slug)

    platform = RUBY_PLATFORM
    machine_name = Socket.gethostname
    begin
      machine_activity = @exp.get_machine_activity(working_dir)
      @exp.start(cmd, platform, machine_name, start_commit, title, email_notification, machine_activity, script_path)
      log_message("Experiment's live results: #{Cnvrg::Helpers.remote_url}/#{@project.owner}/projects/#{@project.slug}/experiments/#{@exp.slug}", Thor::Shell::Color::GREEN)
      log_message("Running: #{cmd}\n", Thor::Shell::Color::BLUE)
      unless @exp.slug.nil?
        real = Time.now
        exp_success = true
        memory_total = []
        cpu_total = []
        start_loop = Time.now
        stdout, stderr = '', ''
        begin
          PTY.spawn(cmd) do |stdout, stdin, pid, stderr|
            begin
              stdout.each do |line|
                cur_time = Time.now
                real_time= Time.now-real

                cur_log = {time: cur_time,
                           message: line,
                           type: "stdout",
                           real: real_time

                }


                if print_log
                  puts cur_log
                end
                log << cur_log

                begin
                  if time_to_upload !=0
                    if time_to_upload <= Time.now - start_loop
                      if remote
                        stats = usage_metrics_in_docker(docker_id)
                        cpu = stats[0]
                        memory = stats[1]
                        if is_on_gpu
                          gpu_stats = gpu_util
                          gpu_utilization = gpu_stats[0]
                          gpu_memory_util = gpu_stats[1]
                        end
                      else
                        memory = memory_usage()
                        cpu = cpu_usage()
                      end
                      log.each do |l|
                        if remote and is_on_gpu
                          l.merge!(cpu: cpu, memory: memory, gpu_util: gpu_utilization, gpu_memory_util: gpu_memory_util)
                        else
                          l.merge!(cpu: cpu, memory: memory)
                        end
                      end


                      #upload current log
                      # cpu_average = cpu_total.inject(0) { |sum, el| sum + el }.to_f / cpu_total.size
                      # memory_average = memory_total.inject(0) { |sum, el| sum + el }.to_f / memory_total.size

                      @exp.upload_temp_log(log, cpu_average, memory_average)
                      log = []
                      start_loop = Time.now
                    end

                  end
                rescue => e

                  log_message("Failed to upload ongoing results, continuing with experiment", Thor::Shell::Color::YELLOW)
                  log_error(e)
                end

              end


              if stderr

                stderr.each do |err|

                  log << {time: Time.now, message: err, type: "stderr"}
                end
              end

            rescue Errno::EIO => e
              log_error(e)

                # break
            rescue Errno::ENOENT => e

              exp_success = false

              log_message("command \"#{cmd}\" couldn't be executed, verify command is valid", Thor::Shell::Color::RED)
              log_error(e)
            rescue Open4::ChildExited
              exp_success = false
              log_message("The process exited!", Thor::Shell::Color::RED)
            rescue => e
              res = @exp.end(log, 1, start_commit, cpu_average, memory_average)

              log_message("Error occurred,aborting", Thor::Shell::Color::RED)
              log_error(e)
              exit(0)
            end
            ::Process.wait pid
          end

            cpu_average = cpu_total.inject(0) { |sum, el| sum + el }.to_f / cpu_total.size
            memory_average = memory_total.inject(0) { |sum, el| sum + el }.to_f / memory_total.size
            exit_status = $?.exitstatus
            if $?.exitstatus != 0
              exp_success = false
            end
            if !exp_success
              if !Cnvrg::Helpers.internet_connection?
                wait_offline = agree "Seems like you're offline, wait until you're back online?", Thor::Shell::Color::YELLOW
                if wait_offline
                  log_message("Waiting until your'e online..", Thor::Shell::Color::BLUE)
                  while !Cnvrg::Helpers.internet_connection?
                  end
                  exit_status = 0
                else
                  log_message("Experiment has failed, your'e computer is offline", Thor::Shell::Color::RED)
                  exit(0)
                end
              else

                end_commit = @project.last_local_commit
                res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
                log_message("Experiment has failed, look at the log for more details or run cnvrg exec --log", Thor::Shell::Color::RED)
                exit(0)
              end

            end
            if sync_after
              # Sync after run


              download(sync=true, ignore_list=ignore)
              upload(link=false, sync=true, direct=false, ignore_list=ignore)

            end
            end_commit = @project.last_local_commit

            res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
            check = Helpers.checkmark()
            log_message("#{check} Done. Experiment's results were updated!", Thor::Shell::Color::GREEN)
        rescue => e
          if container
            container.stop()
          end
          log_message("Couldn't run #{cmd}, check your input parameters", Thor::Shell::Color::RED)
          if @exp
            cur_time = Time.now
            real_time= Time.now-real
            cur_log = {time: cur_time,
                       message: "Couldn't run #{cmd}, check your input parameters",
                       type: "stdout",
                       real: real_time

            }
            log << cur_log
            res = @exp.end(log, "-1", end_commit, cpu_average, memory_average)

          end
          log_error(e)

          exit(1)
        end


      end

    end
  rescue SignalException
    exit_status = -1
    end_commit = @project.last_local_commit

    res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
    if container
      container.stop()
    end
    say "\nAborting"

    exit(1)
  end
end

#exec_container(container_id, *cmd) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4227

def exec_container(container_id, *cmd)
  container = Docker::Container.get(container_id)
  container.start()
  cnvrg_command = cmd.join(" ")
  command = ["/bin/bash", "-lc", "#{cnvrg_command}"]
  res = container.exec(command, tty: true, wait: 5400)[0]
  say res
end

#exec_docker(*cmd) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2719

def exec_docker(*cmd)
  log = []
  cpu_average =0
  memory_average = 0
  verify_logged_in()
  log_start(__method__, args, options)
  project_home = "/home/ds/notebooks"
  @project = Project.new(project_home)
  sync_before = options["sync_before"]
  sync_after = options["sync_after"]
  print_log = options["log"]
  title = options["title"]
  email_notification = options["email_notification"]
  upload_output = options["upload_output"]
  time_to_upload = calc_output_time(upload_output)
  @image = is_project_with_docker(project_home)


  begin
    start_commit = @project.last_local_commit
    cmd = cmd.join("\s")

    log_message("Running: #{cmd}\n", Thor::Shell::Color::BLUE)

    @exp = Experiment.new(@project.owner, @project.slug)
    machine_activity = @exp.get_machine_activity(project_home)

    platform = RUBY_PLATFORM
    machine_name = Socket.gethostname
    begin

      @exp.start(cmd, platform, machine_name, start_commit, title, email_notification, machine_activity, Dir.pwd)
      unless @exp.slug.nil?
        real = Time.now
        exp_success = true
        memory_total = []
        cpu_total = []
        start_loop = Time.now
        begin
          PTY.spawn(cmd) do |stdout, stdin, pid, stderr|
            begin
              stdout.each do |line|
                cur_time = Time.now
                monitor = %x{ps aux|awk  '{print $2,$3,$4}'|grep #{pid} }
                monitor_by = monitor.split(" ")
                memory = monitor_by[2]
                cpu = monitor_by[1]
                memory_total << memory.to_f
                cpu_total << cpu.to_f
                real_time= Time.now-real

                cur_log = {time: cur_time,
                           message: line,
                           type: "stdout",
                           real: real_time}
                if print_log
                  puts cur_log
                end
                log << cur_log

                begin
                  if time_to_upload !=0
                    if time_to_upload <= Time.now - start_loop
                      #upload current log
                      cpu_average = cpu_total.inject(0) { |sum, el| sum + el }.to_f / cpu_total.size
                      memory_average = memory_total.inject(0) { |sum, el| sum + el }.to_f / memory_total.size

                      @exp.upload_temp_log(log, cpu_average, memory_average)
                      log = []
                      start_loop = Time.now
                    end

                  end
                rescue
                  log_message("Failed to upload ongoing results, continuing with experiment", Thor::Shell::Color::YELLOW)
                end

              end


              if stderr

                stderr.each do |err|

                  log << {time: Time.now, message: err, type: "stderr"}
                end
              end

            rescue Errno::EIO => e
              break
            rescue Errno::ENOENT

              exp_success = false

              log_message("command \"#{cmd}\" couldn't be executed, verify command is valid", Thor::Shell::Color::RED)
            rescue PTY::ChildExited
              exp_success = false
              log_message("The process exited!", Thor::Shell::Color::RED)
            rescue => e
              log_message("Error occurred, aborting", Thor::Shell::Color::RED)
              log_error(e)
              exit(0)
            end
            ::Process.wait pid
            cpu_average = cpu_total.inject(0) { |sum, el| sum + el }.to_f / cpu_total.size
            memory_average = memory_total.inject(0) { |sum, el| sum + el }.to_f / memory_total.size
            exit_status = $?.exitstatus
            if $?.exitstatus != 0
              exp_success = false
            end
            if !exp_success
              if !Cnvrg::Helpers.internet_connection?
                wait_offline = agree "Seems like you're offline, wait until your'e back online?", Thor::Shell::Color::YELLOW
                if wait_offline
                  log_message("Waiting until your'e online..", Thor::Shell::Color::BLUE)
                  while !Cnvrg::Helpers.internet_connection?
                  end
                  exit_status = 0
                else
                  log_message("Experiment has failed, your'e computer is offline", Thor::Shell::Color::RED)
                  exit(0)
                end
              else

                end_commit = @project.last_local_commit
                res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
                @image.update_image_activity(@project.last_local_commit, @exp.slug)
                log_message("Experiment has failed, look at the log for more details or run cnvrg exec --log", Thor::Shell::Color::RED)
                exit(0)
              end

            end
            if sync_after
              log_message("Syncing project after running", Thor::Shell::Color::BLUE)
              # Sync after run
              download()
              upload()
              log_message("Done Syncing", Thor::Shell::Color::BLUE)
            end
            end_commit = @project.last_local_commit

            res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
            @image.update_image_activity(@project.last_local_commit, @exp.slug)

            check = Helpers.checkmark()
            log_message("#{check} Done. Experiment's result: #{Cnvrg::Helpers.remote_url}/#{@project.owner}/projects/#{@project.slug}/experiments/#{@exp.slug}", Thor::Shell::Color::GREEN)
          end
        rescue => e
          log_message("Couldn't run #{cmd}, check your input parameters", Thor::Shell::Color::RED)
          log_error(e)
          exit(1)
        end


      end

    end
  rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)

  rescue SignalException
    exit_status = -1
    end_commit = @project.last_local_commit
    if !@exp.nil?

      res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
    end

    say "\nAborting"

    exit(1)
  end
end

#exec_remote(*cmd) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2911

def exec_remote(*cmd)
  verify_logged_in(true)
  log_start(__method__, args, options)
  working_dir = is_cnvrg_dir
  path_to_cmd = get_cmd_path_in_dir(working_dir, Dir.pwd)

  begin
    grid = options["grid"] || nil
    data = options["data"] || nil
    data_commit = options["data_commit"] || nil
    sync_before = options["sync_before"]
    force = options["force"]

    instance_type = options["machine_type"] || nil
    schedule = options["schedule"] || ""
    if schedule.start_with? 'in'
      time = schedule.split(" ")

      local = Time.now.localtime
      if time[2].downcase().start_with? "min"
        new = local + (time[1].to_i * 60)
      elsif time[2].downcase().start_with? "hours"
        new = local + (time[1].to_i * 3600)
      elsif time[2].downcase().start_with? "days"
        new = local + (time[1].to_i * 3600 * 24)
      else
        log_message("Could not undersatnd when to schedule experiment", Thor::Shell::Color::RED)
        exit(1)
      end
      new_time = new.to_s
      new_time = new_time[0, new_time.size-6] #remove timezone
      schedule = "at #{new_time}"
    end
    upload_output = options["upload_output"]
    time_to_upload = calc_output_time(upload_output)
    if time_to_upload==0 or time_to_upload==-1
      upload_output_option = "--upload_output=1m"
    else
      upload_output_option = "--upload_output=#{upload_output}"
    end
    remote = "--remote=true"
    if !instance_type.nil? and instance_type.include? "gpu"
      remote= "#{remote} --gpu=true"
    end

    options_hash = Hash[options]
    options_hash.except!("schedule", "machine_type", "image", "upload_output", "grid", "data", "data_commit", "local", "small", "medium", "large", "gpu", "gpuxl", "gpuxxl")
    exec_options = options_hash.map { |x| "--#{x[0]}=#{x[1]}" }.flatten.join(" ")
    command = "#{exec_options} #{remote}  #{upload_output_option} #{cmd.flatten.join(" ")}"
    commit_to_run = options["commit"] || nil
    if !schedule.nil? and !schedule.empty?

      local_timestamp = get_schedule_date

    end
    project = Project.new(working_dir)

    choose_image = options["image"]

    if !choose_image.nil? and !choose_image.empty?
      invoke :set_image, [choose_image]
    end
    image = is_project_with_docker(working_dir)
    if !image or !image.is_docker
      # say "Couldn't find image related to project", Thor::Shell::Color::RED

      image_slug = "cnvrg"
      if instance_type.eql? "gpu" or instance_type.eql? "gpuxl"
        image_slug = "cnvrg_gpu"
      end
      # default = yes? "use #{default_image_name} default image?", Thor::Shell::Color::YELLOW
      # if default
      #   image = Images.new(working_dir, default_image_name)
      #   image_slug = image.image_slug
      # else
      #   exit(0)
      # end
    else
      image_slug = image.image_slug
    end

    invoke :sync, [false], :force=>force if sync_before


    if command.include? "'"
      oc = command.to_enum(:scan, /'/).map { Regexp.last_match }
      pairs = oc.enum_for(:each_slice, 2).to_a
      pairs.each_with_index do |p, i|
        add=0
        if i!=0
          add=2*i
        end
        total_loc = command[p[0].offset(0)[0]+add..p[1].offset(0)[0]+add]
        command[p[0].offset(0)[0]+add..p[1].offset(0)[0]+add] = "\"#{total_loc}\""
      end


    end
    log_message("Running remote experiment", Thor::Shell::Color::BLUE)
    exp = Experiment.new(project.owner, project.slug)
    res = exp.exec_remote(command, commit_to_run, instance_type, image_slug, schedule, local_timestamp, grid, path_to_cmd, data, data_commit)
    if Cnvrg::CLI.is_response_success(res)
      # if res["result"]["machine"] == -1
      #   say "There are no available machines", Thor::Shell::Color::BLUE
      #   create = yes? "create new machine?", Thor::Shell::Color::YELLOW
      #   if create
      #     res = Cnvrg::API.request("users/#{image.owner}/machines/list", 'GET')
      #     if Cnvrg::CLI.is_response_success(res)
      #       instance_type = machine_options(res["result"]["aws_options"])
      #       if @image.new_machine(instance_type)
      #         say "Running remote experiment", Thor::Shell::Color::BLUE
      #
      #         # res = image.exec_remote(exec_args, exec_options, project.last_local_commit)
      #         # if Cnvrg::CLI.is_response_success(res)
      #
      #           check = Helpers.checkmark()
      #           say "#{check} Finished successfuly", Thor::Shell::Color::GREEN
      #           exit(0)
      #         # end
      #       end
      #     else
      #       say "No machines are avilable", Thor::Shell::Color::RED
      #       exit(0)
      #     end
      #
      #
      #   else
      #     say "Can't execute command on remote machine with local image", Thor::Shell::Color::RED
      #     exit(1)
      #
      #   end
      # else
      check = Helpers.checkmark()
      str = "#{check} Experiment's is on: #{Cnvrg::Helpers.remote_url}/#{project.owner}/projects/#{project.slug}/experiments/#{res["result"]["exp_url"]}"

      if res["result"]["grid"]
        str = "Running grid search. #{Cnvrg::Helpers.remote_url}/#{project.owner}/projects/#{project.slug}/experiments?grid=#{res["result"]["exp_url"]} "
      end

      log_message(str, Thor::Shell::Color::GREEN)

      exit(0)
      # end
    end

  rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)

  rescue SignalException
    exit_status = -1
    end_commit = project.last_local_commit

    res = @exp.end(log, exit_status, end_commit, "", "")
    say "\nAborting"

    exit(1)
  end
end

#experiments ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4690

def experiments
  verify_logged_in(true)
  log_start(__method__, args, options)

  project_dir = is_cnvrg_dir(Dir.pwd)
  @project = Project.new(project_dir)
  unless options['id'].to_s.size > 5
    result = @project.get_experiments()
    list = result["result"]["experiments"]
    if list and list.size > 1
      print_table(list)
    else
      say "No experiments"
    end
  else
    result = @project.get_experiment(options['id'])
    result = result["result"]["experiment"]
    if result
      if options["tag"].to_s.size == 0
        list = []
        list << result.keys
        list << result.values

        print_table(list)
      else
        if result.keys.include? options["tag"]
          say result[options["tag"]]
        else
          say "No such tag"
        end
      end
    else
      say "No such experiment"
    end


  end

end

#get_machine ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4732

def get_machine()
  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    owner = Cnvrg::CLI.get_owner()
    working_dir = is_cnvrg_dir
    @image = Images.new(working_dir)
    if @image.nil? or !@image.is_docker
      say "Couldn't find image related to this project", Thor::Shell::Color::RED
      exit(0)
    end
    res = Cnvrg::API.request("users/#{owner}/machines/list", 'GET')
    if Cnvrg::CLI.is_response_success(res)
      if res["result"]["machines"].empty?
        create = yes? "No machines available, create new machine?", Thor::Shell::Color::YELLOW
        if create
          instance_type = machine_options(res["result"]["aws_options"])
        else
          exit(0)
        end
      end
      printf "%-20s %-20s %-20s\n", "name", "created by", "last_used", "instance_type"
      res["result"]["machines"].each do |u|
        time = Time.parse(u["last_used"])
        update_at = get_local_time(time)
        printf "%-20s %-20s %-20s\n", u["name"], u["created_by"], update_at, u["instance type"]
      end
    end

  rescue SignalException
    log_end(-1)
    say "\nAborting"
    exit(1)
  end
end

#init_data(public) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 758

def init_data(public)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    dataset_name =File.basename(Dir.getwd)
    if File.directory?(Dir.getwd+"/.cnvrg")
      config = YAML.load_file("#{Dir.getwd}/.cnvrg/config.yml")
      log_message("Directory is already linked to #{config[:dataset_slug]}", Thor::Shell::Color::RED)

      exit(0)
    end
    log_message("Init dataset: #{dataset_name}", Thor::Shell::Color::BLUE)

    working_dir = Dir.getwd
    owner = CLI.get_owner
    if Dataset.init(owner, dataset_name, options["public"])
      path = Dir.pwd
      @dataset = Dataset.new(path)

      url = @dataset.url
      check = Helpers.checkmark
      log_message("#{check} Link finished successfully", Thor::Shell::Color::GREEN)
      log_message("#{dataset_name}'s location is: #{url}\n", Thor::Shell::Color::GREEN)

    else
      @dataset.revert(working_dir) unless @dataset.nil?
      log_message("Error creating dataset, please contact support.", Thor::Shell::Color::RED)
      exit(0)
    end
  rescue => e
    log_error(e)
  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#init_data_container(container) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 856

def init_data_container(container)
  begin
    login_content = options["login_content"]

    container = Docker::Container.get(container)
    command = ["/bin/bash", "-lc", "sudo echo -e \"#{login_content}\" >/home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "mkdir /home/ds/.cnvrg"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "mkdir /home/ds/.cnvrg/tmp"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chown -R ds /home/ds/.cnvrg /home/ds/.netrc"]
    container.exec(command, tty: true)
    command = ["/bin/bash", "-lc", "sudo chmod 0600 /home/ds/.netrc"]
    container.exec(command, tty: true)

  rescue SignalException

    say "\nAborting"
    exit(1)
  end
end

#install_python_libraries(*lib) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3766

def install_python_libraries(*lib)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    image = is_project_with_docker(Dir.pwd)
    if image and image.is_docker
      container = image.get_container
      if !container

        say "Couldn't create container with image #{image.image_name}:#{image.image_tag}", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Project is not configured with any image", Thor::Shell::Color::RED
      exit(1)

    end
    req_file = options["requirement"] || nil
    if lib.nil? and not req_file.nil?
      if not File.exist? req_file
        say "Couldn't find #{req_file}", Thor::Shell::Color::RED
        exit(1)

      end
      command_to_run = "pip install -r #{req_file}"

    else
      command_to_run = lib.join(" ")

    end
    say "Running #{command_to_run} in container", Thor::Shell::Color::BLUE
    command = ["/bin/bash", "-lc", "#{command_to_run}"]
    res = container.exec(command, tty: false)
    say res[0].join("\n")
    checks = Helpers.checkmark()
    say "Updating image", Thor::Shell::Color::BLUE

    image.create_custom_image("")
    say "#{checks} Done, installing libraries completed", Thor::Shell::Color::GREEN
    container.stop()

    log_end(0)
  rescue => e
    log_end(-1, e.message)
    say "Error occurred, aborting"
    if container
      container.stop()
    end
  rescue SignalException
    if container
      container.stop()
    end
    say "\nAborting"
    exit(1)
  end

end

#install_system_libraries(*command_to_run) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3715

def install_system_libraries(*command_to_run)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    image = is_project_with_docker(Dir.pwd)
    if image and image.is_docker
      container = image.get_container
      if !container

        say "Couldn't create container with image #{image.image_name}:#{image.image_tag}", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Project is not configured with any image", Thor::Shell::Color::RED
      exit(1)

    end

    command_to_run = command_to_run.join(" ")
    say "Running #{command_to_run} in container", Thor::Shell::Color::BLUE
    command = ["/bin/bash", "-lc", "#{command_to_run}"]
    res = container.exec(command, tty: false)
    say res[0].join("\n")
    checks = Helpers.checkmark()
    say "Updating image", Thor::Shell::Color::BLUE

    image.create_custom_image("")
    say "#{checks} Done, installing libraries completed", Thor::Shell::Color::GREEN
    container.stop()

    log_end(0)
  rescue => e
    log_end(-1, e.message)
    say "Error occurred, aborting"
    if container
      container.stop()
    end
  rescue SignalException
    log_End(-1)
    if container
      container.stop()
    end
    say "\nAborting"
    exit(1)
  end

end

#jump(commit_sha1) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2195

def jump(commit_sha1)
begin
  verify_logged_in()
  log_start(__method__, args, options)
  is_remote = options["remote"]
  project_home = get_project_home
  @project = Project.new(project_home)
  # say "Syncing existing project tree before jumping", Thor::Shell::Color::BLUE
  current_commit = @project.last_local_commit
  if current_commit.eql? commit_sha1
    log_message("Project is already updated", Thor::Shell::Color::GREEN)
    exit(0)
  end
  @files = Cnvrg::Files.new(@project.owner, @project.slug)
  response = @project.clone(false, commit_sha1)
  Cnvrg::CLI.is_response_success(response, true)

  successful_changes = []

  if !response["result"]["tree"].nil?
    parallel_options = {
        :progress => {
            :title => "Jump Progress",
            :progress_mark => '=',
            :format => "%b>>%i| %p%% %t",
            :starting_at => 0,
            :total => response["result"]["tree"].size,
            :autofinish => true
        },
        in_processes: ParallelProcesses,
        in_thread: ParallelThreads
    }
    commit_sha1 = response["result"]["commit"]
    idx = {commit: response["result"]["commit"], tree: response["result"]["tree"]}
    File.open(project_home + "/.cnvrg/idx.yml", "w+") { |f| f.write idx.to_yaml }
    if is_remote
      current_tree = Dir.glob("**/*", File::FNM_DOTMATCH).flatten.reject { |file| file.start_with? '.' or file.eql? "__init__.py" or file.eql? "uwsgi.ini" or file.ends_with? "/." or file.eql? "." }
    else
      current_tree = Dir.glob("**/*", File::FNM_DOTMATCH).flatten.reject { |file| file.start_with? '.cnvrg' or file.ends_with? "/."  or file.eql? "."}
    end

    jump_result = Parallel.map(response["result"]["tree"], parallel_options) do |f|

      relative_path = f[0].gsub(/^#{@project.local_path}/, "")
      log_message("Downloading #{f[0]}", Thor::Shell::Color::BLUE, false)
      if f[0].end_with? "/"
        # dir
      @files.download_dir(f[0], relative_path, project_home)

      else
        # blob
        @files.download_file_s3(f[0], relative_path, project_home, commit_sha1=commit_sha1)
      end
    end


      successful_changes = jump_result.select { |x| not x.nil? }
  end
  response["result"]["tree"].each do |f|
    if f[0].end_with? "/"
        current_tree .delete(f[0][0, f[0].size-1])
    else
      current_tree .delete(f[0])
    end
  end

    FileUtils.rm_rf(current_tree)
    log_message("Done. Jumped to #{commit_sha1} completed successfully", Thor::Shell::Color::GREEN)
    rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)
    rescue SignalException

    exit(1)
  end
end

#link ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 677

def link
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    docker_image = options["docker_image"]
    if !docker_image.nil? and !docker_image.empty?
      docker = true
    else
      docker = false
    end

    sync = options["sync"]
    project_name =File.basename(Dir.getwd)
    log_message("Linking #{project_name}", Thor::Shell::Color::BLUE)
    if File.directory?(Dir.getwd+"/.cnvrg")
      config = YAML.load_file("#{Dir.getwd}/.cnvrg/config.yml")
      log_message("Directory is already linked to #{config[:project_slug]}", Thor::Shell::Color::RED)
      exit(0)
    end
    working_dir = Dir.getwd
    owner = CLI.get_owner
    if Project.link(owner, project_name, docker)
      path = Dir.pwd
      @project = Project.new(path)
      @project.generate_idx()
      if docker
        local_images = Docker::Image.all
        docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.include? docker_image }.flatten
        if docker_image_local.size == 0
          if yes? "Image wasn't found locally, pull image from cnvrg repository?", Thor::Shell::Color::YELLOW
            image = pull(docker_image)
            if image
              log_message("downloaded image: #{docker_image}", Thor::Shell::Color::BLUE)
              @image = Images.new(working_dir, docker_image)
            else
              log_message("Could not create a new project with docker, image was not found", Thor::Shell::Color::RED)
              @project.revert(working_dir)
              exit(1)
            end
          else
            log_message("Could not create a new project with docker, image was not found", Thor::Shell::Color::RED)
            @project.revert(working_dir)
            exit(1)

          end
        elsif docker_image_local.size == 1
          log_message("found image: #{docker_image_local[0]}, setting it up..", Thor::Shell::Color::BLUE)
          @image = Images.new(working_dir, docker_image_local[0])
        elsif docker_image_local.size >1
          log_message("found #{docker_image_local.size} images, choose the image name you want to use", Thor::Shell::Color::BLUE)
          image_name = ask "#{docker_image_local.join("\n")}\n", Thor::Shell::Color::BLUE
          @image = Images.new(working_dir, image_name)
        end
      end
      if sync
        log_message("Syncing project", Thor::Shell::Color::BLUE)
        upload(true)
      end

      url = @project.url
      check = Helpers.checkmark
      log_message("#{check} Link finished successfully", Thor::Shell::Color::GREEN)
      log_message("#{project_name}'s location is: #{url}\n", Thor::Shell::Color::GREEN)

    else
      @project.revert(working_dir) unless @project.nil?
      log_message("Error linking project, please contact support.", Thor::Shell::Color::RED)
      exit(0)
    end
  rescue => e
    log_error(e)
  rescue SignalException

    say "\nAborting"
    exit(1)
  end
end

#list_commits ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1440

def list_commits()
  verify_logged_in(true)
  log_start(__method__, args, options)

  project_dir = is_cnvrg_dir(Dir.pwd)
  @project = Project.new(project_dir)
  result = @project.list_commits()
  list = result["result"]["list"]

  print_table(list)

end

#list_dataset ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1407

def list_dataset
  verify_logged_in(false)
  log_start(__method__, args, options)
  dataset_dir = is_cnvrg_dir(Dir.pwd)
  @dataset = Dataset.new(dataset_dir)
  owner = @dataset.owner
  if owner.nil? or owner.empty?
    owner = CLI.get_owner()
  end
  result = @dataset.list(owner)
  list = result["result"]["list"]

  print_table(list)

end

#list_dataset_commits ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1425

def list_dataset_commits()
  verify_logged_in(true)
  log_start(__method__, args, options)

  dataset_dir = is_cnvrg_dir(Dir.pwd)
  @dataset = Dataset.new(dataset_dir)
  result = @dataset.list_commits()
  list = result["result"]["list"]

  print_table(list)

end

#list_images ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4637

def list_images
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    owner = Cnvrg::CLI.get_owner()
    res = Cnvrg::API.request("users/#{owner}/images/list", 'GET')
    if Cnvrg::CLI.is_response_success(res)
      printf "%-20s %-20s  %-30s %-20s %-20s\n", "name", "project", "created by", "is_public", "last updated"
      res["result"]["images"].each do |u|
        time = Time.parse(u["created_at"])
        update_at = get_local_time(time)
        created_by = u["created_by"]

        printf "%-20s %-20s  %-30s %-20s %-20s\n", u["name"], u["project"], created_by, u["is_public"], update_at
      end
    end
    return res["result"]["images"]
  rescue SignalException
    say "\nAborting"
    exit(1)
  end


end

#list_machines ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4664

def list_machines
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    owner = Cnvrg::CLI.get_owner()
    res = Cnvrg::API.request("users/#{owner}/machines/list", 'GET')
    if Cnvrg::CLI.is_response_success(res)
      printf "%-20s %-20s %-20s\n", "name", "created by", "last_used"
      res["result"]["machines"].each do |u|
        time = Time.parse(u["last_used"])
        update_at = get_local_time(time)
        printf "%-20s %-20s %-20s\n", u["name"], u["created_by"], update_at
      end
    end
    return res["result"]["images"]
  rescue SignalException
    say "\nAborting"
    exit(1)
  end


end

# File 'lib/cnvrg/cli.rb', line 405

def login
  begin
    log_handler()
    log_start(__method__, args, options)

    cmd = HighLine.new

    say 'Authenticating with cnvrg', Thor::Shell::Color::YELLOW

    @auth = Cnvrg::Auth.new
    netrc = Netrc.read
    @email, token = netrc[Cnvrg::Helpers.netrc_domain]

    if @email and token
      log_message('Seems you\'re already logged in', Thor::Shell::Color::BLUE)
      exit(0)
    end
    @email = ask("Enter your email:")
    password = cmd.ask("Enter your password (hidden):") { |q| q.echo = "*" }
    result = @auth.sign_in(@email, password)

    if !result["token"].nil?
      netrc[Cnvrg::Helpers.netrc_domain] = @email, result["token"]
      netrc.save

      log_message("Authenticated successfully as #{@email}", Thor::Shell::Color::GREEN)

      owners = result["owners"]
      urls = result["urls"]
      choose_owner = result["username"]
      ow_index = 0
      if owners.empty?
        choose_owner = result["username"]
      else
        choose_owner = owners[0]
      end

      # if owners.empty?
      # else
      #   owners << choose_owner
      #   chosen = false
      #   while !chosen
      #     owners_id = owners.each_with_index.map { |x, i| "#{i+1}. #{x}" }
      #     choose_owner = ask("Choose default owner:\n"+owners_id.join("\n")+"\n")
      #
      #     if choose_owner =~ /[[:digit:]]/
      #       ow_index = choose_owner.to_i-1
      #       if ow_index<0 or ow_index >= owners.size
      #         say "No such owner, please choose again", Thor::Shell::Color::BLUE
      #         chosen = false
      #         next
      #       end
      #       choose_owner = owners[choose_owner.to_i-1]
      #       chosen = true
      #
      #     else
      #
      #       owners_lower = owners.map { |o| o.downcase }
      #       ow_index = owners_lower.index(choose_owner.downcase)
      #       if ow_index.nil?
      #         say "Could not find owner named #{choose_owner}", Thor::Shell::Color::RED
      #       else
      #         chosen = true
      #       end
      #     end
      #
      #   end


      # end

      if set_owner(choose_owner, result["username"], urls[ow_index])
        log_message("Setting default owner: #{choose_owner}", Thor::Shell::Color::GREEN)

      else
        log_message("Setting default owenr has failed, logging out", Thor::Shell::Color::RED)

        return logout()
      end

    else
      log_message("Failed to authenticate, wrong email/password", Thor::Shell::Color::RED)

      exit(1)
    end
  rescue => e

    log_message("Error Occurred, aborting", Thor::Shell::Color::RED)
    log_error(e)

    logout()
    exit(1)
  rescue SignalException

    say "\nAborting"
    logout()
    exit(1)
  end
end

#logout ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 508

def logout
  begin
    log_handler()
    log_start(__method__, args, options)
    netrc = Netrc.read
    netrc.delete(Cnvrg::Helpers.netrc_domain)
    netrc.save
    log_message("Logged out successfully.\n", Thor::Shell::Color::GREEN)
  rescue =>  e
    puts e.message
    puts e.backtrace
  rescue SignalException
    say "\nAborting"
    exit(1)
  end

end

#me ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 529

def me()
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    auth = Cnvrg::Auth.new
    if (email = auth.get_email)
      log_message("Logged in as: #{email}", Thor::Shell::Color::GREEN)
    else
      log_message("You're not logged in.", Thor::Shell::Color::RED)
    end


  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#new(project_name) ⇒ `Object`

Projects

548	# File 'lib/cnvrg/cli.rb', line 548 desc 'new', 'Create a new cnvrg project'

#notebook ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3203

def notebook
  local = options["local"]
  notebook_dir = options["notebook_dir"]
  kernel = options["kernel"]
  image = options["image"]
  data = options["data"]
  data_commit = options["data_commit"]
  if local
    invoke :run_notebook, [], :notebook_dir => notebook_dir, :remote => false, :kernel => kernel, :image => image
    return
  else
    instances = {"small" => options["small"], "medium" => options["medium"], "large" => options["large"],
                 "gpu" => options["gpu"], "gpuxl" => options["gpuxl"], "gpuxxl" => options["gpuxxl"]}
    instance_type = get_instance_type(instances)

    invoke :remote_notebook, [], :notebook_dir => notebook_dir, :kernel => kernel, :machine_type => instance_type, :image => image,
           :data => data, :data_commit => data_commit
    return

  end


end

#notebook_stop(notebook_slug) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3677

def notebook_stop(notebook_slug)
  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    project_dir = is_cnvrg_dir()


    @project = Project.new(project_dir)


    @note = Experiment.new(@project.owner, @project.slug)
    log_message("Stoping notebook session: #{notebook_slug}", Thor::Shell::Color::BLUE)

    res = @note.end_notebook_session(notebook_slug)
    if res
      check = Helpers.checkmark()
      log_message("#{check} Notebook session has stopped successfully", Thor::Shell::Color::GREEN)

      exit(0)
    else

      log_message("Couldn't stop notebook session, try stopping via cnvrg web", Thor::Shell::Color::RED)
      exit(1)
    end
  rescue => e
    log_message("Error occurd, aborting", Thor::Shell::Color::RED)
    log_error(e)
  rescue SignalException
    log_message("Aborting", Thor::Shell::Color::BLUE)
    exit(1)
  end


end

#port_container(container_id) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4238

def port_container(container_id)
  container = Docker::Container.get(container_id)
  say container.json["HostConfig"]["PortBindings"]["8888/tcp"][0]["HostPort"]
end

#pull_image(image_name) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4771

def pull_image(image_name)
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)
    owner = Cnvrg::CLI.get_owner()
    image = Cnvrg::Images.image_exist(owner, image_name)
    if !image
      log_message("Couldn't find image in cnvrg repository", Thor::Shell::Color::RED)
      exit(1)
    end
    path = download_image(image_name, image["slug"])
    if path
      log_message("Building image", Thor::Shell::Color::BLUE)
      Docker.options[:read_timeout]=216000
      image = Docker::Image.build_from_dir(path, {'dockerfile' => 'Dockerfile.cpu', 't' => "#{image_name}:latest"}) do |v|
        begin
          if (log = JSON.parse(v)) && log.has_key?("stream")
            next if log["stream"].starts_with? "Step"
            $stdout.puts log["stream"]
          end
        rescue
        end

      end

      if not image.nil?
        FileUtils.rm_rf(path)
        checks = Helpers.checkmark()
        log_message("#{checks} Image built successfully", Thor::Shell::Color::GREEN)
        return image
      else

        log_message("Could not build image", Thor::Shell::Color::RED)
        return false
      end
    else

      log_message("Could not download image", Thor::Shell::Color::RED)
      return false


    end

      # else
      #   path = download_image(image_name,image["slug"])
      #   if path
      #     image = Docker::Image.import(path)
      #     image.tag('repo' => image_name, 'tag' => 'latest')
      #     if not image.nil?
      #       say "Finished downloading image, cleaning up..", Thor::Shell::Color::GREEN
      #       FileUtils.rm(path)
      #       checks = Helpers.checkmark()
      #       say "#{checks} Done", Thor::Shell::Color::GREEN
      #       log_end(0)
      #       return image
      #       log_end(0)
      #     else
      #       say "Could not download image", Thor::Shell::Color::RED
      #       return false
      #     end
      #
      #   end
      # end
  rescue => e

    log_message "Error: couldn't build image", Thor::Shell::Color::RED
    log_error(e)

  rescue SignalException
    say "\nAborting"
    exit(1)
  ensure
    if path
      FileUtils.rm_rf(path)

    end
  end


end

#push(*name) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4117

def push(*name)
  verify_logged_in(true)
  log_start(__method__, args, options)
  working_dir = is_cnvrg_dir()
  if !name.empty? and name == "cnvrg"
    log_message("can't create image with the name cnvrg", Thor::Shell::Color::RED)
    exit(1)
  end
  begin
    image = is_project_with_docker(working_dir)
    if !image or !image.is_docker
      log_message("Couldn't find image related to project", Thor::Shell::Color::RED)
      exit(0)
    end
    if !name.nil? and !name.empty?
      if name.include? " "
        name.gsub!(" ", "_")
      end
    end
    stored_commands = File.open(working_dir+"/.cnvrg/custom_image.txt").read.chop.gsub("\n", ",")
    if stored_commands.nil? or stored_commands.empty?
      log_message("Nothing to push", Thor::Shell::Color::BLUE)
      exit(0)
    end

    log_message("Pushing new image", Thor::Shell::Color::BLUE)
    if image.create_custom_image(name, working_dir, stored_commands)

      log_message("Image was updated successfully", Thor::Shell::Color::GREEN)
    end
  rescue => e
    log_message("error occurred, aborting", Thor::Shell::Color::RED)
    log_error(e)

  end
end

#remote_notebook ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3339

def remote_notebook()
  verify_logged_in(true)
  log_start(__method__, args, options)

  working_dir = is_cnvrg_dir()
  instance_type = options["machine_type"] || nil
  data = options["data"]
  data_commit = options["data_commit"]
  commit = options["commit"]
  notebook_type = options["notebook_type"]


  begin
    project = Project.new(working_dir)
    exp = Experiment.new(project.owner, project.slug)

    if !notebook_type.nil? and !notebook_type.empty?
      notebook_type = "jupyter"
    end
    invoke :sync, [false], []
    slug = ""
    res =exp.remote_notebook( instance_type, commit, data, data_commit, notebook_type)
    if Cnvrg::CLI.is_response_success(res)
      slug = res["result"]["notebook_url"]
      log_message("#{Helpers.checkmark} Notebook is ready: #{Cnvrg::Helpers.remote_url}/#{project.owner}/projects/#{project.slug}/notebook_sessions/show/#{slug}", Thor::Shell::Color::GREEN)

    end
  rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)

  rescue SignalException
    log_message("Aborting", Thor::Shell::Color::BLUE)
    notebook_stop(slug) unless slug.nil? or slug.empty?

    exit(1)
  end
end

#remote_notebook_old ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3236

def remote_notebook_old()
  verify_logged_in(true)
  log_start(__method__, args, options)

  working_dir = is_cnvrg_dir()
  notebook_dir = options["notebook_dir"]
  instance_type = options["machine_type"] || nil
  kernel = options["kernel"] || nil
  data = options["data"]
  data_commit = options["data_commit"]


  begin
    choose_image = options["image"]

    if !choose_image.nil? and !choose_image.empty?
      invoke :set_image, [choose_image]
    end
    @image = is_project_with_docker(working_dir)
    if !@image or !@image.is_docker
      # say "Couldn't find image related to project", Thor::Shell::Color::RED
      default_image_name = "cnvrg"
      if instance_type.eql? "gpu" or instance_type.eql? "gpuxl"
        default_image_name = "cnvrg-gpu"
      end
      # default = yes? "use #{default_image_name} default image?", Thor::Shell::Color::YELLOW
      # if default
      @image = Images.new(working_dir, default_image_name)
      # else
      #   exit(0)
      # end
    end

    invoke :sync, [false], []


    res = @image.remote_notebook(notebook_dir, instance_type, kernel, data, data_commit)
    if Cnvrg::CLI.is_response_success(res)
      if res["result"]["machine"] == -1
        log_message("There are no available machines", Thor::Shell::Color::BLUE)
        create = yes? "create new machine?", Thor::Shell::Color::YELLOW
        if create
          res = Cnvrg::API.request("users/#{@image.owner}/machines/list", 'GET')
          if Cnvrg::CLI.is_response_success(res)
            instance_type = machine_options(res["result"]["aws_options"])
            if @image.new_machine(instance_type)
              res = @image.remote_notebook(notebook_dir, instance_type, kernel)
              if Cnvrg::CLI.is_response_success(res)
                url = res["result"]["url"]
                if !url.nil? and !url.empty?
                  check = Helpers.checkmark()

                  log_message("#{check} Notebook server started successfully", Thor::Shell::Color::GREEN)
                  Launchy.open(url)
                else
                  log_message("Couldn't run notebook server", Thor::Shell::Color::RED)
                end
                exit(0)
              end
            end
          else
            log_message("No machines are avilable", Thor::Shell::Color::RED)
            exit(0)
          end


        else
          log_message("Can't execute command on remote machine with local image", Thor::Shell::Color::RED)
          exit(1)

        end
      else
        note_url = res["result"]["notebook_url"]
        @image.set_note_url(note_url)
        check = Helpers.checkmark()
        log_message("#{check} Notebook is on: #{Cnvrg::Helpers.remote_url}/#{@image.owner}/projects/#{@image.project_slug}/notebook_sessions/show/#{note_url}", Thor::Shell::Color::GREEN)
        # Launchy.open(url)

        exit(0)
      end
    end
  rescue => e
    log_message("Error occurred, Aborting", Thor::Shell::Color::RED)
    log_error(e)

  rescue SignalException
    exit_status = -1
    end_commit = @project.last_local_commit

    res = @exp.end(log, exit_status, end_commit, cpu_average, memory_average)
    say "\nAborting"

    exit(1)
  end
end

#revert_exp ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1678

def revert_exp
  begin
    log_start(__method__, args, options)
    @project = Project.new(get_project_home)
    ignore_list = @project.get_ignore_list()

    result = @project.compare_idx(false)["result"]
    result = result["tree"]
    if result["added"].size > 0
      FileUtils.rm_rf(result["added"])
    end
    say "Changes were removed successfully", Thor::Shell::Color::GREEN


  rescue SignalException
    log_end(-1)
    say "\nAborting"
    exit(1)
  end
end

#run(*cmd) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2371

def run(*cmd)
  sync_before = options["sync_before"]
  sync_after = options["sync_after"]
  log = options["log"]
  title = options["title"]
  commit = options["commit"] || nil
  email_notification = options["email_notification"]
  upload_output = options["upload_output"]
  local = options["local"]
  schedule = options["schedule"]
  image = options["image"]
  grid = options["grid"]
  data = options["data"]
  data_commit = options["data_commit"]
  ignore = options["ignore"]
  force = options["force"]

  options_hash = Hash[options]
  real_options = []
  options_hash.each do |o|
    real_options << o if (!o[1].eql? "" and !["small", "medium", "large", "gpu", "gpuxl", "gpuxxl"].include? o[0])
  end
  if local
    invoke :exec, [cmd], :sync_before => sync_before, :sync_after => sync_after, :title => title,
           :log => log, :email_notification => email_notification, :upload_output => upload_output,
           :commit => commit, :image => image, :data => data, :data_commit => data_commit, :ignore => ignore, :force=>force
    return
  else
    real_options.delete(["local", false])
    instances = {"small" => options["small"], "medium" => options["medium"], "large" => options["large"],
                 "gpu" => options["gpu"], "gpuxl" => options["gpuxl"], "gpuxxl" => options["gpuxxl"]}
    instance_type = get_instance_type(instances)
    if !instance_type.nil? and !instance_type.empty?
      real_options << ["machine_type", instance_type]
    end
    exec_options = real_options.map { |x| "--#{x[0]}=#{x[1]}" }.flatten.join(" ")
    cmd_to_exec = "#{exec_options} #{cmd.join(" ")}"
    invoke :exec_remote, [cmd], :sync_before => sync_before, :sync_after => sync_after, :title => title, :machine_type => instance_type,
           :schedule => schedule, :log => log, :email_notification => email_notification, :upload_output => upload_output, :commit => commit,
           :image => image, :grid => grid, :data => data, :data_commit => data_commit, :ignore => ignore, :force=>force
    return
  end

  # if local
  #
  # else


  #   invoke :exec_remote, [cmd_to_exec.split(" ")], :sync_before => sync_before, :sync_after => sync_after, :title => title, :machine_type => instance_type,
  #          :schedule => schedule, :log => log, :email_notification => email_notification, :upload_output => upload_output, :commit => commit,
  #          :image => image, :grid => grid, :data => data, :data_commit => data_commit, :ignore => ignore
  #   return
  # end
end

#run_notebook ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3506

def run_notebook

  begin
    verify_logged_in(true)
    log_start(__method__, args, options)

    project_dir = is_cnvrg_dir()

    notebook_dir = options["notebook_dir"]
    remote = options["remote"] || false
    kernel = options["kernel"] || ""
    notebooks_pid = nil

    if notebook_dir.empty?
      notebook_dir = project_dir
    else

      notebook_dir = project_dir+ notebook_dir
    end
    choose_image = options["image"]

    if !choose_image.nil? and !choose_image.empty?
      invoke :set_image, [choose_image]
    end

    image = is_project_with_docker(Dir.pwd)
    if !image
      jupyter_installed = `which jupyter`
      if !$?.success?
        say "Could not find jupyter, Is it installed?", Thor::Shell::Color::RED
        exit(1)
      end


      cmd = "jupyter-notebook --port=8888"
      PTY.spawn(cmd) do |stdout, stdin, pid, stderr|
        begin
          notebooks_pid = pid
          stdout.each do |line|
            puts line

          end

        rescue Errno::EIO => e
          # break
        rescue Errno::ENOENT
          log_end(1, "command #{cmd} isn't valid")


          say "command \"#{cmd}\" couldn't be executed, verify command is valid", Thor::Shell::Color::RED
        rescue PTY::ChildExited
          log_end(1, "proccess exited")
          say "The process exited!", Thor::Shell::Color::RED
        rescue => e
          log_end(-1, e.message)
          say "Error occurred,aborting", Thor::Shell::Color::RED
          exit(0)

        end


      end

    end

    if image and image.is_docker and !remote
      container= image.get_container
      if !container
        say "Couldn't start docker container", Thor::Shell::Color::RED
        exit(1)

      end

      if options["verbose"]
        say "Syncing project before running", Thor::Shell::Color::BLUE
        say 'Checking for new updates from remote version', Thor::Shell::Color::BLUE
      end
      @project = Project.new(project_dir)

      start_commit = @project.last_local_commit

      if (note_slug=image.note_slug)
        say "There is a running notebook session in: https://cnvrg.io/#{@project.owner}/projects/#{@project.slug}/notebook_sessions/show/#{note_slug}", Thor::Shell::Color::BLUE
        new = yes? "Create a new session?", Thor::Shell::Color::YELLOW
        if !new
          exit(0)
        end

      end
      invoke :sync, [false], :verbose => options["verbose"]
      say "Done Syncing", Thor::Shell::Color::BLUE if options["verbose"]
      #replace url
      base_url = get_base_url()

      local_url = "/#{@project.owner}/projects/#{@project.slug}/notebook_sessions/view/local"
      command = ["/bin/bash", "-lc", "sed -i 's#c.NotebookApp.base_url = .*#c.NotebookApp.base_url = \"#{local_url}\"#' /home/ds/.jupyter/jupyter_notebook_config.py"]
      container.exec(command, tty: true)
      container.stop()
      container.start()
      sleep(7)
      @note = Experiment.new(@project.owner, @project.slug)
      port = image.container_port()

      command = ["/bin/bash", "-lc", "jupyter notebook list"]
      list = container.exec(command, tty: true)[0]
      if list.empty? or list.nil?
        say "Couldn't start notebook server", Thor::Shell::Color::RED
        log_end(1, "can't start notebook server")
        exit(1)
      end

      result = ""
      list.each do |r|
        if r.include? "http"
          result = r
        end
      end
      token = result.to_s.split("::")[0].to_s.match(/(token=)(.+)\s/)[2]

      # machine_activity = @note.get_machine_activity(project_dir)


      slug = @note.start_notebook_session(kernel, start_commit, token, port, false, notebook_dir)
      image.set_note_url(slug)
      note_url = "http://localhost:#{port}/#{@project.owner}/projects/#{@project.slug}/notebook_sessions/view/local/?token=#{token}"


      if !note_url.empty?
        check = Helpers.checkmark()

        say "#{check} Notebook server started successfully", Thor::Shell::Color::GREEN
        Launchy.open(note_url)
      else
        say "Couldn't start notebook server", Thor::Shell::Color::RED
        log_end(1, "can't start notebook server")
        exit(1)
      end
    end


  rescue => e
    log_end(-1, e.message)
    say "Error occurred, aborting", Thor::Shell::Color::RED
    if container
      container.stop()
    end
  rescue SignalException
    if !notebooks_pid.nil?
      ::Process.kill(0, notebooks_pid)
      say "#{check} Notebook has stopped successfully", Thor::Shell::Color::GREEN


      invoke :sync, [false], []
    else
      log_end(-1)

      if container
        container.stop()
      end
    end

  end


end

#search_libraries(library) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3380

def search_libraries(library)
  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    project_dir = is_cnvrg_dir()

    image = is_project_with_docker(project_dir)
    if image and image.is_docker
      container= image.get_container
      if !container
        say "Couldn't create container with image #{image.image_name}:#{image.image_tag}", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Project is not configured with any image", Thor::Shell::Color::RED
      exit(1)

    end

    say "Searching for #{library}", Thor::Shell::Color::BLUE
    pip_arr = image.get_installed_packages("python")
    pip_arr = pip_arr.map(&:downcase)
    check = Helpers.checkmark()
    if !(p = pip_arr.map { |x| x.split("==")[0] }.index(library.downcase)).nil?

      say "#{check} Found it!", Thor::Shell::Color::GREEN


      printf "%-40s %-30s\n", "#{pip_arr[p].split("==")[0]}", "#{pip_arr[p].split("==")[1]}"

    else
      dpkg_arr = image.get_installed_packages("system")
      dpkg_arr = dpkg_arr.map(&:downcase)
      if !(p = dpkg_arr.map { |x| x.split("==")[0] }.index(library.downcase)).nil?
        say "#{check} Found!", Thor::Shell::Color::GREEN

        printf "%-40s %-30s\n", "#{dpkg_arr[p].split("==")[0]}", "#{dpkg_arr[p].split("==")[1]}"
      else
        say "Couldn't find #{library}, run cnvrg install_libraries to install", Thor::Shell::Color::RED
        exit(1)
      end


    end
  rescue => e
    log_end(-1, e.message)
    say "Error occurred, aborting", Thor::Shell::Color::RED
    if container
      container.stop()
    end
  rescue SignalException
    log_end(-1)
    if container
      container.stop()
    end
    say "Aborting"
    exit(1)
  end
end

#set_api_url(url) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 197

def set_api_url(url)
  home_dir = File.expand_path('~')
  if !url.end_with? "/api"
    url = url+"/api"
  end
  begin
    if !File.directory? home_dir+"/.cnvrg"
      FileUtils.mkdir_p([home_dir+"/.cnvrg", home_dir+"/.cnvrg/tmp"])
    end
    if !File.exist?(home_dir+"/.cnvrg/config.yml")
      FileUtils.touch [home_dir+"/.cnvrg/config.yml"]
    end
    compression_path = "#{File.expand_path('~')}/.cnvrg/tmp"

    begin
      config = YAML.load_file(home_dir+"/.cnvrg/config.yml")
      if !config
        config = {owner: "", username: "", version_last_check: get_start_day(), api: url, compression_path: compression_path, }

      end
    rescue
      config = {owner: "", username: "", version_last_check: get_start_day(), api: url, compression_path: compression_path  }
    end
    owner = config.to_h[:owner]

    say "Setting default api to be: #{url}", Thor::Shell::Color::BLUE
    if config.empty?
      config = {owner: "", username: "", version_last_check: get_start_day(), api: url, compression_path: compression_path }
    else
      if !config.to_h[:compression_path].nil?
        compression_path = config.to_h[:compression_path]
      end
      config = {owner: config.to_h[:owner], username: config.to_h[:username], version_last_check: config.to_h[:version_last_check], api: url, compression_path: compression_path}
    end
    # res = Cnvrg::API.request("/users/#{owner}/custom_api", 'POST', {custom_api: url})
    # if Cnvrg::CLI.is_response_success(res, false)

    checks = Helpers.checkmark


    File.open(home_dir+"/.cnvrg/config.yml", "w+") { |f| f.write config.to_yaml }
    say "#{checks} Done", Thor::Shell::Color::GREEN
      # else
      #   say "Couldn't set default api, contact [email protected]", Thor::Shell::Color::RED
      #   exit(1)
      #
      # end

  rescue => e
    say "Couldn't set default api, contact [email protected]", Thor::Shell::Color::RED
  end
end

#set_compression_path(*compression_path) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 371

def set_compression_path(*compression_path)
  begin
    if (compression_path.nil? or compression_path.empty?) and options["reset"]
      compression_path = ["#{File.expand_path('~')}/.cnvrg/tmp"]
    end
    compression_path = compression_path.join(" ")
    if !Dir.exist? compression_path
      say "Couldn't find #{compression_path}, please make sure it exist", Thor::Shell::Color::RED
      exit(0)
    end

    home_dir = File.expand_path('~')
    path = "#{home_dir}/.cnvrg/config.yml"
    if !File.exist?(path)
      say "Couldn't find ~/.cnvrg/config.yml file, please logout and login again", Thor::Shell::Color::RED

      exit(0)
    end
    config = YAML.load_file(path)
    config_new = {owner: config.to_h[:owner], username: config.to_h[:username],
                  version_last_check: config.to_h[:version_last_check], api: config.to_h[:api], compression_path: compression_path}
    File.open(home_dir+"/.cnvrg/config.yml", "w+") { |f| f.write config_new.to_yaml }
    checks = Helpers.checkmark
    say "#{checks} Done", Thor::Shell::Color::GREEN

  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#set_default_owner ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 305

def set_default_owner
  begin
    path = File.expand_path('~')+"/.cnvrg/config.yml"
    if !File.exist?(path)
      say "Couldn't find ~/.cnvrg/config.yml file, please logout and login again", Thor::Shell::Color::RED

      exit(0)
    end
    config = YAML.load_file(path)

    username = config.to_h[:username]
    res = Cnvrg::API.request("/users/#{username}/get_possible_owners", 'GET')
    if Cnvrg::CLI.is_response_success(res)
      owner = username
      result = res["result"]
      owners = result["owners"]
      urls = result["urls"]
      choose_owner = result["username"]
      if owners.empty?
      else
        owners << choose_owner
        chosen = false
        while !chosen
          owners_id = owners.each_with_index.map { |x, i| "#{i+1}. #{x}" }
          choose_owner = ask("Choose default owner:\n"+owners_id.join("\n")+"\n")

          if choose_owner =~ /[[:digit:]]/
            ow_index = choose_owner.to_i-1
            if ow_index<0 or ow_index >= owners.size
              say "No such owner, please choose again", Thor::Shell::Color::BLUE
              chosen = false
              next
            end
            choose_owner = owners[choose_owner.to_i-1]
            chosen = true

          else

            owners_lower = owners.map { |o| o.downcase }
            ow_index = owners_lower.index(choose_owner.downcase)
            if ow_index.nil?
              say "Could not find owner named #{choose_owner}", Thor::Shell::Color::RED
            else
              chosen = true
            end
          end

        end


      end
      if set_owner(choose_owner, result["username"], urls[ow_index])
        say "Setting default owner: #{choose_owner}", Thor::Shell::Color::GREEN
      else
        say "Setting default owenr has failed, try to run cnvrg --config-default-owner", Thor::Shell::Color::RED
      end
    end
  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#set_image(docker_image) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 638

def set_image(docker_image)
  verify_logged_in(false)
  log_start(__method__, args, options)
  working_dir = is_cnvrg_dir
  local_images = Docker::Image.all
  docker_image_local = local_images.map { |x| x.info["RepoTags"] }.flatten.select { |y| y.include? docker_image }.flatten
  if docker_image_local.size == 0

    if yes? "Image wasn't found locally, pull image from cnvrg repository?", Thor::Shell::Color::YELLOW
      image = pull(docker_image)
      if image
        say "downloaded image: #{docker_image}"
        @image = Images.new(working_dir, docker_image)
      else
        say "Could not set image, image was not found", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Could nset image, image was not found", Thor::Shell::Color::RED
      exit(1)

    end
  elsif docker_image_local.size == 1
    say "found image: #{docker_image_local[0]}, setting it up..", Thor::Shell::Color::BLUE
    @image = Images.new(working_dir, docker_image_local[0])
  elsif docker_image_local.size >1
    say "found #{docker_image_local.size} images, choose the image name you want to use", Thor::Shell::Color::BLUE
    image_name = ask "#{docker_image_local.join("\n")}\n", Thor::Shell::Color::BLUE
    image_name = image_name.strip
    @image = Images.new(working_dir, image_name)
  end
  @image.update_image_activity(nil, nil)

end

#set_remote_api_url(owner, current_user, url) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 278

def set_remote_api_url(owner, current_user, url)
  home_dir = File.expand_path('~')
  if !url.end_with? "/api"
    url = url+"/api"
  end
  begin
    if !File.directory? home_dir+"/.cnvrg"
      FileUtils.mkdir_p([home_dir+"/.cnvrg", home_dir+"/.cnvrg/tmp"])
    end
    if !File.exist?(home_dir+"/.cnvrg/config.yml")
      FileUtils.touch [home_dir+"/.cnvrg/config.yml"]
    end
    config = YAML.load_file(home_dir+"/.cnvrg/config.yml")

    compression_path = "#{home_dir}/.cnvrg/tmp"
    config = {owner: owner, username: current_user, version_last_check: get_start_day(), api: url, compression_path: compression_path}
    File.open(home_dir+"/.cnvrg/config.yml", "w+") { |f| f.write config.to_yaml }
    say "Done"
  rescue
    say "ERROR", Thor::Shell::Color::RED
  end
end

#set_remote_login(current_user, owner, url, email, secret) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 251

def set_remote_login(current_user,owner,url, email, secret)
  netrc = Netrc.read
  netrc[Cnvrg::Helpers.netrc_domain] = email, secret
  netrc.save
  home_dir = File.expand_path('~')
  if !url.end_with? "/api"
    url = url+"/api"
  end
  begin
    if !File.directory? home_dir+"/.cnvrg"
      FileUtils.mkdir_p([home_dir+"/.cnvrg", home_dir+"/.cnvrg/tmp"])
    end
    if !File.exist?(home_dir+"/.cnvrg/config.yml")
      FileUtils.touch [home_dir+"/.cnvrg/config.yml"]
    end
    config = YAML.load_file(home_dir+"/.cnvrg/config.yml")

    compression_path = "#{home_dir}/.cnvrg/tmp"
    config = {owner: owner, username: current_user, version_last_check: get_start_day(), api: url, compression_path: compression_path}
    File.open(home_dir+"/.cnvrg/config.yml", "w+") { |f| f.write config.to_yaml }
    say "Done"
  rescue
    say "ERROR", Thor::Shell::Color::RED
  end
end

#show_libraries ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 3443

def show_libraries
  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    system = options["system"] || false


    project_dir = is_cnvrg_dir()

    image = is_project_with_docker(project_dir)
    if image and image.is_docker
      container = image.get_container
      if !container
        say "Couldn't create container with image #{image.image_name}:#{image.image_tag}", Thor::Shell::Color::RED
        exit(1)
      end
    else
      say "Project is not configured with any image", Thor::Shell::Color::RED
      exit(1)

    end

    say "Showing python installed libraries", Thor::Shell::Color::BLUE
    pip_arr = image.get_installed_packages("python")
    printf "%-40s %-30s\n", "name", "version"
    printf "%-40s %-30s\n", "====", "======="

    pip_arr.each do |p|

      printf "%-40s %-30s\n", "#{p.split("==")[0]}", "#{p.split("==")[1]}"
    end
    if system

      say "Showing system installed libraries", Thor::Shell::Color::BLUE
      dpkg_arr = image.get_installed_packages("system")
      printf "%-40s %-30s\n", "name", "version"
      printf "%-40s %-30s\n", "====", "======="
      dpkg_arr.each do |p|
        printf "%-40s %-30s\n", "#{p.split("==")[0]}", "#{p.split("==")[1]}"

      end
    end
  rescue => e
    log_end(-1, e.message)
    say "Error occurred, aborting"
    if container
      container.stop()
    end
  rescue SignalException
    log_end(-1)
    say "Aborting"
    exit(1)
  end
end

#snap_data ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 882

def snap_data
  begin
    verify_logged_in(false)
    log_start(__method__, args, options)

    owner = CLI.get_owner
    path = Dir.pwd
    @dataset = Dataset.new(path)

    log_end(0)

  rescue SignalException
    log_end(-1)

    say "\nAborting"
    exit(1)
  end
end

#status ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1620

def status
  begin
    verify_logged_in()
    log_start(__method__, args, options)
    @project = Project.new(get_project_home)
    new_branch = options["new_branch"] || false
    force = options["force"] || false

    result = @project.compare_idx(new_branch,force:force)["result"]
    commit = result["commit"]
    result = result["tree"]
    log_message("Comparing local changes with remote version:", Thor::Shell::Color::BLUE)

    if result["added"].empty? and result["updated_on_local"].empty? and result["updated_on_server"].empty? and result["deleted"].empty? and result["conflicts"].empty?
      log_message("Project is up to date", Thor::Shell::Color::GREEN)
      return true
    end
    if result["added"].size > 0
      log_message("Added files:\n", Thor::Shell::Color::BLUE)
      result["added"].each do |a|
        log_message("\t\tA:\t#{a}", Thor::Shell::Color::GREEN)
      end
    end

    if result["deleted"].size > 0
      log_message("Deleted files:\n", Thor::Shell::Color::BLUE)
      result["deleted"].each do |a|
        log_message("\t\tD:\t#{a}", Thor::Shell::Color::GREEN)
      end
    end
    if result["updated_on_local"].size > 0
      log_message("Local changes:\n", Thor::Shell::Color::BLUE)
      result["updated_on_local"].each do |a|
        log_message("\t\tM:\t#{a}", Thor::Shell::Color::GREEN)
      end
    end

    if result["updated_on_server"].size > 0
      log_message("Remote changes:\n", Thor::Shell::Color::BLUE)
      result["updated_on_server"].each do |a|
        log_message("\t\tM:\t#{a}", Thor::Shell::Color::GREEN)
      end
    end

    if result["conflicts"].size > 0
      log_message("Conflicted changes:\n", Thor::Shell::Color::BLUE)
      result["conflicts"].each do |a|
        log_message("\t\tC:\t#{a}", Thor::Shell::Color::RED)
      end
    end
  rescue SignalException
    say "\nAborting"
    exit(1)
  end
end

#stop_container(container_id) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4252

def stop_container(container_id)
  container = Docker::Container.get(container_id)
  container.stop()
  container.remove()

end

#sync(direct = true) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 2331

def sync(direct=true)
  verify_logged_in(true) if direct
  log_start(__method__, args, options)
  log_message('Checking for new updates from remote version', Thor::Shell::Color::BLUE, options["verbose"])
  log_message('Syncing project', Thor::Shell::Color::BLUE, !options["verbose"])
  if !options[:force]
    invoke :download, [], :new_branch => options["new_branch"], :verbose => options["verbose"], :sync => true
  end


  invoke :upload, [link=false, sync=true, direct=direct], :new_branch => options["new_branch"], :verbose => options["verbose"], :sync => true,
         :ignore => options[:ignore], :force=> options[:force]


end

#sync_image(docker = false) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4086

def sync_image(docker=false)
  verify_logged_in(true)
  log_start(__method__, args, options)
  is_public = options["is_public"] || false
  is_base = options["is_base"] || false
  message = options["message"] || ""
  image_id = commit_image

  if docker
    message = "before running experiment"
    image = is_project_with_docker(Dir.pwd)
    if image and image.is_docker
      container = image.get_container
      if !container

        upload_image(image_id, is_public, is_base, message)
      else
        command = ["/bin/bash", "-lc", "cnvrg upload_image #{image_id} #{is_public} #{is_base} #{message}"]
        puts "Running in contianer"
        container.exec(command, detach: false)
      end
    end

  else
    upload_image(image_id, is_public, is_base, message)
  end

end

#tensor_port_container(container_id) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4245

def tensor_port_container(container_id)
  container = Docker::Container.get(container_id)
  say container.json["HostConfig"]["PortBindings"]["6006/tcp"][0]["HostPort"]
end

#test ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 163

def test
  # image_settings = {
  #     'Image' => "cnvrg:latest",
  #     'User' => 'ds',
  #     'Cmd' => '/home/ds/run_ipython.sh',
  #     'ExposedPorts' => {
  #         '80/tcp' => {},
  #     },
  #     'HostConfig' => {
  #         'PortBindings' => {
  #             '80/tcp' => [
  #                 {'HostPort' => "7654", 'HostIp' => 'localhost'}
  #             ],
  #         },
  #     },
  # }
  # container = Docker::Container.get('b4d64bf83f41')
  # s = "/leah/1/2/3/4/5"
  # command = ["/bin/bash","-lc","sed -i 's#c.NotebookApp.base_url = .*#c.NotebookApp.base_url = \"#{s}\"#' /home/ds/.jupyter/jupyter_notebook_config.py"]
  # puts container.exec(command, tty: true)
end

#unlink ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1456

def unlink
  verify_logged_in(false)
  log_start(__method__, args, options)
  working_dir = is_cnvrg_dir()
  list_to_del = [working_dir+"/.cnvrgignore", working_dir+"/.cnvrg"]
  FileUtils.rm_rf list_to_del
end

#upload(link = false, sync = false, direct = false, ignore_list = "") ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1707

def upload(link=false, sync=false, direct=false, ignore_list="")

  begin
    verify_logged_in(true)
    log_start(__method__, args, options)

    @project = Project.new(get_project_home)

    @files = Cnvrg::Files.new(@project.owner, @project.slug)
    ignore = options[:ignore] || ""
    force = options[:force] || false

    if ignore.nil? or ignore.empty?
      ignore = ignore_list
    end
    data_ignore = data_dir_include()
    if !data_ignore.nil?
      if ignore.nil? or ignore.empty?
        ignore = data_ignore
      else
        ignore ="#{ignore},#{data_ignore}"
      end
    end
    if !@project.update_ignore_list(ignore)
      log_message("Couldn't append new ignore files to .cnvrgignore", Thor::Shell::Color::YELLOW)
    end
    new_branch = options["new_branch"] || false

    if options["sync"] or sync
      new_branch_exp = @project.get_new_branch
      if new_branch_exp
        new_branch = new_branch_exp
      end
    end

    result = @project.compare_idx(new_branch,force:force)
    commit = result["result"]["commit"]
    if !link
      if ((commit != @project.last_local_commit and !@project.last_local_commit.nil? and !result["result"]["tree"]["updated_on_server"].empty?) and !force )

        log_message("Remote server has an updated version, please run `cnvrg download` first, or alternatively: `cnvrg sync`", Thor::Shell::Color::BLUE)
        exit(1)
      end

      log_message("Comparing local changes with remote version:", Thor::Shell::Color::BLUE, (options["verbose"]))
    end
    result = result["result"]["tree"]
    # if result["added"].any? {|x| x.include? ".conflict"} or !result["conflicts"].empty?
    #   all = result["added"].select {|x| x.include? ".conflict"} +result["conflicts"].flatten
    #   if all.size == 1
    #     num = "conflict"
    #   else
    #     num =  "conflicts"
    #   end
    #   say "Project contains #{all.size} #{num}:", Thor::Shell::Color::RED
    #   say "#{all.join("\n")}"
    #   say "Please fix #{num}, and retry", Thor::Shell::Color::RED
    #   exit(1)
    #
    # end
    check = Helpers.checkmark()
    if result["added"].empty? and result["updated_on_local"].empty? and result["deleted"].empty?
      log_message("#{check} Project is up to date", Thor::Shell::Color::GREEN, (((options["sync"] or sync) and !direct) ? false : true))
      return true
    end
    update_count = 0
    update_total = result["added"].size + result["updated_on_local"].size + result["deleted"].size
    successful_updates = []
    successful_deletions = []
    if options["verbose"]
      if update_total == 1
        log_message("Updating #{update_total} file", Thor::Shell::Color::BLUE)
      else
        log_message("Updating #{update_total} files", Thor::Shell::Color::BLUE)
      end
    else
      log_message("Syncing files", Thor::Shell::Color::BLUE, ((options["sync"] or sync)) ? false : true)

    end
    # Start commit
    commit_sha1 = @files.start_commit(new_branch,force:force)["result"]["commit_sha1"]

    # upload / update
    begin

      parallel_options = {
          :progress => {
              :title => "Upload Progress",
              :progress_mark => '=',
              :format => "%b>>%i| %p%% %t",
              :starting_at => 0,
              :total => (result["added"] + result["updated_on_local"]).size,
              :autofinish => true
          },
          in_processes: ParallelProcesses,
          in_thread: ParallelThreads,
          isolation: true
      }
      if (result["added"] + result["updated_on_local"]).size > 0

        begin
          upload_result = Parallel.map((result["added"] + result["updated_on_local"]), parallel_options) do |f|
            absolute_path = "#{@project.local_path}/#{f}"
            relative_path = f.gsub(/^#{@project.local_path + "/"}/, "")
            if File.directory?(absolute_path)
              log_message("uploading dir: #{f}", Thor::Shell::Color::BLUE, options["verbose"])

              resDir = @files.create_dir(absolute_path, relative_path, commit_sha1)
              if resDir
                f
                # progressbar.increment
                update_count += 1
                successful_updates<< relative_path
              else
                log_message("Failed to upload directory: #{ relative_path }", Thor::Shell::Color::RED)

                raise Parallel::Kill
              end

            else
              log_message("uploading: #{f}", Thor::Shell::Color::BLUE, options["verbose"])

              res = @files.upload_file(absolute_path, relative_path, commit_sha1)
              if res
                f
                update_count += 1

                successful_updates<< relative_path
              else
                log_message("Failed to upload: #{ File.basename(absolute_path) }", Thor::Shell::Color::RED)

                raise Parallel::Kill

              end
            end
          end
        rescue SignalException
          log_message("Couldn't upload, Rolling Back all changes.", Thor::Shell::Color::RED)
          @files.rollback_commit(commit_sha1)

          exit(1)
        end
      end


      successful_updates = upload_result.to_a


      # delete

      deleted = update_deleted(result["deleted"])
      begin

        deleted_result = Parallel.map(deleted, in_processes: ParallelProcesses, in_thread: ParallelThreads) do |f|

          relative_path = f.gsub(/^#{@project.local_path + "/"}/, "")
          if relative_path.end_with?("/")
            log_message("deleting dir: #{f}", Thor::Shell::Color::RED, options["verbose"])

            if @files.delete_dir(f, relative_path, commit_sha1)
              f
            else
              log_message("Failed to delete directory: #{ f }", Thor::Shell::Color::RED)

            end
          else
            log_message("deleteing file: #{f}", Thor::Shell::Color::RED, options["verbose"])

            if @files.delete_file(f, relative_path, commit_sha1)
              f
            else
              log_message("Failed to delete file: #{ f }", Thor::Shell::Color::RED)

            end
          end
        end
      rescue Interrupt
        log_message("Couldn't upload, Rolling Back all changes.", Thor::Shell::Color::RED)
        @files.rollback_commit(commit_sha1)

        exit(1)

      end


      successful_deletions += successful_deletions.select { |x| not x.nil? }


      successful_updates = successful_updates.select { |x| not x.nil? }

      update_count = successful_updates.size

    rescue SignalException
      @files.rollback_commit(commit_sha1)
      say "User aborted, Rolling Back all changes.", Thor::Shell::Color::RED
      exit(0)
    rescue => e
      @files.rollback_commit(commit_sha1)
      log_message("Exception while trying to upload, Rolling back", Thor::Shell::Color::RED)
      log_error(e)
      exit(0)
    end
    if !result["deleted"].nil? and !result["deleted"].empty?
      update_count += result["deleted"].size
    end

    if update_count == update_total
      res = @files.end_commit(commit_sha1,force:force)
      if (Cnvrg::CLI.is_response_success(res, false))
        # save idx
        begin
          @project.update_idx_with_files_commits!((successful_deletions+successful_updates), res["result"]["commit_time"])

          @project.update_idx_with_commit!(commit_sha1)
        rescue => e
          @files.rollback_commit(commit_sha1)
          log_message("Couldn't commit updates, Rolling Back all changes.", Thor::Shell::Color::RED)
          log_error(e)
          exit(1)

        end
        image = is_project_with_docker(Dir.pwd)
        if image and image.is_docker
          image.update_image_activity(commit_sha1, nil)
        end

        if options["verbose"]
          log_message("#{check} Done", Thor::Shell::Color::BLUE)
          if successful_updates.size >0
            successful_updates.flatten!
            log_message("Updated:", Thor::Shell::Color::GREEN)
            suc = successful_updates.map { |x| x=Helpers.checkmark() +" "+x }
            log_message(suc.join("\n"), Thor::Shell::Color::GREEN)
          end
          if successful_deletions.size >0
            successful_deletions.flatten!

            log_message("Deleted:", Thor::Shell::Color::GREEN)
            del = successful_updates.map { |x| x=Helpers.checkmark() +" "+x }
            log_message(del.join("\n"), Thor::Shell::Color::GREEN)
          end
          log_message("Total of #{update_count} / #{update_total} files.", Thor::Shell::Color::GREEN)
        else
          if (options["sync"] or sync) and direct
            log_message("#{check} Syncing project completed successfully", Thor::Shell::Color::GREEN)

          else
            log_message("#{check} Changes were updated successfully", Thor::Shell::Color::GREEN)

          end

        end

      else
        @files.rollback_commit(commit_sha1)
        log_message("Error: couldn't commit changes,  Rolling Back all changes.", Thor::Shell::Color::RED)
      end
    else
      log_message("Error: uploaded only: #{update_count} / #{update_total}, \n Rolling back", Thor::Shell::Color::RED)

    end
  rescue => e

    log_message("Error occurred, \nAborting", Thor::Shell::Color::RED)
    log_error(e)
    @files.rollback_commit(commit_sha1) unless commit_sha1.nil?
    puts e.message

    exit(1)
  rescue SignalException

    say "\nAborting", Thor::Shell::Color::BLUE
    say "\nRolling back all changes", Thor::Shell::Color::BLUE
    @files.rollback_commit(commit_sha1) unless commit_sha1.nil?
    exit(1)
  end

end

#upload_cnvrg_image(image_path, image_name, secret) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4500

def upload_cnvrg_image(image_path,image_name,secret)
  begin
  verify_logged_in(false)

  @files = Cnvrg::Files.new("", "")
  say "Uploading cnvrg  image file", Thor::Shell::Color::BLUE

  res = @files.upload_cnvrg_image(image_path, image_name, secret)
  if res
    say "Successfully uploaded cnvrg image file", Thor::Shell::Color::GREEN

  else
    say "Couldn't upload cnvrg image file", Thor::Shell::Color::RED
  end
  rescue => e
    puts e
    puts e.backtrace
  end


end

#upload_data(sync = false, direct = false) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1035

def upload_data(sync=false, direct=false)

  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    dataset_dir = is_cnvrg_dir(Dir.pwd)
    @dataset = Dataset.new(dataset_dir)

    @files = Cnvrg::Datafiles.new(@dataset.owner, @dataset.slug)
    ignore = options[:ignore] || []
    if !@dataset.update_ignore_list(ignore)
      log_message("Couldn't append new ignore files to .cnvrgignore", Thor::Shell::Color::YELLOW)
    end
    result = @dataset.compare_idx(false)

    commit = result["result"]["commit"]
    if commit != @dataset.last_local_commit and !@dataset.last_local_commit.nil? and !result["result"]["tree"]["updated_on_server"].empty?

      log_message("Remote server has an updated version, please run `cnvrg download` first, or alternatively: `cnvrg sync`", Thor::Shell::Color::BLUE)
      exit(1)
    end

    log_message("Comparing local changes with remote version:", Thor::Shell::Color::BLUE, options["verbose"] ? true : false)
    result = result["result"]["tree"]
    # if result["added"].any? {|x| x.include? ".conflict"} or !result["conflicts"].empty?
    #   all = result["added"].select {|x| x.include? ".conflict"} +result["conflicts"].flatten
    #   if all.size == 1
    #     num = "conflict"
    #   else
    #     num =  "conflicts"
    #   end
    #   say "Project contains #{all.size} #{num}:", Thor::Shell::Color::RED
    #   say "#{all.join("\n")}"
    #   say "Please fix #{num}, and retry", Thor::Shell::Color::RED
    #   exit(1)
    #
    # end
    check = Helpers.checkmark()

    if result["added"].empty? and result["updated_on_local"].empty? and result["deleted"].empty?
      log_message("#{check} Dataset is up to date", Thor::Shell::Color::GREEN, (((options["sync"] or sync) and !direct) ? false : true))
      return true
    end
    update_count = 0
    update_total = result["added"].size + result["updated_on_local"].size + result["deleted"].size
    successful_updates = []
    successful_deletions = []
    if options["verbose"]
      if update_total == 1
        log_message("Updating #{update_total} file", Thor::Shell::Color::BLUE)
      else
        log_message("Updating #{update_total} files", Thor::Shell::Color::BLUE)
      end
    else
      log_message("Syncing files", Thor::Shell::Color::BLUE, ((options["sync"] or sync)) ? false : true)

    end

    # Start commit

    commit_sha1 = @files.start_commit(false)["result"]["commit_sha1"]
    # upload / update
    begin
      (result["added"] + result["updated_on_local"]).each do |f|
        absolute_path = "#{@dataset.local_path}/#{f}"
        relative_path = f.gsub(/^#{@dataset.local_path + "/"}/, "")
        if File.directory?(absolute_path)
          resDir = @files.create_dir(absolute_path, relative_path, commit_sha1)
          if resDir
            update_count += 1
            successful_updates<< relative_path
          end
        else
          res = @files.upload_file(absolute_path, relative_path, commit_sha1)

          if res
            update_count += 1
            successful_updates<< relative_path
          else
            @files.rollback_commit(commit_sha1)
            log_message("Couldn't upload, Rolling Back all changes.", Thor::Shell::Color::RED)
            exit(0)
          end
        end
      end

      # delete
      deleted = update_deleted(result["deleted"])
      deleted.each do |f|
        relative_path = f.gsub(/^#{@dataset.local_path + "/"}/, "")
        if relative_path.end_with?("/")
          if @files.delete_dir(f, relative_path, commit_sha1)
            # update_count += 1
            successful_updates<< relative_path
          end
        else
          if @files.delete_file(f, relative_path, commit_sha1)
            # update_count += 1
            successful_updates<< relative_path
          end
        end
      end

    rescue SignalException
      @files.rollback_commit(commit_sha1)
      say "User aborted, Rolling Back all changes.", Thor::Shell::Color::RED
      exit(0)
    rescue => e
      log_message("Exception while trying to upload, Rolling back", Thor::Shell::Color::RED)
      log_error(e)
      @files.rollback_commit(commit_sha1)
      exit(0)
    end
    if !result["deleted"].nil? and !result["deleted"].empty?
      update_count += result["deleted"].size
    end
    if update_count == update_total
      res = @files.end_commit(commit_sha1)
      if (Cnvrg::CLI.is_response_success(res, false))
        # save idx
        begin
          @dataset.update_idx_with_files_commits!((successful_deletions+successful_updates), res["result"]["commit_time"])

          @dataset.update_idx_with_commit!(commit_sha1)
        rescue => e
          log_message("Couldn't commit updates, Rolling Back all changes.", Thor::Shell::Color::RED)
          log_error(e)
          @files.rollback_commit(commit_sha1)
          exit(1)

        end
        if options["verbose"]
          log_message("#{check} Done", Thor::Shell::Color::BLUE)
          if successful_updates.size >0
            log_message("Updated:", Thor::Shell::Color::GREEN)
            suc = successful_updates.map { |x| x=Helpers.checkmark() +" "+x }
            log_message(suc.join("\n"), Thor::Shell::Color::GREEN)
          end
          if successful_deletions.size >0
            log_message("Deleted:", Thor::Shell::Color::GREEN)
            del = successful_updates.map { |x| x=Helpers.checkmark() +" "+x }
            log_message(del.join("\n"), Thor::Shell::Color::GREEN)
          end
          log_message("Total of #{update_count} / #{update_total} files.", Thor::Shell::Color::GREEN)
        else
          if (options["sync"] or sync) and direct
            log_message("#{check} Syncing dataset completed successfully", Thor::Shell::Color::GREEN)

          else
            log_message("#{check} Changes were updated successfully", Thor::Shell::Color::GREEN)

          end

        end

      else
        @files.rollback_commit(commit_sha1)
        log_message("Error: Couldn't commit. \nRolling Back all changes.", Thor::Shell::Color::RED)
      end
    else
      log_message("Error: Uploaded only #{update_count}/#{update_total} files, \nRolling back", Thor::Shell::Color::RED)

      @files.rollback_commit(commit_sha1)
    end
  rescue => e
    log_message("Error occurd, \nAborting", Thor::Shell::Color::RED)
    log_error(e)

    @files.rollback_commit(commit_sha1)
    exit(1)
  rescue SignalException

    say "\nAborting", Thor::Shell::Color::BLUE
    say "\nRolling back all changes", Thor::Shell::Color::BLUE
    @files.rollback_commit(commit_sha1)
    exit(1)
  end

end

#upload_data_tar(ignore, verbose, sync, no_compression) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 1222

def upload_data_tar(ignore, verbose, sync, no_compression)

  begin
    verify_logged_in(true)
    log_start(__method__, args, options)
    dataset_dir = is_cnvrg_dir(Dir.pwd)

    @dataset = Dataset.new(dataset_dir)

    @files = Cnvrg::Datafiles.new(@dataset.owner, @dataset.slug)
    if !@dataset.update_ignore_list(ignore)
      log_message("Couldn't append new ignore files to .cnvrgignore", Thor::Shell::Color::RED)
      exit(1)
    end
    log_message("Checking dataset", Thor::Shell::Color::BLUE)
    local_idx = @dataset.generate_idx
    result = @dataset.compare_idx(false, commit=@dataset.last_local_commit, local_idx= local_idx)


    commit = result["result"]["commit"]
    if commit != @dataset.last_local_commit and !@dataset.last_local_commit.nil? and !result["result"]["tree"]["updated_on_server"].empty?

      log_message("Remote server has an updated version, please run `cnvrg data download` first", Thor::Shell::Color::BLUE)
      exit(1)
    end

    log_message("Comparing local changes with remote version:", Thor::Shell::Color::BLUE, verbose)
    result = result["result"]["tree"]
    check = Helpers.checkmark()

    if result["added"].empty? and result["updated_on_local"].empty? and result["deleted"].empty?
      log_message("#{check} Dataset is up to date", Thor::Shell::Color::GREEN, (sync ? false : true))
      return true
    end
    update_count = 0
    update_total = result["added"].size + result["updated_on_local"].size + result["deleted"].size
    successful_updates = []
    successful_deletions = []

    # Start commit
    res = @files.start_commit(false)["result"]
    commit_sha1 =res["commit_sha1"]
    commit_time = res["commit_time"]
    # upload / update
    begin
      (result["added"] + result["updated_on_local"]).each do |f|
        relative_path = f.gsub(/^#{@dataset.local_path + "/"}/, "")
        successful_updates<< relative_path
        update_count += 1
      end

      # delete
      deleted = update_deleted(result["deleted"])
      deleted.each do |f|
        relative_path = f.gsub(/^#{@dataset.local_path + "/"}/, "")
        successful_updates<< relative_path
      end
      @dataset.update_idx_with_files_commits!((successful_deletions+successful_updates), commit_time)

      @dataset.update_idx_with_commit!(commit_sha1)
      log_message("Compressing data", Thor::Shell::Color::BLUE)

      home_dir = File.expand_path('~')
      compression_path = get_compression_path
      tar_path = "#{compression_path}#{@dataset.slug}_#{commit_sha1}.tar.gz"
      tar_files_path = "#{home_dir}/.cnvrg/tmp/#{@dataset.slug}_#{commit_sha1}.txt"
      tar_files = (result["added"] + result["updated_on_local"]).join("\n")
      File.open(tar_files_path, 'w') { |f| f.write tar_files }
      is_tar = create_tar(dataset_dir, tar_path, tar_files_path, no_compression)
      if !is_tar
        log_message("ERROR: Couldn't compress data", Thor::Shell::Color::RED)
        FileUtils.rm_rf([tar_path]) if File.exist? tar_path
        FileUtils.rm_rf([tar_files_path]) if File.exist? tar_files_path
        @files.rollback_commit(commit_sha1)
        log_message("Rolling Back all changes.", Thor::Shell::Color::RED)
        exit(1)
      end
      log_message("Uploading data", Thor::Shell::Color::BLUE)
      log_file = "#{home_dir}/.cnvrg/tmp/upload_#{File.basename(tar_path)}.log"
      res = false
      res = @files.upload_tar_file(tar_path, tar_path, commit_sha1)

      if res
        log_message("Commiting data", Thor::Shell::Color::BLUE)

        cur_idx = @dataset.get_idx.to_h

        res = @files.end_commit_tar(commit_sha1, cur_idx)
        if !Cnvrg::CLI.is_response_success(res, false)
          FileUtils.rm_rf([tar_files_path]) if File.exist? tar_files_path
          FileUtils.rm_rf([tar_path]) if File.exist? tar_path


          @files.rollback_commit(commit_sha1)
          log_message("Can't commit, Rolling Back all changes.", Thor::Shell::Color::RED)
          exit(1)
        end

      else
        if File.exist? log_file
          @files.upload_data_log_file(log_file, log_file, commit_sha1)
        end


        FileUtils.rm_rf([tar_files_path]) if File.exist? tar_files_path
        FileUtils.rm_rf([tar_path]) if File.exist? tar_path


        @files.rollback_commit(commit_sha1)
        log_message("Can't upload, Rolling Back all changes.", Thor::Shell::Color::RED)
        log_message("Upload error log: #{log_file}", Thor::Shell::Color::RED)

        exit(1)
      end


      # delete
      FileUtils.rm_rf([tar_path, tar_files_path])

    rescue SignalException
      FileUtils.rm_rf([tar_files_path]) if File.exist? tar_files_path
      FileUtils.rm_rf([tar_path]) if File.exist? tar_path
      if File.exist? log_file
        @files.upload_data_log_file(log_file, log_file, commit_sha1)
      end


      @files.rollback_commit(commit_sha1)
      say "User aborted, Rolling Back all changes.", Thor::Shell::Color::RED
      exit(0)
    rescue => e
      log_error(e)
      if !Cnvrg::Helpers.internet_connection?
        say "Seems there is no internet connection", Thor::Shell::Color::RED

      end
      if File.exist? log_file
        @files.upload_data_log_file(log_file, log_file, commit_sha1)
      end
      FileUtils.rm_rf([tar_files_path]) if File.exist? tar_files_path
      FileUtils.rm_rf([tar_path]) if File.exist? tar_path

      @files.rollback_commit(commit_sha1)
      log_message("Exception while trying to upload, \nRolling back,\n look at the log for more details", Thor::Shell::Color::RED)
      log_message("Error log: #{log_file}", Thor::Shell::Color::RED)


      exit(0)
    end
    log_message("#{check} Changes were updated successfully", Thor::Shell::Color::GREEN)


  rescue => e

    puts e.message
    puts e.backtrace
    log_message("Error occurred, \nAborting", Thor::Shell::Color::RED)
    log_error(e)
    @files.rollback_commit(commit_sha1)
    exit(1)
  rescue SignalException

    say "\nAborting", Thor::Shell::Color::BLUE
    say "\nRolling back all changes", Thor::Shell::Color::BLUE
    @files.rollback_commit(commit_sha1)
    exit(1)
  end


end

#upload_image(image_id, is_public, is_base, *message) ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4157

def upload_image(image_id, is_public, is_base, *message)
  verify_logged_in(true)
  log_start(__method__, args, options)
  image = Docker::Image.get(image_id)
  project_home = get_project_home
  @project = Project.new(project_home)
  last_local_commit = @project.last_local_commit
  image_name = @project.slug+"#{last_local_commit}"
  path = File.expand_path('~')+"/.cnvrg/tmp/#{image_name}.tar"
  owner = Cnvrg::CLI.get_owner()
  if !message.nil? or !message.empty?
    message = message.join(" ")
  end

  log_message("Saving image's current state", Thor::Shell::Color::BLUE)
  image.save(path)

  begin
    log_message("Compressing image file to upload", Thor::Shell::Color::BLUE)
    gzipRes = system("gzip -f #{path}")
    if !gzipRes

      log_message("Couldn't create tar file from image", Thor::Shell::Color::RED)
      exit(1)
    end
    path = path+".gz"
    @files = Cnvrg::Files.new(owner, "")

    exit_status = $?.exitstatus
    if exit_status == 0
      log_message("Uploading image file", Thor::Shell::Color::BLUE)

      diff =container_changes(Dir.pwd)
      res = @files.upload_image(path, image_name, owner, is_public, is_base, diff[1], diff[0], diff[2], message, image.commit_id)
      if res
        File.delete(path)
        image_loc = is_project_with_docker(Dir.pwd)
        image_loc.update_slug(res["result"]["id"])

        checks = Helpers.checkmark()
        log_message("#{checks} Done", Thor::Shell::Color::GREEN)
      else
        log_message("Couldn't upload image", Thor::Shell::Color::RED)

      end
    else
      log_message("Couldn't create image file for: #{image_name}", Thor::Shell::Color::RED)
      exit(1)
    end
  rescue => e
    log_message("Couldn't upload image file for: #{image_name}", Thor::Shell::Color::RED)
    log_error(e)
  rescue SignalException

    say "Couldn't upload image file for: #{image_name}", Thor::Shell::Color::RED
    exit(1)
  end
end

#upload_log ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 4218

def upload_log()
  log_path = '/home/ds/app/uwsgi.log'
  loglines = File.new(log_path).readlines
  logs = loglines.select { |x| x.start_with? "cnvrg_app:" }.collect { |x| x.strip }

end

#version ⇒ `Object`

# File 'lib/cnvrg/cli.rb', line 188

def version
  puts Cnvrg::VERSION

end

Class: Cnvrg::CLI

Constant Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.is_thor_reserved_word?(word, type) ⇒ Boolean

Instance Method Details

#build(*cmd) ⇒ Object

#build_image(image_name) ⇒ Object

#clone(project_url) ⇒ Object

#clone_data(dataset_url) ⇒ Object

#commit_image ⇒ Object

#config_flask_remote(image_name, port = 80) ⇒ Object

#config_flask_remote_gpu(image_name, port = 80) ⇒ Object

#config_netrc(container) ⇒ Object

#config_remote(image_name, port = 7654, tensport = 6006) ⇒ Object

#config_remote_gpu(image_name, port = 7654, tensport = 6006) ⇒ Object

#create_volume ⇒ Object

#data_init_container(owner, dataset_slug, dataset_name) ⇒ Object

#data_jump(*commit_sha1) ⇒ Object

#deploy(file_to_run, function) ⇒ Object

#download(sync = false, ignore_list = "") ⇒ Object

#download_built_image(image_name, image_slug) ⇒ Object

#download_cnvrg_image(image_name, secret) ⇒ Object

#download_data(verbose, sync, path = Dir.pwd, in_dir = true) ⇒ Object

#download_image(image_name, image_slug) ⇒ Object

#exec(*cmd) ⇒ Object

#exec_container(container_id, *cmd) ⇒ Object

#exec_docker(*cmd) ⇒ Object

#exec_remote(*cmd) ⇒ Object

#experiments ⇒ Object

#get_machine ⇒ Object

#init_data(public) ⇒ Object

#init_data_container(container) ⇒ Object

#install_python_libraries(*lib) ⇒ Object

#install_system_libraries(*command_to_run) ⇒ Object

#jump(commit_sha1) ⇒ Object

#link ⇒ Object

#list_commits ⇒ Object

#list_dataset ⇒ Object

#list_dataset_commits ⇒ Object

#list_images ⇒ Object

#list_machines ⇒ Object

#login ⇒ Object

#logout ⇒ Object

#me ⇒ Object

#new(project_name) ⇒ Object

#notebook ⇒ Object

#notebook_stop(notebook_slug) ⇒ Object

#port_container(container_id) ⇒ Object

#pull_image(image_name) ⇒ Object

#push(*name) ⇒ Object

#remote_notebook ⇒ Object

#remote_notebook_old ⇒ Object

#revert_exp ⇒ Object

#run(*cmd) ⇒ Object

#run_notebook ⇒ Object

#search_libraries(library) ⇒ Object

#set_api_url(url) ⇒ Object

#set_compression_path(*compression_path) ⇒ Object

#set_default_owner ⇒ Object

#set_image(docker_image) ⇒ Object

#set_remote_api_url(owner, current_user, url) ⇒ Object

#set_remote_login(current_user, owner, url, email, secret) ⇒ Object

#show_libraries ⇒ Object

#snap_data ⇒ Object

#status ⇒ Object

#stop_container(container_id) ⇒ Object

#sync(direct = true) ⇒ Object

#sync_image(docker = false) ⇒ Object

#tensor_port_container(container_id) ⇒ Object

#test ⇒ Object

#unlink ⇒ Object

#upload(link = false, sync = false, direct = false, ignore_list = "") ⇒ Object

#upload_cnvrg_image(image_path, image_name, secret) ⇒ Object

#upload_data(sync = false, direct = false) ⇒ Object

#upload_data_tar(ignore, verbose, sync, no_compression) ⇒ Object

#upload_image(image_id, is_public, is_base, *message) ⇒ Object

#upload_log ⇒ Object

#version ⇒ Object

.is_thor_reserved_word?(word, type) ⇒ `Boolean`

#build(*cmd) ⇒ `Object`

#build_image(image_name) ⇒ `Object`

#clone(project_url) ⇒ `Object`

#clone_data(dataset_url) ⇒ `Object`

#commit_image ⇒ `Object`

#config_flask_remote(image_name, port = 80) ⇒ `Object`

#config_flask_remote_gpu(image_name, port = 80) ⇒ `Object`

#config_netrc(container) ⇒ `Object`

#config_remote(image_name, port = 7654, tensport = 6006) ⇒ `Object`

#config_remote_gpu(image_name, port = 7654, tensport = 6006) ⇒ `Object`

#create_volume ⇒ `Object`

#data_init_container(owner, dataset_slug, dataset_name) ⇒ `Object`

#data_jump(*commit_sha1) ⇒ `Object`

#deploy(file_to_run, function) ⇒ `Object`

#download(sync = false, ignore_list = "") ⇒ `Object`

#download_built_image(image_name, image_slug) ⇒ `Object`

#download_cnvrg_image(image_name, secret) ⇒ `Object`

#download_data(verbose, sync, path = Dir.pwd, in_dir = true) ⇒ `Object`

#download_image(image_name, image_slug) ⇒ `Object`

#exec(*cmd) ⇒ `Object`

#exec_container(container_id, *cmd) ⇒ `Object`

#exec_docker(*cmd) ⇒ `Object`

#exec_remote(*cmd) ⇒ `Object`

#experiments ⇒ `Object`

#get_machine ⇒ `Object`

#init_data(public) ⇒ `Object`

#init_data_container(container) ⇒ `Object`

#install_python_libraries(*lib) ⇒ `Object`

#install_system_libraries(*command_to_run) ⇒ `Object`

#jump(commit_sha1) ⇒ `Object`

#link ⇒ `Object`

#list_commits ⇒ `Object`

#list_dataset ⇒ `Object`

#list_dataset_commits ⇒ `Object`

#list_images ⇒ `Object`

#list_machines ⇒ `Object`

#login ⇒ `Object`

#logout ⇒ `Object`

#me ⇒ `Object`

#new(project_name) ⇒ `Object`

#notebook ⇒ `Object`

#notebook_stop(notebook_slug) ⇒ `Object`

#port_container(container_id) ⇒ `Object`

#pull_image(image_name) ⇒ `Object`

#push(*name) ⇒ `Object`

#remote_notebook ⇒ `Object`

#remote_notebook_old ⇒ `Object`

#revert_exp ⇒ `Object`

#run(*cmd) ⇒ `Object`

#run_notebook ⇒ `Object`

#search_libraries(library) ⇒ `Object`

#set_api_url(url) ⇒ `Object`

#set_compression_path(*compression_path) ⇒ `Object`

#set_default_owner ⇒ `Object`

#set_image(docker_image) ⇒ `Object`

#set_remote_api_url(owner, current_user, url) ⇒ `Object`

#set_remote_login(current_user, owner, url, email, secret) ⇒ `Object`

#show_libraries ⇒ `Object`

#snap_data ⇒ `Object`

#status ⇒ `Object`

#stop_container(container_id) ⇒ `Object`

#sync(direct = true) ⇒ `Object`

#sync_image(docker = false) ⇒ `Object`

#tensor_port_container(container_id) ⇒ `Object`

#test ⇒ `Object`

#unlink ⇒ `Object`

#upload(link = false, sync = false, direct = false, ignore_list = "") ⇒ `Object`

#upload_cnvrg_image(image_path, image_name, secret) ⇒ `Object`

#upload_data(sync = false, direct = false) ⇒ `Object`

#upload_data_tar(ignore, verbose, sync, no_compression) ⇒ `Object`

#upload_image(image_id, is_public, is_base, *message) ⇒ `Object`

#upload_log ⇒ `Object`

#version ⇒ `Object`