Class: Entitlements::Backend::GitHubTeam::Provider

Inherits:
BaseProvider
  • Object
show all
Includes:
Contracts::Core
Defined in:
lib/entitlements/backend/github_team/provider.rb

Constant Summary collapse

C = 
::Contracts

Instance Method Summary collapse

Constructor Details

#initialize(config:) ⇒ Provider 



21
22
23
24
25
26
27
28
29
30
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 21

def initialize(config:)
  @github = Entitlements::Backend::GitHubTeam::Service.new(
    org: config.fetch("org"),
    addr: config.fetch("addr", nil),
    token: config.fetch("token"),
    ou: config.fetch("base")
  )

  @github_team_cache = {}
end

Instance Method Details

#auto_generate_ignored_users(entitlement_group) ⇒ Object 



145
146
147
148
149
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 145

def auto_generate_ignored_users(entitlement_group)
  org_members = github.org_members.keys.map(&:downcase)
  group_members = entitlement_group.member_strings.map(&:downcase)
  Set.new(group_members - org_members)
end

#change_ignored?(action) ⇒ Boolean 



111
112
113
114
115
116
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 111

def change_ignored?(action)
  return false if action.existing.nil?

  result = diff_existing_updated(action.existing, action.updated, action.ignored_users)
  result[:added].empty? && result[:removed].empty? && result[:metadata].nil?
end

#commit(entitlement_group) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 124

def commit(entitlement_group)
  github_team = github.read_team(entitlement_group)

  # Create the new team and invalidate the cache
  if github_team.nil?
    team_name = entitlement_group.cn.downcase
    github.create_team(entitlement_group: entitlement_group)
    github.invalidate_predictive_cache(entitlement_group)
    @github_team_cache.delete(team_name)
    github_team = github.read_team(entitlement_group)
  end
  github.sync_team(entitlement_group, github_team)
end

#diff(entitlement_group, ignored_users = Set.new) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 58

def diff(entitlement_group, ignored_users = Set.new)
  # The current value of the team from `read` might be based on the predictive cache
  # or on an actual API call. At this stage we don't care.
  team_identifier = entitlement_group.cn.downcase
  github_team_group = read(entitlement_group)
  if github_team_group.nil?
    github_team_group = create_github_team_group(entitlement_group)
  end

  result = diff_existing_updated(github_team_group, entitlement_group, ignored_users)

  # If there are no differences, return. (If we read from the predictive cache, we just saved ourselves a call
  # to the API. Hurray.)
  return result unless result[:added].any? || result[:removed].any? || result[:metadata]

  # If the group doesn't exist yet, we know we're not using the cache and we can save on any further API calls
  unless github_team_group.metadata_fetch_if_exists("team_id") == -999
    # There are differences so we don't want to use the predictive cache. Call to `from_predictive_cache?`
    # to determine whether our source of "current state" came from the predictive cache or from the API.
    # If it returns false, it came from the API, and we should just return what we got
    # (since pulling the data from the API again would be pointless).
    return result unless github.from_predictive_cache?(entitlement_group)

    # If `from_predictive_cache?` returned true, the data came from the predictive cache. We need
    # to invalidate the predictive cache entry, clean up the instance variable and re-read the refreshed data.
    github.invalidate_predictive_cache(entitlement_group)
    @github_team_cache.delete(team_identifier)
    github_team_group = read(entitlement_group)
  end

  # And finally, we have to calculate a new diff, which this time uses the fresh data from the API as
  # its basis, rather than the predictive cache.
  diff_existing_updated(github_team_group, entitlement_group, ignored_users)
end

#diff_existing_updated(existing_group, group, ignored_users = Set.new) ⇒ Object 



100
101
102
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 100

def diff_existing_updated(existing_group, group, ignored_users = Set.new)
  diff_existing_updated_metadata(existing_group, group, super)
end

#read(entitlement_group) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/entitlements/backend/github_team/provider.rb', line 39

def read(entitlement_group)
  slug = Entitlements::Util::Util.any_to_cn(entitlement_group.cn.downcase)
  return @github_team_cache[slug] if @github_team_cache[slug]

  github_team = github.read_team(entitlement_group)

  # We should not cache a team which does not exist
  return nil if github_team.nil?

  Entitlements.logger.debug "Loaded #{github_team.team_dn} (id=#{github_team.team_id}) with #{github_team.member_strings.count} member(s)"
  @github_team_cache[github_team.team_name] = github_team
end