コード例 #1
0
ファイル: test_service.py プロジェクト: pratikmallya/otter
 def test_dont_filter_out_non_recently_converged(self):
     """
     If a group was converged in the past but not recently, it will be
     cleaned from the ``recently_converged`` map, and it will be converged.
     """
     # g1: converged a while ago; divergent -> removed and converged
     # g2: converged recently; not divergent -> not converged
     # g3: converged a while ago; not divergent -> removed and not converged
     eff = self._converge_all_groups(['00_g1'])
     sequence = [
         (ReadReference(ref=self.currently_converging), lambda i: pset([])),
         (Log('converge-all-groups',
              dict(group_infos=[self.group_infos[0]],
                   currently_converging=[])),
          noop),
         (ReadReference(ref=self.recently_converged),
          lambda i: pmap({'g1': 4, 'g2': 10, 'g3': 0})),
         (Func(time.time), lambda i: 20),
         (ModifyReference(self.recently_converged,
                          match_func("literally anything",
                                     pmap({'g2': 10}))),
          noop),
         parallel_sequence([[self._expect_group_converged('00', 'g1')]])
     ]
     self.assertEqual(perform_sequence(sequence, eff), ['converged g1!'])
コード例 #2
0
ファイル: test_service.py プロジェクト: pratikmallya/otter
 def test_record_recently_converged(self):
     """
     After converging, the group is added to ``recently_converged`` -- but
     *before* being removed from ``currently_converging``, to avoid race
     conditions.
     """
     currently = Reference(pset())
     recently = Reference(pmap())
     remove_from_currently = match_func(pset([self.group_id]), pset([]))
     sequence = [
         (ReadReference(currently), lambda i: pset()),
         add_to_currently(currently, self.group_id),
         (('ec', self.tenant_id, self.group_id, 3600),
          lambda i: (StepResult.SUCCESS, ScalingGroupStatus.ACTIVE)),
         (Func(time.time), lambda i: 100),
         add_to_recently(recently, self.group_id, 100),
         (ModifyReference(currently, remove_from_currently), noop),
         (DeleteNode(path='/groups/divergent/tenant-id_g1',
                     version=self.version), noop),
         (Log('mark-clean-success', {}), noop)
     ]
     eff = converge_one_group(
         currently, recently, self.tenant_id, self.group_id, self.version,
         3600, execute_convergence=self._execute_convergence)
     perform_sequence(sequence, eff)
コード例 #3
0
ファイル: test_service.py プロジェクト: pratikmallya/otter
 def test_unexpected_errors(self):
     """
     Unexpected exceptions log a non-fatal error and don't clean up the
     dirty flag.
     """
     converging = Reference(pset())
     recent = Reference(pmap())
     expected_error = RuntimeError('oh no!')
     sequence = [
         (ReadReference(converging), lambda i: pset()),
         add_to_currently(converging, self.group_id),
         (('ec', self.tenant_id, self.group_id, 3600),
          lambda i: raise_(expected_error)),
         (Func(time.time), lambda i: 100),
         add_to_recently(recent, self.group_id, 100),
         (ModifyReference(converging,
                          match_func(pset([self.group_id]), pset())),
          noop),
         (LogErr(CheckFailureValue(expected_error),
                 'converge-non-fatal-error', {}),
          noop),
     ]
     self._verify_sequence(sequence, converging=converging, recent=recent,
                           allow_refs=False)
コード例 #4
0
ファイル: test_service.py プロジェクト: pratikmallya/otter
def add_to_currently(currently, group_id):
    return (ModifyReference(currently,
                            match_func(pset(), pset([group_id]))),
            noop)
コード例 #5
0
ファイル: test_service.py プロジェクト: pratikmallya/otter
def add_to_recently(recently, group_id, cvg_time):
    return (ModifyReference(recently,
                            match_func(pmap(), pmap({group_id: cvg_time}))),
            noop)