Class: Codily::Engine

Inherits:
Object
  • Object
show all
Defined in:
lib/codily/engine.rb

Constant Summary collapse

ORDER = 
[
  Elements::Service,
  Elements::Settings,
  Elements::Condition,
  Elements::Backend,
  Elements::CacheSetting,
  Elements::Dictionary,
  Elements::Domain,
  Elements::Gzip,
  Elements::Header,
  Elements::Healthcheck,
  Elements::RequestSetting,
  Elements::ResponseObject,
  Elements::Vcl,
]

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(fastly, present, desired, service_filter: nil, activate: false) ⇒ Engine

Returns a new instance of Engine.



20
21
22
23
24
25
26
27
 
# File 'lib/codily/engine.rb', line 20

def initialize(fastly, present, desired, service_filter: nil, activate: false)
  @fastly = fastly
  @present = present
  @desired = desired

  @service_filter = service_filter
  @activate = activate
end

Instance Attribute Details

#activate ⇒ Object (readonly)

Returns the value of attribute activate.



29
30
31
 
# File 'lib/codily/engine.rb', line 29

def activate
  @activate
end

#desired ⇒ Object (readonly)

Returns the value of attribute desired.



29
30
31
 
# File 'lib/codily/engine.rb', line 29

def desired
  @desired
end

#fastly ⇒ Object (readonly)

Returns the value of attribute fastly.



29
30
31
 
# File 'lib/codily/engine.rb', line 29

def fastly
  @fastly
end

#present ⇒ Object (readonly)

Returns the value of attribute present.



29
30
31
 
# File 'lib/codily/engine.rb', line 29

def present
  @present
end

#service_filter ⇒ Object (readonly)

Returns the value of attribute service_filter.



29
30
31
 
# File 'lib/codily/engine.rb', line 29

def service_filter
  @service_filter
end

Instance Method Details

#affected_services ⇒ Object 



163
164
165
166
167
168
 
# File 'lib/codily/engine.rb', line 163

def affected_services
  [*creations, *removals, *updates.map(&:first)].
    select { |_| _.parent_class == Elements::Service }.
    map(&:parent_key).
    uniq
end

#creations ⇒ Object 



130
131
132
133
134
135
 
# File 'lib/codily/engine.rb', line 130

def creations
  @creations ||= begin
    new_keys = desired_element_keys - present_element_keys
    sort_elements(new_keys.map{ |_| desired.elements[_[0]][_[1]] })
  end
end

#removals ⇒ Object 



156
157
158
159
160
161
 
# File 'lib/codily/engine.rb', line 156

def removals
  @removals ||= begin
    removed_keys = present_element_keys - desired_element_keys
    sort_elements(removed_keys.map{ |_| present.elements[_[0]][_[1]] })
  end
end

#run(dry_run: false) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/codily/engine.rb', line 47

def run(dry_run: false)
  if dry_run
    puts "(dry-run)"
    puts
  end

  affected_services.each do |key|
    version = present.service_version_get(key)
    if !version[:dev]
      puts "CLONE VERSION: #{version[:name]}.#{version[:active]}"
      if !dry_run
        version[:dev] = fastly.get_version(version[:id], version[:active]).clone.number
      end
    end
  end

  puts

  creations.each do |new_element|
    puts "CREATE: #{new_element.inspect}"

    hash = new_element.as_hash

    if new_element.parent_class == Elements::Service
      service_version = present.service_version_get(new_element.service_name)
      hash[:service_id] = service_version[:id]
      hash[:version] = service_version[:dev]
    end

    unless dry_run
      new_obj = fastly.create(new_element.fastly_class, hash)

      if new_element.class == Elements::Service
        present.service_version_set(new_obj.name, new_obj.id, new_obj.versions)
      end
    end
  end

  updates.each do |present_elem, desired_elem|
    puts "UPDATE: - #{present_elem.inspect}"
    puts "        + #{desired_elem.inspect}"

    payload = UpdatePayload.new(name: present_elem.name, id: present_elem.id, hash: desired_elem.as_hash)
    if desired_elem.parent_class == Elements::Service
      service_version = present.service_version_get(desired_elem.service_name)
      payload.service_id = service_version[:id]
      payload.version_number = service_version[:dev]
    end

    unless dry_run
      fastly.update(desired_elem.fastly_class, payload)
    end
  end

  removals.each do |removed_element|
    puts "DELETE: #{removed_element.inspect}"

    unless dry_run
      removed_element.fastly_obj.delete!
    end
  end

  act_any = !affected_services.empty?

  unless act_any
    puts "No difference."
  end

  puts

  if activate
    affected_services.each do |id|
      version = present.service_version_get(id)
      puts "ACTIVATE VERSION: #{version[:name]}.#{version[:dev]}"
      if !dry_run
        fastly.get_version(version[:id], version[:dev]).activate!
      end
    end
  end

  act_any
end

#updates ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/codily/engine.rb', line 137

def updates
  @updates ||= begin
    common = present_element_keys & desired_element_keys

    present_existing = common.map{ |_| present.elements[_[0]][_[1]] }
    desired_existing = common.map{ |_| desired.elements[_[0]][_[1]] }

    raise '!?' if present_existing.size != desired_existing.size

    present_existing.zip(desired_existing).map do |present_elem, desired_elem|
      if present_elem.as_hash != desired_elem.as_hash
        [present_elem, desired_elem]
      else
        nil
      end
    end.compact.sort_by { |_| ORDER.index(_[0].class) }
  end
end