| require 'weakref' |
| |
| module ASF |
| |
| class Mail |
| # return a Hash containing complete list of all known emails, and the |
| # ASF::Person that is associated with that email. |
| def self.list |
| begin |
| return Hash[@list.to_a] if @list |
| rescue NoMethodError, WeakRef::RefError |
| end |
| |
| list = Hash.new |
| |
| # load info from LDAP |
| people = ASF::Person.preload(['mail', 'asf-altEmail']) |
| people.each do |person| |
| (person.mail+person.alt_email).each do |mail| |
| list[mail.downcase] = person |
| end |
| end |
| |
| # load all member emails in one pass |
| ASF::Member.each do |id, text| |
| Member.emails(text).each do |mail| |
| list[mail.downcase] ||= Person.find(id) |
| end |
| end |
| |
| # load all ICLA emails in one pass |
| ASF::ICLA.each do |icla| |
| person = Person.find(icla.id) |
| list[icla.email.downcase] ||= person |
| next if icla.id == 'notinavail' |
| list["#{icla.id.downcase}@apache.org"] ||= person |
| end |
| |
| @list = WeakRef.new(list) |
| list |
| end |
| |
| # Parse the .archives file to get the list names |
| def self._load_lists |
| apmail_bin = ASF::SVN['apmail_bin'] |
| file = File.join(apmail_bin, '.archives') |
| if not @lists or File.mtime(file) != @list_mtime |
| lists = Hash[File.read(file).scan( |
| /^\s+"(\w[-\w]+)", "\/home\/apmail\/(public|private)-arch\// |
| )] |
| # Drop the infra test lists |
| lists.delete_if {|list| list =~ /-infra-[a-z]$/ or list == 'incubator-infra-dev' } |
| @lists = lists |
| @list_mtime = File.mtime(file) |
| end |
| end |
| |
| # get a list of all mailing lists. If <tt>public_private</tt> is |
| # <tt>false</tt> this will be a simple list. If <tt>public_private</tt> is |
| # <tt>true</tt>, return a Hash where the values are either <tt>public</tt> |
| # or <tt>private</tt>. |
| def self.lists(public_private=false) |
| Mail._load_lists |
| public_private ? @lists : @lists.keys |
| end |
| |
| def self.list_mtime |
| Mail._load_lists |
| @list_mtime |
| end |
| |
| # list of mailing lists that aren't actively seeking new subscribers |
| def self.deprecated |
| apmail_bin = ASF::SVN['apmail_bin'] |
| YAML.load_file(File.join(apmail_bin, 'deprecated_mailing_lists.yml')) |
| end |
| |
| def self.cannot_sub |
| self._load_auto() |
| @auto[:disallowed] |
| end |
| |
| def self.committers_allowed |
| self._load_auto() |
| @auto[:committers] |
| end |
| |
| def self.chairs_allowed |
| self._load_auto() |
| @auto[:chairs] |
| end |
| |
| def self.members_allowed |
| self._load_auto() |
| @auto[:members]+@auto[:chairs] |
| end |
| |
| # which lists are available for subscription via Whimsy? |
| # member: true if member |
| # pmc_chair: true if pmc_chair |
| # ldap_pmcs: list of (P)PMC mail_list names |
| # lid_only: return lid instead of [dom,list,lid] |
| # output is and array of entries: lid or [dom,list,lid] |
| def self.cansub(member, pmc_chair, ldap_pmcs, lidonly = true) |
| allowed = [] |
| parse_flags do |dom,list,f| |
| lid = archivelistid(dom,list) |
| next if self.cannot_sub.include? lid # probably unnecessary |
| cansub = false |
| modsub = isModSub?(f) |
| if not modsub # subs not moderated; allow all |
| cansub = true |
| elsif self.committers_allowed().include?(lid) # always allowed |
| cansub = true |
| else # subs are moderated |
| if member |
| if list == 'private' or self.members_allowed.include?(lid) |
| cansub = true |
| end |
| else |
| if ldap_pmcs |
| cansub = true if list == 'private' and ldap_pmcs.include? dom.sub('.apache.org','') |
| end |
| end |
| if pmc_chair and self.chairs_allowed.include? lid |
| cansub = true |
| end |
| end |
| if cansub |
| if lidonly |
| allowed << lid |
| else |
| allowed << [dom,list,lid] |
| end |
| end |
| end |
| allowed |
| end |
| |
| |
| # common configuration for sending mail; loads <tt>:sendmail</tt> |
| # configuration from <tt>~/.whimsy</tt> if available; otherwise default |
| # to disable openssl verification as that is what it required in order |
| # to work on the infrastructure provided whimsy-vm. |
| def self.configure |
| # fetch overrides |
| sendmail = ASF::Config.get(:sendmail) |
| |
| if sendmail |
| # convert string keys to symbols |
| options = Hash[sendmail.map {|key, value| [key.to_sym, value.untaint]}] |
| |
| # extract delivery method |
| method = options.delete(:delivery_method).to_sym |
| else |
| # provide defaults that work on whimsy-vm* infrastructure. Since |
| # procmail is configured with a self-signed certificate, verification |
| # isn't a possibility |
| method = :smtp |
| options = {openssl_verify_mode: 'none'} |
| end |
| |
| ::Mail.defaults do |
| delivery_method method, options |
| end |
| end |
| |
| # List of .qmail files that could clash with user ids (See: INFRA-14566) |
| def self.qmail_ids |
| return [] unless File.exist? '/srv/subscriptions/qmail.ids' |
| File.read('/srv/subscriptions/qmail.ids').split |
| end |
| |
| # Is the id used by qmail? |
| # See also ASF::ICLA.taken? |
| def self.taken?(id) |
| self.qmail_ids.include? id |
| end |
| |
| # Convert list name to form used in bin/.archives |
| def self.archivelistid(dom,list) |
| return "apachecon-#{list}" if dom == 'apachecon.com' |
| return list if dom == 'apache.org' |
| dom.sub(".apache.org",'-') + list |
| end |
| |
| # Canonicalise an email address, removing aliases and ignored punctuation |
| # and downcasing the name if safe to do so |
| # |
| # Currently only handles aliases for @gmail.com and @googlemail.com |
| # |
| # All domains are converted to lower-case |
| # |
| # The case of the name part is preserved since some providers may be case-sensitive |
| # Almost all providers ignore case in names, however that is not guaranteed |
| def self.to_canonical(email) |
| parts = email.split('@') |
| if parts.length == 2 |
| name, dom = parts |
| return email if name.length == 0 || dom.length == 0 |
| dom.downcase! |
| dom = 'gmail.com' if dom == 'googlemail.com' # same mailbox |
| if dom == 'gmail.com' |
| return name.sub(/\+.*/,'').gsub('.','').downcase + '@' + dom |
| else |
| # Effectively the same: |
| dom = 'apache.org' if dom == 'minotaur.apache.org' |
| # only downcase the domain (done above) |
| return name + '@' + dom |
| end |
| end |
| # Invalid; return input rather than failing |
| return email |
| end |
| |
| private |
| |
| # Load the auto-subscription file |
| def self._load_auto |
| apmail_bin = ASF::SVN['apmail_bin'] |
| auto_file = File.join(apmail_bin, 'mail_list_autosub.yml') |
| auto_mtime = File.mtime(auto_file) # fetch this up front in case file updated during loading |
| if not @auto or auto_mtime != @auto_mtime |
| @auto = YAML.load_file(auto_file) |
| @auto_mtime = auto_mtime |
| end |
| end |
| |
| |
| # Load the flags file |
| def self._load_flags |
| # flags for each mailing list |
| @list_flags ||= File.join(ASF::Config[:subscriptions], 'list-flags') |
| if not @flags or File.mtime(@list_flags) != @flags_mtime |
| lists = [] |
| File.open(@list_flags).each do |line| |
| if line.match(/^F:-([a-zA-Z]{26}) (\S+) (\S+)/) |
| flags,dom,list=$1,$2,$3 |
| next if list =~ /^infra-[a-z]$/ or (dom == 'incubator' and list == 'infra-dev') |
| lists << [dom,list,flags] |
| else |
| raise "Unexpected flags: #{line}" |
| end |
| end |
| @flags = lists |
| @flags_mtime = File.mtime(@list_flags) |
| end |
| end |
| |
| # parse the flags |
| # F:-aBcdeFgHiJklMnOpqrSTUVWXYz domain list |
| # Input: |
| # filter = RE to match against the flags, e.g. /s/ for subsmod |
| # Output: |
| # yields: domain, list, flags |
| def self.parse_flags(filter=nil) |
| self._load_flags() |
| @flags.each do |d,l,f| |
| next if filter and not f =~ filter |
| yield [d,l,f] |
| end |
| end |
| |
| # Do the flags indicate subscription moderation? |
| def self.isModSub?(flags) |
| flags.include? 's' |
| end |
| |
| end |
| |
| class Person < Base |
| # find a Person by email address |
| def self.find_by_email(value) |
| value.downcase! |
| |
| person = Mail.list[value] |
| return person if person |
| end |
| |
| # List of inactive email addresses: currently only contains the address in |
| # <tt>iclas.txt</tt> if it is not contained in the list of active email |
| # addresses. |
| def obsolete_emails |
| return @obsolete_emails if @obsolete_emails |
| result = [] |
| if icla |
| unless active_emails.any? {|mail| mail.downcase == icla.email.downcase} |
| result << icla.email |
| end |
| end |
| @obsolete_emails = result |
| end |
| |
| # Active emails: primary email address, alt email addresses, and |
| # member email addresses. |
| def active_emails |
| (mail + alt_email + member_emails).uniq |
| end |
| |
| # All known email addresses: includes active, obsolete, and apache.org |
| # email addresses. (But don't add notinavail@apache.org) |
| def all_mail |
| (active_emails + obsolete_emails + (id == 'notinavail' ? [] : ["#{id}@apache.org"])).uniq |
| end |
| end |
| |
| class Committee |
| # mailing list for this committee. Generally returns the first name in |
| # the dns (e.g. whimsical). If so, it can be prefixed by a number of |
| # list names (e.g. dev, private) and <tt>.apache.org</tt> is to be |
| # appended. In some cases, the name contains an <tt>@</tt> sign and |
| # is the full name for the mail list. |
| def mail_list |
| case name.downcase |
| when 'comdev' |
| 'community' |
| when 'httpcomponents' |
| 'hc' |
| when 'whimsy' |
| 'whimsical' |
| |
| when 'brandmanagement' |
| 'trademarks@apache.org' |
| when 'infrastructure' |
| 'infra' |
| when 'dataprivacy' |
| 'privacy@apache.org' |
| when 'legalaffairs' |
| 'legal-internal@apache.org' |
| when 'fundraising' |
| 'fundraising-private@apache.org' |
| when 'marketingandpublicity' |
| 'press@apache.org' |
| when 'tac' |
| 'travel-assistance@apache.org' |
| when 'w3crelations' |
| 'w3c@apache.org' |
| when 'concom' |
| 'planners@apachecon.com' |
| else |
| name |
| end |
| end |
| end |
| |
| class Podling |
| # base name used in constructing mailing list name. |
| def mail_list |
| case name.downcase |
| when 'odftoolkit' |
| 'odf' |
| else |
| name |
| end |
| end |
| end |
| |
| end |
