2016-11-15 10:56:29 -05:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2016-02-24 06:57:29 -05:00
|
|
|
class ProcessFeedService < BaseService
|
2016-02-20 16:53:20 -05:00
|
|
|
def call(body, account)
|
|
|
|
xml = Nokogiri::XML(body)
|
2016-11-13 13:12:40 -05:00
|
|
|
xml.encoding = 'utf-8'
|
2016-11-07 19:32:34 -05:00
|
|
|
|
|
|
|
update_author(xml, account)
|
|
|
|
process_entries(xml, account)
|
2016-03-24 21:13:30 -04:00
|
|
|
end
|
2016-02-20 16:53:20 -05:00
|
|
|
|
2016-03-24 21:13:30 -04:00
|
|
|
private
|
2016-02-28 08:26:26 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def update_author(xml, account)
|
2016-11-30 15:32:11 -05:00
|
|
|
return if xml.at_xpath('/xmlns:feed', xmlns: TagManager::XMLNS).nil?
|
|
|
|
UpdateRemoteProfileService.new.call(xml.at_xpath('/xmlns:feed', xmlns: TagManager::XMLNS), account, true)
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def process_entries(xml, account)
|
2016-11-30 15:32:11 -05:00
|
|
|
xml.xpath('//xmlns:entry', xmlns: TagManager::XMLNS).reverse_each.map { |entry| ProcessEntry.new.call(entry, account) }.compact
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-03-16 05:46:15 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
class ProcessEntry
|
|
|
|
def call(xml, account)
|
|
|
|
@account = account
|
|
|
|
@xml = xml
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
return if skip_unsupported_type?
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
case verb
|
|
|
|
when :post, :share
|
|
|
|
return create_status
|
|
|
|
when :delete
|
|
|
|
return delete_status
|
2016-02-23 19:28:53 -05:00
|
|
|
end
|
2016-11-18 17:19:38 -05:00
|
|
|
rescue ActiveRecord::RecordInvalid => e
|
|
|
|
Rails.logger.debug "Nothing was saved for #{id} because: #{e}"
|
|
|
|
nil
|
2016-03-24 21:13:30 -04:00
|
|
|
end
|
2016-02-24 18:17:01 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
private
|
2016-09-09 14:04:34 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def create_status
|
|
|
|
Rails.logger.debug "Creating remote status #{id}"
|
|
|
|
status = status_from_xml(@xml)
|
2016-11-05 10:20:05 -04:00
|
|
|
|
2017-01-13 20:22:16 -05:00
|
|
|
return if status.nil?
|
2017-01-20 12:31:49 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
if verb == :share
|
2016-11-30 15:32:11 -05:00
|
|
|
original_status = status_from_xml(@xml.at_xpath('.//activity:object', activity: TagManager::AS_XMLNS))
|
2016-11-07 19:32:34 -05:00
|
|
|
status.reblog = original_status
|
2016-11-08 13:37:08 -05:00
|
|
|
|
|
|
|
if original_status.nil?
|
|
|
|
status.destroy
|
|
|
|
return nil
|
2016-11-09 18:15:49 -05:00
|
|
|
elsif original_status.reblog?
|
|
|
|
status.reblog = original_status.reblog
|
2016-11-08 13:37:08 -05:00
|
|
|
end
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-09-09 14:04:34 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
status.save!
|
2016-11-21 03:56:01 -05:00
|
|
|
|
2016-11-22 11:32:51 -05:00
|
|
|
NotifyService.new.call(status.reblog.account, status) if status.reblog? && status.reblog.account.local?
|
2017-01-20 14:14:02 -05:00
|
|
|
# LinkCrawlWorker.perform_async(status.reblog? ? status.reblog_of_id : status.id)
|
2016-11-07 19:32:34 -05:00
|
|
|
Rails.logger.debug "Queuing remote status #{status.id} (#{id}) for distribution"
|
2016-03-24 22:22:26 -04:00
|
|
|
DistributionWorker.perform_async(status.id)
|
2016-11-07 19:32:34 -05:00
|
|
|
status
|
2016-03-24 21:13:30 -04:00
|
|
|
end
|
2016-02-28 15:22:56 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def delete_status
|
|
|
|
Rails.logger.debug "Deleting remote status #{id}"
|
|
|
|
status = Status.find_by(uri: id)
|
|
|
|
RemoveStatusService.new.call(status) unless status.nil?
|
|
|
|
nil
|
|
|
|
end
|
2016-10-14 14:14:53 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def skip_unsupported_type?
|
|
|
|
!([:post, :share, :delete].include?(verb) && [:activity, :note, :comment].include?(type))
|
|
|
|
end
|
2016-02-28 15:22:56 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def status_from_xml(entry)
|
|
|
|
# Return early if status already exists in db
|
|
|
|
status = find_status(id(entry))
|
|
|
|
return status unless status.nil?
|
|
|
|
|
2016-11-09 18:15:49 -05:00
|
|
|
# If status embeds an author, find that author
|
|
|
|
# If that author cannot be found, don't record the status (do not misattribute)
|
|
|
|
if account?(entry)
|
|
|
|
begin
|
|
|
|
account = find_or_resolve_account(acct(entry))
|
|
|
|
return nil if account.nil?
|
|
|
|
rescue Goldfinger::Error
|
|
|
|
return nil
|
|
|
|
end
|
|
|
|
else
|
|
|
|
account = @account
|
2016-11-08 13:37:08 -05:00
|
|
|
end
|
|
|
|
|
2016-12-05 16:59:30 -05:00
|
|
|
return if account.suspended?
|
|
|
|
|
2016-11-15 10:56:29 -05:00
|
|
|
status = Status.create!(
|
2016-11-07 19:32:34 -05:00
|
|
|
uri: id(entry),
|
|
|
|
url: url(entry),
|
2016-11-08 13:37:08 -05:00
|
|
|
account: account,
|
2016-11-07 19:32:34 -05:00
|
|
|
text: content(entry),
|
2017-01-24 18:49:08 -05:00
|
|
|
spoiler_text: content_warning(entry),
|
2016-11-15 10:56:29 -05:00
|
|
|
created_at: published(entry)
|
|
|
|
)
|
2016-11-07 19:32:34 -05:00
|
|
|
|
|
|
|
if thread?(entry)
|
2016-11-08 13:37:08 -05:00
|
|
|
Rails.logger.debug "Trying to attach #{status.id} (#{id(entry)}) to #{thread(entry).first}"
|
2016-11-07 19:32:34 -05:00
|
|
|
status.thread = find_or_resolve_status(status, *thread(entry))
|
|
|
|
end
|
2016-09-26 10:42:38 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
mentions_from_xml(status, entry)
|
|
|
|
hashtags_from_xml(status, entry)
|
|
|
|
media_from_xml(status, entry)
|
2016-09-29 15:28:21 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
status
|
|
|
|
end
|
2016-02-28 15:22:56 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def find_or_resolve_account(acct)
|
|
|
|
FollowRemoteAccountService.new.call(acct)
|
|
|
|
end
|
2016-03-18 19:41:29 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def find_or_resolve_status(parent, uri, url)
|
|
|
|
status = find_status(uri)
|
2016-12-11 16:23:11 -05:00
|
|
|
|
2016-12-12 15:12:19 -05:00
|
|
|
ThreadResolveWorker.perform_async(parent.id, url) if status.nil?
|
2016-09-22 15:10:36 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
status
|
|
|
|
end
|
2016-09-26 10:42:38 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def find_status(uri)
|
|
|
|
if TagManager.instance.local_id?(uri)
|
|
|
|
local_id = TagManager.instance.unique_tag_to_local_id(uri, 'Status')
|
|
|
|
return Status.find(local_id)
|
2016-02-28 15:22:56 -05:00
|
|
|
end
|
2016-11-07 19:32:34 -05:00
|
|
|
|
|
|
|
Status.find_by(uri: uri)
|
2016-02-23 19:28:53 -05:00
|
|
|
end
|
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def mentions_from_xml(parent, xml)
|
|
|
|
processed_account_ids = []
|
2016-11-30 15:32:11 -05:00
|
|
|
public_visibility = false
|
2016-10-14 14:14:53 -04:00
|
|
|
|
2016-11-30 15:32:11 -05:00
|
|
|
xml.xpath('./xmlns:link[@rel="mentioned"]', xmlns: TagManager::XMLNS).each do |link|
|
|
|
|
if link['ostatus:object-type'] == TagManager::TYPES[:collection] && link['href'] == TagManager::COLLECTIONS[:public]
|
|
|
|
public_visibility = true
|
|
|
|
next
|
|
|
|
elsif link['ostatus:object-type'] == TagManager::TYPES[:group]
|
|
|
|
next
|
|
|
|
end
|
2016-09-05 12:39:53 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
url = Addressable::URI.parse(link['href'])
|
2016-09-22 14:42:20 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
mentioned_account = if TagManager.instance.local_domain?(url.host)
|
|
|
|
Account.find_local(url.path.gsub('/users/', ''))
|
|
|
|
else
|
|
|
|
Account.find_by(url: link['href']) || FetchRemoteAccountService.new.call(link['href'])
|
|
|
|
end
|
2016-09-29 15:28:21 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
next if mentioned_account.nil? || processed_account_ids.include?(mentioned_account.id)
|
2016-09-05 12:39:53 -04:00
|
|
|
|
2016-11-19 18:33:02 -05:00
|
|
|
mention = mentioned_account.mentions.where(status: parent).first_or_create(status: parent)
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-19 18:33:02 -05:00
|
|
|
# Notify local user
|
|
|
|
NotifyService.new.call(mentioned_account, mention) if mentioned_account.local?
|
2016-02-24 11:23:59 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
# So we can skip duplicate mentions
|
|
|
|
processed_account_ids << mentioned_account.id
|
|
|
|
end
|
2016-11-30 15:32:11 -05:00
|
|
|
|
|
|
|
parent.visibility = public_visibility ? :public : :unlisted
|
|
|
|
parent.save!
|
2016-03-19 14:20:07 -04:00
|
|
|
end
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def hashtags_from_xml(parent, xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
tags = xml.xpath('./xmlns:category', xmlns: TagManager::XMLNS).map { |category| category['term'] }.select { |t| !t.blank? }
|
2016-11-07 19:32:34 -05:00
|
|
|
ProcessHashtagsService.new.call(parent, tags)
|
Fix #24 - Thread resolving for remote statuses
This is a big one, so let me enumerate:
Accounts as well as stream entry pages now contain Link headers that
reference the Atom feed and Webfinger URL for the former and Atom entry
for the latter. So you only need to HEAD those resources to get that
information, no need to download and parse HTML <link>s.
ProcessFeedService will now queue ThreadResolveWorker for each remote
status that it cannot find otherwise. Furthermore, entries are now
processed in reverse order (from bottom to top) in case a newer entry
references a chronologically previous one.
ThreadResolveWorker uses FetchRemoteStatusService to obtain a status
and attach the child status it was queued for to it.
FetchRemoteStatusService looks up the URL, first with a HEAD, tests
if it's an Atom feed, in which case it processes it directly. Next
for Link headers to the Atom feed, in which case that is fetched
and processed. Lastly if it's HTML, it is checked for <link>s to the Atom
feed, and if such is found, that is fetched and processed. The account for
the status is derived from author/name attribute in the XML and the hostname
in the URL (domain). FollowRemoteAccountService and ProcessFeedService
are used.
This means that potentially threads are resolved recursively until a dead-end
is encountered, however it is performed asynchronously over background jobs,
so it should be ok.
2016-09-20 19:34:14 -04:00
|
|
|
end
|
2016-02-20 16:53:20 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def media_from_xml(parent, xml)
|
2017-01-23 15:36:08 -05:00
|
|
|
return if DomainBlock.find_by(domain: parent.account.domain)&.reject_media?
|
|
|
|
|
2016-11-30 15:32:11 -05:00
|
|
|
xml.xpath('./xmlns:link[@rel="enclosure"]', xmlns: TagManager::XMLNS).each do |link|
|
2016-11-07 19:32:34 -05:00
|
|
|
next unless link['href']
|
2016-03-16 05:46:15 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
media = MediaAttachment.where(status: parent, remote_url: link['href']).first_or_initialize(account: parent.account, status: parent, remote_url: link['href'])
|
2016-02-20 16:53:20 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
begin
|
|
|
|
media.file_remote_url = link['href']
|
|
|
|
media.save
|
2016-11-18 17:16:34 -05:00
|
|
|
rescue OpenURI::HTTPError, Paperclip::Errors::NotIdentifiedByImageMagickError
|
2016-11-07 19:32:34 -05:00
|
|
|
next
|
|
|
|
end
|
|
|
|
end
|
2016-02-20 16:53:20 -05:00
|
|
|
end
|
2016-02-24 11:23:59 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def id(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
xml.at_xpath('./xmlns:id', xmlns: TagManager::XMLNS).content
|
2016-02-24 11:23:59 -05:00
|
|
|
end
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def verb(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
raw = xml.at_xpath('./activity:verb', activity: TagManager::AS_XMLNS).content
|
|
|
|
TagManager::VERBS.key(raw)
|
2016-11-07 19:32:34 -05:00
|
|
|
rescue
|
|
|
|
:post
|
Fix #24 - Thread resolving for remote statuses
This is a big one, so let me enumerate:
Accounts as well as stream entry pages now contain Link headers that
reference the Atom feed and Webfinger URL for the former and Atom entry
for the latter. So you only need to HEAD those resources to get that
information, no need to download and parse HTML <link>s.
ProcessFeedService will now queue ThreadResolveWorker for each remote
status that it cannot find otherwise. Furthermore, entries are now
processed in reverse order (from bottom to top) in case a newer entry
references a chronologically previous one.
ThreadResolveWorker uses FetchRemoteStatusService to obtain a status
and attach the child status it was queued for to it.
FetchRemoteStatusService looks up the URL, first with a HEAD, tests
if it's an Atom feed, in which case it processes it directly. Next
for Link headers to the Atom feed, in which case that is fetched
and processed. Lastly if it's HTML, it is checked for <link>s to the Atom
feed, and if such is found, that is fetched and processed. The account for
the status is derived from author/name attribute in the XML and the hostname
in the URL (domain). FollowRemoteAccountService and ProcessFeedService
are used.
This means that potentially threads are resolved recursively until a dead-end
is encountered, however it is performed asynchronously over background jobs,
so it should be ok.
2016-09-20 19:34:14 -04:00
|
|
|
end
|
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def type(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
raw = xml.at_xpath('./activity:object-type', activity: TagManager::AS_XMLNS).content
|
|
|
|
TagManager::TYPES.key(raw)
|
2016-11-07 19:32:34 -05:00
|
|
|
rescue
|
|
|
|
:activity
|
|
|
|
end
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def url(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
link = xml.at_xpath('./xmlns:link[@rel="alternate"]', xmlns: TagManager::XMLNS)
|
2016-11-08 13:09:22 -05:00
|
|
|
link.nil? ? nil : link['href']
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-02-28 15:22:56 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def content(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
xml.at_xpath('./xmlns:content', xmlns: TagManager::XMLNS).content
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-02-24 11:23:59 -05:00
|
|
|
|
2017-01-24 18:49:08 -05:00
|
|
|
def content_warning(xml = @xml)
|
|
|
|
xml.at_xpath('./xmlns:content', xmlns: TagManager::XMLNS)['warning']
|
|
|
|
end
|
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def published(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
xml.at_xpath('./xmlns:published', xmlns: TagManager::XMLNS).content
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-02-24 11:23:59 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def thread?(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
!xml.at_xpath('./thr:in-reply-to', thr: TagManager::THR_XMLNS).nil?
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-02-23 19:28:53 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def thread(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
thr = xml.at_xpath('./thr:in-reply-to', thr: TagManager::THR_XMLNS)
|
2016-11-07 19:32:34 -05:00
|
|
|
[thr['ref'], thr['href']]
|
|
|
|
end
|
2016-02-23 21:05:40 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def account?(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
!xml.at_xpath('./xmlns:author', xmlns: TagManager::XMLNS).nil?
|
2016-11-07 19:32:34 -05:00
|
|
|
end
|
2016-02-24 18:17:01 -05:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
def acct(xml = @xml)
|
2016-11-30 15:32:11 -05:00
|
|
|
username = xml.at_xpath('./xmlns:author/xmlns:name', xmlns: TagManager::XMLNS).content
|
|
|
|
url = xml.at_xpath('./xmlns:author/xmlns:uri', xmlns: TagManager::XMLNS).content
|
2016-11-07 19:32:34 -05:00
|
|
|
domain = Addressable::URI.parse(url).host
|
2016-09-19 18:39:03 -04:00
|
|
|
|
2016-11-07 19:32:34 -05:00
|
|
|
"#{username}@#{domain}"
|
|
|
|
end
|
2016-09-19 18:39:03 -04:00
|
|
|
end
|
2016-02-20 16:53:20 -05:00
|
|
|
end
|