dratools 0.0.1

data/lib/dratools/ddbj_record_fields.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Dratools
+  # DDBJ Search resource JSON で使う resource type とキー名をまとめる。
+  module DdbjRecordFields
+    SRA_RUN_RESOURCE_TYPE = 'sra-run'
+    SRA_EXPERIMENT_RESOURCE_TYPE = 'sra-experiment'
+    SRA_SAMPLE_RESOURCE_TYPE = 'sra-sample'
+    SRA_STUDY_RESOURCE_TYPE = 'sra-study'
+    SRA_SUBMISSION_RESOURCE_TYPE = 'sra-submission'
+    BIOPROJECT_RESOURCE_TYPE = 'bioproject'
+    BIOSAMPLE_RESOURCE_TYPE = 'biosample'
+
+    FILE_TYPE_SRA = 'sra'
+    FILE_TYPE_FASTQ = 'fastq'
+    FILE_TYPE_ALL = 'all'
+
+    DB_XREFS_KEY = 'dbXrefs'
+    CHILD_BIOPROJECTS_KEY = 'childBioProjects'
+    TYPE_KEY = 'type'
+    URL_KEY = 'url'
+    FTP_URL_KEY = 'ftpUrl'
+    ID_KEY = 'id'
+    IDENTIFIER_KEY = 'identifier'
+    ACCESSION_KEY = 'accession'
+    PRIMARY_ID_KEY = 'primaryId'
+    DOWNLOAD_URL_KEY = 'downloadUrl'
+    DISTRIBUTION_KEY = 'distribution'
+    CONTENT_URL_KEY = 'contentUrl'
+    CONTENT_SIZE_KEY = 'contentSize'
+    SIZE_KEY = 'size'
+    FILE_SIZE_KEY = 'fileSize'
+    MD5_KEY = 'md5'
+    MD5_SUM_KEY = 'md5sum'
+    ENCODING_FORMAT_KEY = 'encodingFormat'
+
+    INFO_FIELD_KEYS = [
+      IDENTIFIER_KEY,
+      TYPE_KEY,
+      'title',
+      'description',
+      'organism',
+      'platform',
+      'instrumentModel',
+      'libraryStrategy',
+      'librarySource',
+      'librarySelection',
+      'libraryLayout',
+      'libraryName',
+      'dateCreated',
+      'dateModified',
+      'datePublished',
+      'status'
+    ].freeze
+  end
+end

data/lib/dratools/ddbj_resource_client.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'timeout'
+require 'uri'
+
+require_relative 'errors'
+require_relative 'version'
+
+module Dratools
+  # DDBJ resource API を呼び出す薄い HTTP クライアント。
+  class DdbjResourceClient
+    DDBJ_RESOURCE_BASE_URL = 'https://ddbj.nig.ac.jp/resource'
+    RESOURCE_RECORD_EXTENSION = '.json'
+    HTTPS_SCHEME = 'https'
+    HTTP_LOCATION_HEADER = 'location'
+    USER_AGENT_HEADER = 'User-Agent'
+    DEFAULT_REDIRECT_LIMIT = 5
+    DEFAULT_OPEN_TIMEOUT_SECONDS = 10
+    DEFAULT_READ_TIMEOUT_SECONDS = 30
+
+    def initialize(base_url: DDBJ_RESOURCE_BASE_URL, open_timeout: DEFAULT_OPEN_TIMEOUT_SECONDS,
+                   read_timeout: DEFAULT_READ_TIMEOUT_SECONDS)
+      @base_url = base_url.delete_suffix('/')
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    def fetch_resource_record(type, accession)
+      fetch_json("#{@base_url}/#{type}/#{accession}#{RESOURCE_RECORD_EXTENSION}")
+    end
+
+    private
+
+    def fetch_json(request_url, redirects_remaining = DEFAULT_REDIRECT_LIMIT)
+      request_uri = URI(request_url)
+      response = get_http_response(request_uri)
+
+      case response
+      when Net::HTTPSuccess
+        JSON.parse(response.body)
+      when Net::HTTPRedirection
+        raise NetworkError, "too many redirects: #{request_url}" if redirects_remaining <= 0
+
+        location = response[HTTP_LOCATION_HEADER]
+        raise NetworkError, "redirect without location: #{request_url}" if location.to_s.empty?
+
+        fetch_json(URI.join(request_uri, location).to_s, redirects_remaining - 1)
+      when Net::HTTPNotFound
+        raise NotFoundError, "not found: #{request_url}"
+      else
+        raise NetworkError, "HTTP #{response.code}: #{request_url}"
+      end
+    rescue JSON::ParserError => error
+      raise NetworkError, "invalid JSON from #{request_url}: #{error.message}", cause: error
+    rescue Timeout::Error, IOError, SocketError, SystemCallError => error
+      message = "failed to fetch #{request_url}: #{error.class}: #{error.message}"
+      raise NetworkError, message, cause: error
+    end
+
+    def get_http_response(request_uri)
+      Net::HTTP.start(
+        request_uri.host,
+        request_uri.port,
+        use_ssl: request_uri.scheme == HTTPS_SCHEME,
+        open_timeout: @open_timeout,
+        read_timeout: @read_timeout
+      ) do |http|
+        http.get(request_uri.request_uri, USER_AGENT_HEADER => user_agent)
+      end
+    end
+
+    def user_agent
+      "#{NAME}/#{VERSION}"
+    end
+  end
+end

data/lib/dratools/download_candidate.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative 'errors'
+
+module Dratools
+  # 1 件のダウンロード候補を表す値オブジェクト。
+  class DownloadCandidate
+    FTP_PROTOCOL = 'ftp'
+    HTTPS_PROTOCOL = 'https'
+    HTTP_PROTOCOL = 'http'
+    HTTP_BASED_PROTOCOLS = [HTTPS_PROTOCOL, HTTP_PROTOCOL].freeze
+
+    attr_reader :run_accession, :type, :url, :ftp_url, :size, :md5
+
+    def initialize(type:, run_accession: nil, url: nil, ftp_url: nil, size: nil, md5: nil)
+      @run_accession = run_accession
+      @type = type
+      @url = url
+      @ftp_url = ftp_url
+      @size = size
+      @md5 = md5
+    end
+
+    def url_for_protocol(protocol)
+      case protocol.to_s
+      when FTP_PROTOCOL
+        ftp_url || url
+      when *HTTP_BASED_PROTOCOLS
+        url || ftp_url
+      else
+        raise InvalidProtocolError, "unknown protocol: #{protocol}"
+      end
+    end
+
+    def filename_for_protocol(protocol = HTTPS_PROTOCOL)
+      File.basename(URI(url_for_protocol(protocol)).path)
+    end
+
+    def directory_url_for_protocol?(protocol = HTTPS_PROTOCOL)
+      URI(url_for_protocol(protocol)).path.end_with?('/')
+    end
+  end
+end

data/lib/dratools/download_candidate_builder.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'ddbj_record_fields'
+require_relative 'download_candidate'
+
+module Dratools
+  # DDBJ run レコードの downloadUrl/distribution から DownloadCandidate を作る。
+  class DownloadCandidateBuilder
+    def build_from_run_record(run_record)
+      run_accession = run_accession_from(run_record)
+      downloads = download_items_from(run_record).filter_map do |download_item|
+        build_from_download_item(run_accession, download_item)
+      end
+      downloads.uniq { |download| download_key(download) }
+    end
+
+    private
+
+    def run_accession_from(run_record)
+      run_record[DdbjRecordFields::ACCESSION_KEY] ||
+        run_record[DdbjRecordFields::IDENTIFIER_KEY] ||
+        run_record[DdbjRecordFields::ID_KEY] ||
+        run_record[DdbjRecordFields::PRIMARY_ID_KEY]
+    end
+
+    def download_items_from(ddbj_record)
+      ddbj_record.fetch(DdbjRecordFields::DOWNLOAD_URL_KEY, []) +
+        ddbj_record.fetch(DdbjRecordFields::DISTRIBUTION_KEY, [])
+    end
+
+    def build_from_download_item(run_accession, download_item)
+      return unless download_item.is_a?(Hash)
+
+      if download_item[DdbjRecordFields::CONTENT_URL_KEY]
+        build_from_distribution_item(run_accession, download_item)
+      else
+        build_from_download_url_item(run_accession, download_item)
+      end
+    end
+
+    def build_from_distribution_item(run_accession, download_item)
+      file_type = file_type_from_distribution(download_item)
+      return unless file_type
+
+      DownloadCandidate.new(
+        run_accession: run_accession,
+        type: file_type,
+        url: download_item[DdbjRecordFields::CONTENT_URL_KEY],
+        ftp_url: nil,
+        size: download_item[DdbjRecordFields::CONTENT_SIZE_KEY],
+        md5: download_item[DdbjRecordFields::MD5_KEY] || download_item[DdbjRecordFields::MD5_SUM_KEY]
+      )
+    end
+
+    def build_from_download_url_item(run_accession, download_item)
+      file_type = file_type_from_download_url(download_item)
+      return unless file_type
+
+      DownloadCandidate.new(
+        run_accession: run_accession,
+        type: file_type,
+        url: download_item[DdbjRecordFields::URL_KEY],
+        ftp_url: download_item[DdbjRecordFields::FTP_URL_KEY],
+        size: download_item[DdbjRecordFields::SIZE_KEY] || download_item[DdbjRecordFields::FILE_SIZE_KEY],
+        md5: download_item[DdbjRecordFields::MD5_KEY] || download_item[DdbjRecordFields::MD5_SUM_KEY]
+      )
+    end
+
+    def file_type_from_distribution(download_item)
+      file_type_from(download_item[DdbjRecordFields::ENCODING_FORMAT_KEY])
+    end
+
+    def file_type_from_download_url(download_item)
+      file_type_from(download_item[DdbjRecordFields::TYPE_KEY])
+    end
+
+    def file_type_from(value)
+      case value.to_s.downcase
+      when DdbjRecordFields::FILE_TYPE_SRA
+        DdbjRecordFields::FILE_TYPE_SRA
+      when DdbjRecordFields::FILE_TYPE_FASTQ
+        DdbjRecordFields::FILE_TYPE_FASTQ
+      end
+    end
+
+    def download_key(download)
+      [download.type, download.url, download.ftp_url]
+    end
+  end
+end

data/lib/dratools/download_service.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'cgi/escape'
+require 'fileutils'
+require 'net/http'
+require 'timeout'
+require 'uri'
+
+require_relative 'download_candidate'
+require_relative 'external_command_runner'
+require_relative 'checksum_verifier'
+require_relative 'errors'
+require_relative 'version'
+
+module Dratools
+  # 解決済みダウンロードの取得、probe、md5 検証、既存ファイル判定をまとめて扱う。
+  class DownloadService
+    DownloadResult = Struct.new(:path, :skipped, keyword_init: true) do
+      def skipped?
+        skipped
+      end
+
+      def to_s
+        path
+      end
+    end
+
+    DEFAULT_OUTPUT_DIRECTORY = '.'
+    DEFAULT_PROTOCOL = DownloadCandidate::HTTPS_PROTOCOL
+    DEFAULT_PROBE_TIMEOUT_SECONDS = 5
+    DEFAULT_SIZE_TIMEOUT_SECONDS = 10
+    DEFAULT_REDIRECT_LIMIT = 5
+    HTTP_LOCATION_HEADER = 'location'
+    HTTPS_SCHEME = 'https'
+    USER_AGENT_HEADER = 'User-Agent'
+    FASTQ_HREF_PATTERN = /href=(?<quote>["'])(?<href>[^"']*\.fastq[^"']*)\k<quote>/i
+
+    def initialize(runner: ExternalCommandRunner.new, checksum_verifier: ChecksumVerifier.new)
+      @runner = runner
+      @checksum_verifier = checksum_verifier
+    end
+
+    def probe_download(download, protocol: DEFAULT_PROTOCOL, timeout: DEFAULT_PROBE_TIMEOUT_SECONDS)
+      @runner.probe_url(download.url_for_protocol(protocol), timeout: timeout)
+    end
+
+    def content_lengths(download, protocol: DEFAULT_PROTOCOL, timeout: DEFAULT_SIZE_TIMEOUT_SECONDS)
+      download_url = download.url_for_protocol(protocol)
+      return [nil] unless http_url?(download_url)
+
+      if download.directory_url_for_protocol?(protocol)
+        file_urls = directory_file_urls(download_url, timeout: timeout)
+        return [nil] if file_urls.empty?
+
+        return file_urls.map { |file_url| safe_head_content_length(file_url, timeout: timeout) }
+      end
+
+      [safe_head_content_length(download_url, timeout: timeout)]
+    rescue Error
+      [nil]
+    end
+
+    def save_download(
+      download,
+      outdir: DEFAULT_OUTPUT_DIRECTORY,
+      protocol: DEFAULT_PROTOCOL,
+      verify: true,
+      force: false,
+      skip_existing: false
+    )
+      FileUtils.mkdir_p(outdir)
+      download_url = download.url_for_protocol(protocol)
+      if download.directory_url_for_protocol?(protocol)
+        raise InvalidRecordError, "download URL points to a directory: #{download_url}"
+      end
+
+      output_path = File.join(outdir, download.filename_for_protocol(protocol))
+      FileUtils.rm_f(output_path) if force && File.file?(output_path)
+      if should_skip_existing?(
+        output_path,
+        download,
+        download_url: download_url,
+        skip_existing: skip_existing
+      )
+        return DownloadResult.new(path: output_path, skipped: true)
+      end
+
+      @runner.download_url(download_url, output_path)
+      if verify && checksum_available?(download)
+        @checksum_verifier.verify_md5!(output_path, download.md5)
+      end
+      DownloadResult.new(path: output_path, skipped: false)
+    end
+
+    private
+
+    def should_skip_existing?(output_path, download, download_url:, skip_existing:)
+      return false unless File.file?(output_path)
+      return true if skip_existing
+      if checksum_available?(download)
+        return @checksum_verifier.md5_matches?(output_path, download.md5)
+      end
+
+      existing_file_complete?(output_path, download_url)
+    end
+
+    def existing_file_complete?(output_path, download_url)
+      remote_size = safe_head_content_length(download_url, timeout: DEFAULT_SIZE_TIMEOUT_SECONDS)
+      return false unless remote_size
+
+      local_size = File.size(output_path)
+      return true if local_size == remote_size
+      return false if local_size < remote_size
+
+      raise InvalidRecordError,
+            "existing file is larger than remote file: #{output_path} " \
+            "(local=#{local_size}, remote=#{remote_size}); use --force to re-download"
+    end
+
+    def checksum_available?(download)
+      !download.md5.to_s.strip.empty?
+    end
+
+    def http_url?(url)
+      DownloadCandidate::HTTP_BASED_PROTOCOLS.include?(URI(url).scheme)
+    rescue TypeError, URI::InvalidURIError
+      false
+    end
+
+    def directory_file_urls(directory_url, timeout:, redirects_remaining: DEFAULT_REDIRECT_LIMIT)
+      request_uri = URI(directory_url)
+      response = get_http_response(request_uri, timeout: timeout)
+
+      case response
+      when Net::HTTPSuccess
+        response.body.scan(FASTQ_HREF_PATTERN).map do |match|
+          href = CGI.unescapeHTML(match.last)
+          URI.join(request_uri, href).to_s
+        end.uniq
+      when Net::HTTPRedirection
+        raise NetworkError, "too many redirects: #{directory_url}" if redirects_remaining <= 0
+
+        location = response[HTTP_LOCATION_HEADER]
+        raise NetworkError, "redirect without location: #{directory_url}" if location.to_s.empty?
+
+        directory_file_urls(
+          URI.join(request_uri, location).to_s,
+          timeout: timeout,
+          redirects_remaining: redirects_remaining - 1
+        )
+      else
+        raise NetworkError, "HTTP #{response.code}: #{directory_url}"
+      end
+    rescue Timeout::Error, IOError, SocketError, SystemCallError, URI::InvalidURIError => error
+      raise NetworkError, fetch_failure_message(directory_url, error), cause: error
+    end
+
+    def head_content_length(request_url, timeout:, redirects_remaining: DEFAULT_REDIRECT_LIMIT)
+      request_uri = URI(request_url)
+      response = head_http_response(request_uri, timeout: timeout)
+
+      case response
+      when Net::HTTPSuccess
+        response.content_length
+      when Net::HTTPRedirection
+        raise NetworkError, "too many redirects: #{request_url}" if redirects_remaining <= 0
+
+        location = response[HTTP_LOCATION_HEADER]
+        raise NetworkError, "redirect without location: #{request_url}" if location.to_s.empty?
+
+        head_content_length(
+          URI.join(request_uri, location).to_s,
+          timeout: timeout,
+          redirects_remaining: redirects_remaining - 1
+        )
+      else
+        raise NetworkError, "HTTP #{response.code}: #{request_url}"
+      end
+    rescue Timeout::Error, IOError, SocketError, SystemCallError, URI::InvalidURIError => error
+      raise NetworkError, fetch_failure_message(request_url, error), cause: error
+    end
+
+    def safe_head_content_length(request_url, timeout:)
+      head_content_length(request_url, timeout: timeout)
+    rescue Error
+      nil
+    end
+
+    def get_http_response(request_uri, timeout:)
+      Net::HTTP.start(
+        request_uri.host,
+        request_uri.port,
+        use_ssl: request_uri.scheme == HTTPS_SCHEME,
+        open_timeout: timeout,
+        read_timeout: timeout
+      ) do |http|
+        http.get(request_uri.request_uri, USER_AGENT_HEADER => user_agent)
+      end
+    end
+
+    def head_http_response(request_uri, timeout:)
+      Net::HTTP.start(
+        request_uri.host,
+        request_uri.port,
+        use_ssl: request_uri.scheme == HTTPS_SCHEME,
+        open_timeout: timeout,
+        read_timeout: timeout
+      ) do |http|
+        http.head(request_uri.request_uri, USER_AGENT_HEADER => user_agent)
+      end
+    end
+
+    def user_agent
+      "#{NAME}/#{VERSION}"
+    end
+
+    def fetch_failure_message(url, error)
+      "failed to fetch #{url}: #{error.class}: #{error.message}"
+    end
+  end
+end

data/lib/dratools/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Dratools
+  class Error < StandardError
+  end
+
+  class InputError < Error
+  end
+
+  class MissingAccessionError < InputError
+  end
+
+  class InputFileError < InputError
+  end
+
+  class InvalidOptionError < Error
+  end
+
+  class InvalidProtocolError < Error
+  end
+
+  class NotFoundError < Error
+  end
+
+  class InvalidRecordError < Error
+  end
+
+  class NetworkError < Error
+  end
+
+  class CommandError < Error
+  end
+
+  class ChecksumError < Error
+  end
+
+  class UnsupportedAccessionError < Error
+  end
+end

data/lib/dratools/external_command_runner.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+require 'English'
+
+require_relative 'config'
+require_relative 'errors'
+
+module Dratools
+  # curl か wget を使って URL の確認とダウンロードを行うラッパー。
+  #
+  # probe は短時間・無出力で済ませ、download は外部コマンドの進捗を端末へ流す。
+  # 巨大ファイルを扱うため、download には総時間制限ではなく失速検知を使う。
+  class ExternalCommandRunner
+    CURL_COMMAND = 'curl'
+    WGET_COMMAND = 'wget'
+    SUPPORTED_COMMANDS = [CURL_COMMAND, WGET_COMMAND].freeze
+    COMMAND_NOT_FOUND_MESSAGE = 'curl または wget が見つかりません'
+    DEFAULT_PROBE_TIMEOUT_SECONDS = 5
+    PROBE_BYTE_RANGE = '0-0'
+    SINGLE_ATTEMPT_COUNT = 1
+
+    CURL_PROBE_OPTIONS = ['--location', '--fail', '--silent', '--show-error', '--range'].freeze
+    CURL_TIMEOUT_OPTION = '--max-time'
+    CURL_CONNECT_TIMEOUT_OPTION = '--connect-timeout'
+    CURL_SPEED_LIMIT_OPTION = '--speed-limit'
+    CURL_SPEED_TIME_OPTION = '--speed-time'
+    CURL_RETRY_OPTION = '--retry'
+    CURL_OUTPUT_OPTION = '--output'
+    CURL_DOWNLOAD_OPTIONS = ['--location', '--fail', '--continue-at', '-'].freeze
+
+    WGET_PROBE_OPTIONS = ['--spider'].freeze
+    WGET_TIMEOUT_OPTION = '--timeout'
+    WGET_CONNECT_TIMEOUT_OPTION = '--connect-timeout'
+    WGET_READ_TIMEOUT_OPTION = '--read-timeout'
+    WGET_TRIES_OPTION = '--tries'
+    WGET_WAITRETRY_OPTION = '--waitretry'
+    WGET_CONTINUE_OPTION = '--continue'
+    WGET_OUTPUT_OPTION = '--output-document'
+
+    def initialize(preferred: nil)
+      @preferred = preferred
+    end
+
+    def available_command
+      candidates = [@preferred, *SUPPORTED_COMMANDS].compact
+      candidates.find { |command_name| executable_command?(command_name) }
+    end
+
+    def probe_url(url, timeout: DEFAULT_PROBE_TIMEOUT_SECONDS)
+      tool = available_command || raise(CommandError, COMMAND_NOT_FOUND_MESSAGE)
+      # 巨大ファイルを落とさないよう、短時間・最小範囲の確認に留める。
+      command =
+        if File.basename(tool) == CURL_COMMAND
+          [tool, *CURL_PROBE_OPTIONS, PROBE_BYTE_RANGE, CURL_TIMEOUT_OPTION, timeout.to_s,
+           CURL_OUTPUT_OPTION, null_device, url]
+        else
+          [tool, *WGET_PROBE_OPTIONS, "#{WGET_TIMEOUT_OPTION}=#{timeout}",
+           "#{WGET_TRIES_OPTION}=#{SINGLE_ATTEMPT_COUNT}", url]
+        end
+      run_quietly(command)
+    end
+
+    def download_url(url, output_path)
+      tool = available_command || raise(CommandError, COMMAND_NOT_FOUND_MESSAGE)
+      command =
+        if File.basename(tool) == CURL_COMMAND
+          [tool, *CURL_DOWNLOAD_OPTIONS,
+           CURL_CONNECT_TIMEOUT_OPTION, Config.download_connect_timeout_seconds.to_s,
+           CURL_SPEED_LIMIT_OPTION, Config.download_stall_speed_bytes_per_second.to_s,
+           CURL_SPEED_TIME_OPTION, Config.download_stall_timeout_seconds.to_s,
+           CURL_RETRY_OPTION, Config.download_retry_count.to_s,
+           CURL_OUTPUT_OPTION, output_path, url]
+        else
+          [tool, WGET_CONTINUE_OPTION,
+           "#{WGET_CONNECT_TIMEOUT_OPTION}=#{Config.download_connect_timeout_seconds}",
+           "#{WGET_READ_TIMEOUT_OPTION}=#{Config.download_stall_timeout_seconds}",
+           "#{WGET_TRIES_OPTION}=#{Config.download_retry_count}",
+           "#{WGET_WAITRETRY_OPTION}=#{Config.download_retry_wait_seconds}",
+           WGET_OUTPUT_OPTION, output_path, url]
+        end
+      run_streaming(command)
+    end
+
+    private
+
+    def run_quietly(command)
+      out, err, status = Open3.capture3(*command)
+      return true if status.success?
+
+      raise CommandError, "#{command.shelljoin}\n#{out}#{err}"
+    end
+
+    def run_streaming(command)
+      # 配列形式で渡すことでシェルを介さず、curl/wget の stderr 進捗はそのまま見せる。
+      return true if system(*command)
+
+      status = $CHILD_STATUS
+      detail = status ? "exit status: #{status.exitstatus}" : 'command failed'
+      raise CommandError, "#{command.shelljoin}\n#{detail}"
+    end
+
+    def executable_command?(command_name)
+      ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |directory|
+        command_path = File.join(directory, command_name)
+        File.file?(command_path) && File.executable?(command_path)
+      end
+    end
+
+    def null_device
+      File::NULL
+    end
+  end
+end