def getRecoveryActionsBasedOnOptions(self, gpEnv, gpArray):
     if self.__options.rebalanceSegments:
         return GpSegmentRebalanceOperation(gpEnv, gpArray)
     elif self.__options.recoveryConfigFile is not None:
         return self.getRecoveryActionsFromConfigFile(gpArray)
     else:
         return self.getRecoveryActionsFromConfiguration(gpEnv, gpArray)
示例#2
0
    def setUp(self):
        self.pool = Mock()
        self.pool.getCompletedItems.return_value = []

        self.apply_patches([
            patch("gppylib.commands.base.WorkerPool.__init__", return_value=None),
            patch("gppylib.commands.base.WorkerPool", return_value=self.pool),
            patch('gppylib.programs.clsRecoverSegment.GpRecoverSegmentProgram'),
        ])

        self.mock_gp_recover_segment_prog_class = self.get_mock_from_apply_patch('GpRecoverSegmentProgram')
        self.mock_parser = Mock()
        self.mock_gp_recover_segment_prog_class.createParser.return_value = self.mock_parser
        self.mock_parser.parse_args.return_value = (Mock(), Mock())
        self.mock_gp_recover_segment_prog = Mock()
        self.mock_gp_recover_segment_prog_class.createProgram.return_value = self.mock_gp_recover_segment_prog

        self.failure_command_mock = Mock()
        self.failure_command_mock.get_results.return_value = CommandResult(
            1, b"stdout failure text", b"stderr text", True, False)

        self.success_command_mock = Mock()
        self.success_command_mock.get_results.return_value = CommandResult(
            0, b"stdout success text", b"stderr text", True, False)

        self.subject = GpSegmentRebalanceOperation(Mock(), self._create_gparray_with_2_primary_2_mirrors())
        self.subject.logger = Mock()
示例#3
0
    def getRecoveryActionsBasedOnOptions(self, gpEnv, gpArray):
        if self.__options.rebalanceSegments:
            return GpSegmentRebalanceOperation(gpEnv, gpArray,
                                               self.__options.parallelDegree,
                                               self.__options.parallelPerHost)
        else:
            segs_with_persistent_mirroring_disabled = []
            self._output_segments_with_persistent_mirroring_disabled(
                segs_with_persistent_mirroring_disabled)

            instance = clsRecoverSegment_triples.MirrorBuilderFactory.instance(
                gpArray, self.__options.recoveryConfigFile,
                self.__options.newRecoverHosts, self.logger)
            segs = []
            for t in instance.getMirrorTriples():
                #TODO pass just t to GpMirrorToBuild
                segs.append(
                    GpMirrorToBuild(t.failed, t.live, t.failover,
                                    self.__options.forceFullResynchronization))

            return GpMirrorListToBuild(
                segs,
                self.__pool,
                self.__options.quiet,
                self.__options.parallelDegree,
                instance.getInterfaceHostnameWarnings(),
                forceoverwrite=True,
                progressMode=self.getProgressMode(),
                parallelPerHost=self.__options.parallelPerHost)
示例#4
0
 def getRecoveryActionsBasedOnOptions(self, gpEnv, gpArray):
     if self.__options.rebalanceSegments:
         return GpSegmentRebalanceOperation(gpEnv, gpArray, self.__options.parallelDegree, self.__options.parallelPerHost)
     else:
         instance = RecoveryTripletsFactory.instance(gpArray, self.__options.recoveryConfigFile, self.__options.newRecoverHosts)
         segs = [GpMirrorToBuild(t.failed, t.live, t.failover, self.__options.forceFullResynchronization) for t in instance.getTriplets()]
         return GpMirrorListToBuild(segs, self.__pool, self.__options.quiet,
                                    self.__options.parallelDegree,
                                    instance.getInterfaceHostnameWarnings(),
                                    forceoverwrite=True,
                                    progressMode=self.getProgressMode(),
                                    parallelPerHost=self.__options.parallelPerHost)