stationery 0.8.0 → 0.10.0

data/lib/stationery/markdown/inline_parser/emphasis.rb

@@ -21,23 +21,30 @@ module Stationery
           end
         end
 
-        # Wraps matched delimiter pairs (and what lies between them) in place.
+        # Wraps matched delimiter pairs (and what lies between them) in place. `bottoms` remembers, per
+        # kind of closer, the index below which no opener is left for it, so a run of closers that
+        # nothing opens is not searched for again and again (CommonMark's openers_bottom).
         def process(nodes)
+          bottoms = Hash.new(0)
           index = 0
           while index < nodes.size
             closer = nodes[index]
-            opener = closer?(closer) && opener_for(nodes, index)
-            next index += 1 unless opener
+            next index += 1 unless closer?(closer)
 
-            index = wrap(nodes, opener, index)
+            opening = opener_for(nodes, index, bottoms[kind(closer)])
+            next index = wrap(nodes, opening, index, bottoms) if opening
+
+            bottoms[kind(closer)] = index
+            index += 1
           end
         end
 
-        def wrap(nodes, opening, index)
+        def wrap(nodes, opening, index, bottoms)
           opener = nodes[opening]
           closer = nodes[index]
           used = used(opener, closer)
           nodes[(opening + 1)...index] = [Nodes::Wrap.new(marks(closer.char, used), nodes[(opening + 1)...index])]
+          bottoms.each { |kind, bottom| bottoms[kind] = opening + 1 if bottom > opening + 1 }
           opener.remaining -= used
           closer.remaining -= used
           index = opening + 2
@@ -49,9 +56,9 @@ module Stationery
           index
         end
 
-        def opener_for(nodes, index)
+        def opener_for(nodes, index, bottom)
           closer = nodes[index]
-          (index - 1).downto(0).find do |i|
+          (index - 1).downto(bottom).find do |i|
             node = nodes[i]
             node.is_a?(Nodes::Delimiter) && node.opener && node.char == closer.char && node.remaining.positive? &&
               (closer.char != "~" || node.remaining == closer.remaining)
@@ -60,6 +67,9 @@ module Stationery
 
         def closer?(node) = node.is_a?(Nodes::Delimiter) && node.closer && node.remaining.positive?
 
+        # What decides which openers suit a closer: its character, and for `~` its length too.
+        def kind(closer) = closer.char == "~" ? [closer.char, closer.remaining] : closer.char
+
         def used(opener, closer)
           return closer.remaining if closer.char == "~"
 

data/lib/stationery/markdown/inline_parser/links.rb

@@ -3,9 +3,14 @@
 module Stationery
   module Markdown
     class InlineParser
-      # Brackets, inline and reference links, images and autolinks.
+      # Brackets, inline and reference links, images and autolinks. At most OPEN brackets wait for
+      # their `]` at once (the oldest gives way), and a link label is at most LABEL characters as
+      # CommonMark has it, so neither nesting nor the work per `]` grows with the input. A bracket's
+      # `position` is in bytes, which the scanner knows without counting characters.
       module Links
         Bracket = Struct.new(:index, :image, :active, :position)
+        OPEN = 64
+        LABEL = 999
 
         INLINE = /
           \(\s*
@@ -23,7 +28,8 @@ module Stationery
         private
 
         def open_bracket(image: false)
-          @brackets << Bracket.new(@nodes.size, image, true, @scanner.charpos)
+          @brackets.shift if @brackets.size >= OPEN
+          @brackets << Bracket.new(@nodes.size, image, true, @scanner.pos)
           add(image ? "![" : "[")
         end
 
@@ -31,7 +37,7 @@ module Stationery
           bracket = @brackets.pop
           return add("]") unless bracket&.active
 
-          href = inline_destination || reference(@source[bracket.position...(@scanner.charpos - 1)])
+          href = inline_destination || reference(bracket.position...(@scanner.pos - 1))
           return add("]") unless href
 
           children = @nodes.slice!(bracket.index..).drop(1)
@@ -48,18 +54,17 @@ module Stationery
           InlineParser.destination(@scanner[1] || @scanner[2])
         end
 
-        def reference(label)
+        # The target of `[text][label]`, `[text][]` or `[text]`, `span` being where the text lies.
+        def reference(span)
           position = @scanner.pos
-          if @scanner.scan(REFERENCE)
-            label = @scanner[1] unless @scanner[1].empty?
-            href = @refs[InlineParser.label(label)]
-            @scanner.pos = position unless href
-            href
-          else
-            @refs[InlineParser.label(label)]
-          end
+          label = @scanner[1] if @scanner.scan(REFERENCE) && !@scanner[1].empty?
+          href = defined_as(label || (@source.byteslice(span) if span.size <= LABEL * 4))
+          @scanner.pos = position unless href
+          href
         end
 
+        def defined_as(label) = label && label.length <= LABEL && @refs[InlineParser.label(label)]
+
         def autolink
           url = @scanner[1] || "mailto:#{@scanner[2]}"
           @nodes << Nodes::Wrap.new({ link: url }, [Nodes::Text.new(@scanner[1] || @scanner[2])])

data/lib/stationery/markdown/inline_parser/nodes.rb

@@ -14,20 +14,34 @@ module Stationery
 
         module_function
 
-        def flatten(nodes, marks = {}, out = [])
-          nodes.each do |node|
-            case node
-            when Text then out << Rich::Inline.new(text: node.text, marks:)
-            when Delimiter then out << Rich::Inline.new(text: node.char * node.remaining, marks:)
-            when Code then out << Rich::Inline.new(text: node.text, marks: marks.merge(code: true))
-            when Break then out << Rich::Inline.break
-            when Wrap then flatten(node.children, marks.merge(node.marks), out)
-            when Picture then out << picture(node)
-            end
+        # The tree as a flat list of inlines, each with the marks of the wraps around it. Walked with
+        # a stack of its own, not by recursion: emphasis nests as deep as its author types asterisks.
+        def flatten(nodes, marks = {})
+          out = []
+          pending = [[nodes, 0, marks]]
+          until pending.empty?
+            level = pending.last
+            node = level[0][level[1]]
+            next pending.pop unless node
+
+            level[1] += 1
+            next pending << [node.children, 0, level[2].merge(node.marks)] if node.is_a?(Wrap)
+
+            out << inline(node, level[2])
           end
           out
         end
 
+        def inline(node, marks)
+          case node
+          when Text then Rich::Inline.new(text: node.text, marks:)
+          when Delimiter then Rich::Inline.new(text: node.char * node.remaining, marks:)
+          when Code then Rich::Inline.new(text: node.text, marks: marks.merge(code: true))
+          when Break then Rich::Inline.break
+          when Picture then picture(node)
+          end
+        end
+
         def picture(node) = Rich::Image.new(src: node.src, alt: plain(node.children), width: nil, height: nil)
 
         def plain(nodes)

data/lib/stationery/markdown/inline_parser.rb

@@ -79,10 +79,16 @@ module Stationery
       end
 
       def delimiter
-        position = @scanner.charpos
+        before = previous_character
         run = @scanner.scan(/\*+|_+|~+/)
-        before = position.zero? ? " " : @source[position - 1]
-        @nodes << Emphasis.delimiter(run, before, @source[@scanner.charpos] || " ")
+        @nodes << Emphasis.delimiter(run, before, @scanner.check(/./m) || " ")
+      end
+
+      # The character before the scanner, read from the few bytes before it: a character position
+      # is counted from the start of the source, which a long paragraph would pay for at every run.
+      def previous_character
+        position = @scanner.pos
+        @source.byteslice([position - 4, 0].max...position).scrub("")[-1] || " "
       end
     end
   end

data/lib/stationery/minitest.rb

@@ -34,6 +34,10 @@ module Stationery
         assert_pdf(Matchers::HaveFacturX.new(profile:), subject, msg)
       end
 
+      def assert_pdf_signature(subject, msg = nil, name: nil, valid: true)
+        assert_pdf(Matchers::HaveSignature.new(name:, valid:), subject, msg)
+      end
+
       def assert_no_pdf_warnings(subject, msg = nil) = assert_pdf(Matchers::HaveNoWarnings.new, subject, msg)
       def assert_pdf_structure(subject, tree, msg = nil) = assert_pdf(Matchers::HaveStructure.new(tree), subject, msg)
       def assert_tagged_content(subject, msg = nil) = assert_pdf(Matchers::HaveTaggedContent.new, subject, msg)

data/lib/stationery/pdf/assembler.rb

@@ -10,12 +10,20 @@ module Stationery
       # PDF::Attachment files to embed; `xmp:` (true) writes the XMP packet,
       # with `xmp_extensions:` as further schemas and `xmp_schemas:` describing
       # them to PDF/A (see XMP); `conformance:` (a PDF::Conformance) adds what
-      # PDF/A and PDF/UA ask of the file.
+      # PDF/A and PDF/UA ask of the file; `signature:` (a PDF::Signature)
+      # signs it. `sink:` (anything answering `call(bytes)`) receives the file
+      # in pieces as each page is written, in the order the objects are
+      # flushed, instead of one String at the end; a signature needs the
+      # finished file, so it cannot be streamed.
       def initialize(pages:, resources:, info: {}, outline: [], encryption: nil, tagging: nil, lang: nil,
                      page_labels: nil, attachments: [], xmp: true, xmp_extensions: {}, xmp_schemas: [],
-                     conformance: nil)
+                     conformance: nil, signature: nil, sink: nil)
+        raise ArgumentError, "a signed document cannot be streamed: sign needs the whole file" if signature && sink
+
+        @sink = sink
         @xmp_schemas = xmp_schemas
         @conformance = conformance
+        @signature = signature
         @tagging = tagging
         @lang = lang
         @page_labels = page_labels
@@ -29,14 +37,19 @@ module Stationery
         @encryption = encryption
       end
 
+      # The file as a String, or the number of bytes streamed to the sink.
       def render
-        writer = Writer.new(encryption: @encryption)
-        @form = Forms::AcroForm.new(writer)
+        writer = Writer.new(encryption: @encryption, sink: @sink)
         tree = writer.reserve
         refs = @resources.build(writer)
+        @form = Forms::AcroForm.new(writer, fonts: refs.fetch(:Font), signature: @signature,
+                                            need_appearances: @conformance.nil? && @signature.nil?)
         kids = @kids = @pages.map { writer.reserve }
         @structure = @tagging && Tagging::Writer.new(@tagging, pages: @pages, refs: kids)
-        @pages.each_with_index { |page, index| write_page(writer, page, kids[index], tree, refs) }
+        @pages.each_with_index do |page, index|
+          write_page(writer, page, kids[index], tree, refs)
+          writer.flush
+        end
         writer.set(tree, { Type: :Pages, Kids: kids, Count: kids.size })
         outlines = OutlineWriter.new(writer, @outline, kids).write
         now = Time.now
@@ -44,7 +57,8 @@ module Stationery
         entries = catalog(tree, outlines, @form.write)
                   .merge(accessibility(writer), metadata(writer, info, now), Attachments.write(writer, @attachments))
         entries.merge!(@conformance.catalog_entries(writer)) if @conformance
-        writer.render(root: writer.add(entries), info: writer.add(info))
+        pdf = writer.render(root: writer.add(entries), info: writer.add(info))
+        @signature ? @signature.apply(pdf) : pdf
       end
 
       private
@@ -69,14 +83,20 @@ module Stationery
           Type: :Page, Parent: tree, MediaBox: [0, 0, *page.size],
           Contents: writer.add(Stream.new(page.content)), Resources: page_resources(page, refs)
         }
-        if page.annotations.any?
-          dictionary[:Annots] = page.annotations.map { |annot| annotation_ref(writer, annot, ref) }
-        end
+        annotations = page.annotations.map { |annot| annotation_ref(writer, annot, ref) }
+        annotations << @form.sign(ref, taken: field_names) if @signature&.invisible? && ref == @kids.first
+        dictionary[:Annots] = annotations if annotations.any?
         dictionary.merge!(@structure.page_entries(page)) if @structure
-        dictionary.merge!(@conformance.page_entries(page)) if @conformance
+        dictionary.merge!(@conformance.page_entries(page, annotated: annotations.any?)) if @conformance
         writer.set(ref, dictionary)
       end
 
+      # Every field name of the document and the group each one starts with.
+      def field_names
+        names = @pages.flat_map(&:annotations).filter_map { |annotation| annotation[:widget]&.name }
+        names.flat_map { |name| [name, name.split(".").first] }.uniq
+      end
+
       def page_resources(page, refs)
         page.resource_names.to_h do |category, names|
           [category, names.to_h { |name| [name, refs.fetch(category).fetch(name)] }]
@@ -85,7 +105,7 @@ module Stationery
 
       def annotation_ref(writer, annotation, page)
         if annotation[:widget]
-          return @form.add(annotation[:widget], annotation[:rect], page) do |widget_ref|
+          return @form.add(annotation, page) do |widget_ref|
             @structure ? @structure.annotation(annotation, widget_ref) : {}
           end
         end

data/lib/stationery/pdf/conformance.rb

@@ -92,7 +92,8 @@ module Stationery
       end
 
       # A page's entries: PDF/UA tabs through annotations in structure order.
-      def page_entries(page) = pdf_ua? && page.annotations.any? ? { Tabs: :S } : {}
+      # `annotated` is whether the page has any, its own or a signature's.
+      def page_entries(page, annotated: page.annotations.any?) = pdf_ua? && annotated ? { Tabs: :S } : {}
 
       # A link annotation's entries: printable, and described for PDF/UA.
       def annotation_entries(link)
@@ -110,11 +111,12 @@ module Stationery
         link[:url] || "Page #{link[:dest].page + 1}"
       end
 
-      # Form fields draw with the standard Helvetica and ZapfDingbats, which
-      # are not embedded, and ask the viewer to regenerate appearances:
-      # neither PDF/A nor PDF/UA accepts that.
+      # A form field draws with the document's embedded fonts; one made
+      # without a font book draws with the standard Helvetica, which is not
+      # embedded: neither PDF/A nor PDF/UA accepts that.
       def fields(pages)
-        names = pages.flat_map(&:annotations).filter_map { |annotation| annotation[:widget]&.name }.uniq
+        widgets = pages.flat_map(&:annotations).select { |annotation| annotation[:widget] }
+        names = widgets.reject { |annotation| annotation[:appearance].embedded? }.map { |a| a[:widget].name }.uniq
         names.map { |name| %(form field "#{name}" draws with a font that is not embedded) }
       end
 

data/lib/stationery/pdf/serializer.rb

@@ -9,7 +9,8 @@ module Stationery
     # TextString for human-readable text that may need UTF-16.
     #
     # `crypt`, when given, receives every string's bytes (the writer binds it
-    # to the object being written) and the result is written as hex.
+    # to the object being written) and the result is written as hex. A
+    # Verbatim is written as it is.
     module Serializer
       NAME_ESCAPE = %r{[^\x21-\x7E]|[#%()/<>\[\]{}]}n
       LITERAL_ESCAPE = /[\\()\r]/n
@@ -25,6 +26,7 @@ module Stationery
         when Array then "[#{value.map { |v| dump(v, crypt) }.join(" ")}]"
         when HexString then hex(value.bytes, crypt)
         when TextString then text(value.value, crypt)
+        when Verbatim then value.source
         when String then crypt ? hex(value, crypt) : literal(value)
         when Integer, true, false then value.to_s
         when Float then number(value)

data/lib/stationery/pdf/signature/cms.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    class Signature
+      # The signature value: a detached CMS SignedData (RFC 5652) over the
+      # signed bytes, as CAdES and PAdES baseline ask for it. The signed
+      # attributes are the content type, the SHA-256 message digest and the
+      # ESS signing-certificate-v2 (RFC 5035) that binds the signature to the
+      # signer's certificate; there is no signing-time attribute, a PDF keeps
+      # that in the signature dictionary's /M.
+      #
+      # A timestamp token over the signature value (see Timestamp) goes into
+      # the unsigned attributes, which makes the signature PAdES baseline B-T.
+      #
+      # Ruby's OpenSSL::PKCS7 cannot add signed attributes, so the structure
+      # is built with OpenSSL::ASN1. RSA keys sign with PKCS #1 v1.5, EC keys
+      # with ECDSA, both over SHA-256.
+      class CMS
+        OIDS = {
+          data: "1.2.840.113549.1.7.1", signed_data: "1.2.840.113549.1.7.2",
+          content_type: "1.2.840.113549.1.9.3", message_digest: "1.2.840.113549.1.9.4",
+          signing_certificate_v2: "1.2.840.113549.1.9.16.2.47", sha256: "2.16.840.1.101.3.4.2.1",
+          signature_timestamp_token: "1.2.840.113549.1.9.16.2.14",
+          rsa: "1.2.840.113549.1.1.1", ecdsa_sha256: "1.2.840.10045.4.3.2"
+        }.freeze
+
+        # `chain` are the certificates between the signer's and its root.
+        def initialize(certificate, key, chain = [])
+          @certificate = certificate
+          @key = key
+          @chain = chain
+        end
+
+        # The DER of the SignedData signing `data`. `timestamp:` is a callable
+        # given the signature value and answering a timestamp token (DER).
+        def sign(data, timestamp: nil)
+          attributes = attributes(OpenSSL::Digest::SHA256.digest(data))
+          signature = @key.sign("SHA256", asn1::Set.new(attributes).to_der)
+          unsigned = timestamp && [attribute(:signature_timestamp_token, asn1.decode(timestamp.call(signature)))]
+          content = asn1::Sequence.new([
+                                         asn1::Integer.new(1),
+                                         asn1::Set.new([algorithm(:sha256)]),
+                                         asn1::Sequence.new([oid(:data)]),
+                                         implicit(certificates),
+                                         asn1::Set.new([signer(attributes, signature, unsigned)])
+                                       ])
+          asn1::Sequence.new([oid(:signed_data), asn1::ASN1Data.new([content], 0, :CONTEXT_SPECIFIC)]).to_der
+        end
+
+        private
+
+        def asn1 = OpenSSL::ASN1
+        def oid(name) = asn1::ObjectId.new(OIDS.fetch(name))
+        def implicit(items, tag = 0) = asn1::Set.new(items, tag, :IMPLICIT, :CONTEXT_SPECIFIC)
+        def certificates = [@certificate, *@chain].map { |certificate| asn1.decode(certificate.to_der) }
+
+        # RSA and the digests carry an explicit NULL parameter, ECDSA none.
+        def algorithm(name, null: true) = asn1::Sequence.new(null ? [oid(name), asn1::Null.new(nil)] : [oid(name)])
+
+        def attribute(name, value) = asn1::Sequence.new([oid(name), asn1::Set.new([value])])
+
+        # DER orders the members of a SET OF by their encoding.
+        def attributes(digest)
+          [
+            attribute(:content_type, oid(:data)),
+            attribute(:message_digest, asn1::OctetString.new(digest)),
+            attribute(:signing_certificate_v2, signing_certificate)
+          ].sort_by(&:to_der)
+        end
+
+        # SigningCertificateV2 with one ESSCertIDv2: the certificate's SHA-256
+        # (the default hash algorithm, so it is left out).
+        def signing_certificate
+          hash = asn1::OctetString.new(OpenSSL::Digest::SHA256.digest(@certificate.to_der))
+          asn1::Sequence.new([asn1::Sequence.new([asn1::Sequence.new([hash])])])
+        end
+
+        def signer(attributes, signature, unsigned)
+          issuer = asn1.decode(@certificate.issuer.to_der)
+          info = [
+            asn1::Integer.new(1),
+            asn1::Sequence.new([issuer, asn1::Integer.new(@certificate.serial)]),
+            algorithm(:sha256),
+            implicit(attributes),
+            @key.is_a?(OpenSSL::PKey::EC) ? algorithm(:ecdsa_sha256, null: false) : algorithm(:rsa),
+            asn1::OctetString.new(signature)
+          ]
+          info << implicit(unsigned, 1) if unsigned
+          asn1::Sequence.new(info)
+        end
+      end
+    end
+  end
+end

data/lib/stationery/pdf/signature/timestamp.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Stationery
+  module PDF
+    class Signature
+      # A signature timestamp from an RFC 3161 time-stamping authority (TSA):
+      # the TSA signs the digest of the signature value and the time it saw
+      # it, and the token goes into the signature's unsigned attributes, which
+      # makes it PAdES baseline B-T. A reader can then trust the signing time
+      # even after the signer's certificate expires.
+      #
+      # `sign timestamp: "https://tsa.example/tsr"`, or a Hash with `url:`,
+      # `username:`/`password:` for a TSA that wants HTTP basic auth, `hash:`
+      # (:sha256, the default, :sha384 or :sha512) and `client:`, a callable
+      # given the request DER and answering the response DER, in place of
+      # the built-in HTTP client. Anything short of a token over exactly what
+      # was asked raises SignatureError: a document is never quietly written
+      # without the timestamp it was asked for.
+      class Timestamp
+        OPTIONS = %i[url username password hash client].freeze
+        DIGESTS = { sha256: "SHA256", sha384: "SHA384", sha512: "SHA512" }.freeze
+        # Status values a TSA answers with when it did grant the token
+        # (granted, grantedWithMods).
+        GRANTED = [0, 1].freeze
+        REQUEST_TYPE = "application/timestamp-query"
+        REPLY_TYPE = "application/timestamp-reply"
+
+        attr_reader :url, :hash
+
+        # The timestamp for `spec`: a URL String, a Hash of OPTIONS, or nil.
+        def self.for(spec)
+          return unless spec
+
+          spec = { url: spec.to_s } unless spec.is_a?(Hash)
+          spec = spec.transform_keys(&:to_sym)
+          unknown = spec.keys - OPTIONS
+          unless unknown.empty?
+            raise ArgumentError, "unknown timestamp option: #{unknown.join(", ")} (use #{OPTIONS.join(", ")})"
+          end
+
+          new(**spec)
+        end
+
+        def initialize(url: nil, username: nil, password: nil, hash: :sha256, client: nil)
+          raise ArgumentError, "sign timestamp: needs the TSA's url:" if url.to_s.empty? && client.nil?
+
+          @url = url&.to_s
+          @username = username
+          @password = password
+          @hash = hash.to_sym
+          @client = client
+          return if DIGESTS[@hash]
+
+          raise ArgumentError,
+                "timestamp hash: is #{DIGESTS.keys.join(", ")}, got #{hash.inspect}"
+        end
+
+        # The timestamp token (a ContentInfo, DER) the TSA issued over
+        # `signature`, checked against what was asked.
+        def token(signature)
+          request = request_for(OpenSSL::Digest.digest(DIGESTS.fetch(@hash), signature))
+          response = parse((@client || method(:post)).call(request.to_der))
+          check!(response, request)
+          response.token.to_der
+        end
+
+        private
+
+        def request_for(digest)
+          request = OpenSSL::Timestamp::Request.new
+          request.algorithm = DIGESTS.fetch(@hash)
+          request.message_imprint = digest
+          request.nonce = OpenSSL::BN.rand(64)
+          request.cert_requested = true
+          request
+        end
+
+        def parse(der)
+          OpenSSL::Timestamp::Response.new(der.to_s)
+        rescue OpenSSL::Timestamp::TimestampError, TypeError => e
+          raise SignatureError, "#{tsa} did not answer with a timestamp response: #{e.message}"
+        end
+
+        def check!(response, request)
+          status = response.status.to_i
+          unless GRANTED.include?(status) && response.token
+            text = [*response.status_text, response.failure_info].compact.map(&:to_s).reject(&:empty?)
+            raise SignatureError,
+                  "#{tsa} refused the timestamp (status #{status}#{": #{text.join(", ")}" unless text.empty?})"
+          end
+
+          info = response.token_info
+          raise SignatureError, "#{tsa} answered another request (nonce differs)" unless info.nonce == request.nonce
+          return if info.message_imprint == request.message_imprint
+
+          raise SignatureError, "#{tsa} timestamped something else (message imprint differs)"
+        end
+
+        def tsa = "timestamp: #{@url || "the TSA"}"
+
+        # POSTs the request as RFC 3161 over HTTP asks for it.
+        def post(body)
+          require "net/http"
+          uri = URI.parse(@url)
+          request = Net::HTTP::Post.new(uri)
+          request["Content-Type"] = REQUEST_TYPE
+          request["Accept"] = REPLY_TYPE
+          request.basic_auth(@username, @password.to_s) if @username
+          request.body = body
+          response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+          raise SignatureError, "#{tsa} answered HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+          response.body
+        rescue SystemCallError, IOError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError => e
+          raise SignatureError, "#{tsa} could not be reached: #{e.message}"
+        end
+      end
+    end
+  end
+end