예제 #1
0
파일: components.py 프로젝트: Woi/yadtshell
    def update(self, reboot_required=False, upgrade_packages=True):
        next_artefacts = [uri.replace('/', '-', 1)
                          for uri in self.next_artefacts]
        if not reboot_required:
            return self.remote_call('yadt-host-update %s' % ' '.join(next_artefacts),
                                    '%s_%s' % (self.hostname, yadtshell.settings.UPDATE))

        update_and_reboot_command = self.remote_call(
            'yadt-host-update -r %s' % ' '.join(next_artefacts if upgrade_packages else []),
            '%s_%s' % (self.hostname, yadtshell.settings.UPDATE))
        p = YadtProcessProtocol(self, update_and_reboot_command, out_log_level=logging.INFO)
        p.target_state = yadtshell.settings.UPTODATE
        p.state = yadtshell.settings.UNKNOWN

        def handle_rebooting_machine(failure, ssh_poll_max_seconds):
            if failure.value.exitCode == 152:
                raise yadtshell.actions.ActionException(
                    'Timed out while waiting for %s to reboot' % self.uri, 152)
            elif failure.value.exitCode == 255:
                logger.info("%s: rebooting now" % self.uri)
                return poll_rebooting_machine()
            return failure

        def poll_rebooting_machine(count=1):
            max_tries = calculate_max_tries_for_interval_and_delay(interval=self.ssh_poll_max_seconds,
                                                                   delay=yadtshell.constants.SSH_POLL_DELAY)
            logger.info("%s: polling for ssh connect, try %i of %i" %
                        (self.uri, count, max_tries))
            poll_command = self.remote_call('uptime', '%s_poll' % self.hostname)
            poll_protocol = YadtProcessProtocol(self, poll_command, out_log_level=logging.INFO)
            poll_protocol.ssh_poll_count = count
            if (count * yadtshell.constants.SSH_POLL_DELAY) < self.ssh_poll_max_seconds:
                poll_protocol.deferred.addErrback(
                    lambda x: task.deferLater(reactor,
                                              yadtshell.constants.SSH_POLL_DELAY,
                                              poll_rebooting_machine,
                                              count + 1)
                )
            cmdline = shlex.split(poll_protocol.cmd)
            reactor.spawnProcess(poll_protocol, cmdline[0], cmdline, None)

            return poll_protocol.deferred

        p.deferred.addErrback(handle_rebooting_machine, self.ssh_poll_max_seconds)

        def display_reboot_info(protocol):
            if hasattr(protocol, 'ssh_poll_count'):
                logger.info('%s: reboot took %d seconds' %
                            (self.uri, protocol.ssh_poll_count * yadtshell.constants.SSH_POLL_DELAY))
            return protocol
        p.deferred.addCallback(display_reboot_info)

        cmdline = shlex.split(p.cmd.encode('ascii'))
        reactor.spawnProcess(p, cmdline[0], cmdline, None)
        return p.deferred
예제 #2
0
    def test_out_received_should_append_data(self):
        mock_process_protocol = Mock(YadtProcessProtocol)
        mock_process_protocol.data = 'some-data-'
        mock_process_protocol.component = 'component'
        mock_process_protocol.out_log_level = 'info'
        mock_process_protocol.pi = None
        mock_logger = Mock()
        mock_process_protocol.logger = mock_logger

        YadtProcessProtocol.outReceived(mock_process_protocol, '-more-data')

        self.assertEqual(mock_process_protocol.data, 'some-data--more-data')
예제 #3
0
    def test_out_received_should_append_data(self):
        mock_process_protocol = Mock(YadtProcessProtocol)
        mock_process_protocol.data = 'some-data-'
        mock_process_protocol.component = 'component'
        mock_process_protocol.out_log_level = 'info'
        mock_process_protocol.pi = None
        mock_logger = Mock()
        mock_process_protocol.logger = mock_logger

        YadtProcessProtocol.outReceived(mock_process_protocol, '-more-data')

        self.assertEqual(mock_process_protocol.data, 'some-data--more-data')
예제 #4
0
    def test_stderr_should_update_progress_indicator_with_command_and_component(self):
        mock_progress_indicator = Mock()

        mock_process_protocol = Mock(YadtProcessProtocol)
        mock_process_protocol.data = ''
        mock_process_protocol.cmd = 'command'
        mock_process_protocol.component = 'component'
        mock_process_protocol.err_log_level = 'info'
        mock_process_protocol.pi = mock_progress_indicator
        mock_logger = Mock()
        mock_process_protocol.logger = mock_logger

        YadtProcessProtocol.errReceived(mock_process_protocol, 'data')

        mock_progress_indicator.update.assert_called_with(('command', 'component'))
예제 #5
0
    def test_stderr_should_update_progress_indicator_with_command_and_component(
            self):
        mock_progress_indicator = Mock()

        mock_process_protocol = Mock(YadtProcessProtocol)
        mock_process_protocol.data = ''
        mock_process_protocol.cmd = 'command'
        mock_process_protocol.component = 'component'
        mock_process_protocol.err_log_level = 'info'
        mock_process_protocol.pi = mock_progress_indicator
        mock_logger = Mock()
        mock_process_protocol.logger = mock_logger

        YadtProcessProtocol.errReceived(mock_process_protocol, 'data')

        mock_progress_indicator.update.assert_called_with(
            ('command', 'component'))
예제 #6
0
파일: components.py 프로젝트: Woi/yadtshell
        def poll_rebooting_machine(count=1):
            max_tries = calculate_max_tries_for_interval_and_delay(interval=self.ssh_poll_max_seconds,
                                                                   delay=yadtshell.constants.SSH_POLL_DELAY)
            logger.info("%s: polling for ssh connect, try %i of %i" %
                        (self.uri, count, max_tries))
            poll_command = self.remote_call('uptime', '%s_poll' % self.hostname)
            poll_protocol = YadtProcessProtocol(self, poll_command, out_log_level=logging.INFO)
            poll_protocol.ssh_poll_count = count
            if (count * yadtshell.constants.SSH_POLL_DELAY) < self.ssh_poll_max_seconds:
                poll_protocol.deferred.addErrback(
                    lambda x: task.deferLater(reactor,
                                              yadtshell.constants.SSH_POLL_DELAY,
                                              poll_rebooting_machine,
                                              count + 1)
                )
            cmdline = shlex.split(poll_protocol.cmd)
            reactor.spawnProcess(poll_protocol, cmdline[0], cmdline, None)

            return poll_protocol.deferred
    def status(self):
        status_command = self.remote_call(
            'yadt-service-%s %s' % (yadtshell.settings.STATUS, self.name),
            tag='%s_%s' % (self.name, yadtshell.settings.STATUS))
        status_protocol = YadtProcessProtocol(self,
                                              status_command,
                                              out_log_level=logging.DEBUG)
        cmdline = shlex.split(status_protocol.cmd)
        reactor.spawnProcess(status_protocol, cmdline[0], cmdline, None)

        return status_protocol.deferred
        def poll_rebooting_machine(count=1):
            max_tries = calculate_max_tries_for_interval_and_delay(
                interval=self.ssh_poll_max_seconds,
                delay=yadtshell.constants.SSH_POLL_DELAY)
            logger.info("%s: polling for ssh connect, try %i of %i" %
                        (self.uri, count, max_tries))
            poll_command = self.remote_call('uptime',
                                            '%s_poll' % self.hostname)
            poll_protocol = YadtProcessProtocol(self,
                                                poll_command,
                                                out_log_level=logging.INFO)
            poll_protocol.ssh_poll_count = count
            if (count * yadtshell.constants.SSH_POLL_DELAY
                ) < self.ssh_poll_max_seconds:
                poll_protocol.deferred.addErrback(lambda x: task.deferLater(
                    reactor, yadtshell.constants.SSH_POLL_DELAY,
                    poll_rebooting_machine, count + 1))
            cmdline = shlex.split(poll_protocol.cmd)
            reactor.spawnProcess(poll_protocol, cmdline[0], cmdline, None)

            return poll_protocol.deferred
    def update(self, reboot_required=False, upgrade_packages=True):
        next_artefacts = [
            uri.replace('/', '-', 1) for uri in self.next_artefacts
        ]
        if not reboot_required:
            return self.remote_call(
                'yadt-host-update %s' % ' '.join(next_artefacts),
                '%s_%s' % (self.hostname, yadtshell.settings.UPDATE))

        update_and_reboot_command = self.remote_call(
            'yadt-host-update -r %s' %
            ' '.join(next_artefacts if upgrade_packages else []),
            '%s_%s' % (self.hostname, yadtshell.settings.UPDATE))
        p = YadtProcessProtocol(self,
                                update_and_reboot_command,
                                out_log_level=logging.INFO)
        p.target_state = yadtshell.settings.UPTODATE
        p.state = yadtshell.settings.UNKNOWN

        def handle_rebooting_machine(failure, ssh_poll_max_seconds):
            if failure.value.exitCode == 152:
                raise yadtshell.actions.ActionException(
                    'Timed out while waiting for %s to reboot' % self.uri, 152)
            elif failure.value.exitCode == 255:
                logger.info("%s: rebooting now" % self.uri)
                return poll_rebooting_machine()
            return failure

        def poll_rebooting_machine(count=1):
            max_tries = calculate_max_tries_for_interval_and_delay(
                interval=self.ssh_poll_max_seconds,
                delay=yadtshell.constants.SSH_POLL_DELAY)
            logger.info("%s: polling for ssh connect, try %i of %i" %
                        (self.uri, count, max_tries))
            poll_command = self.remote_call('uptime',
                                            '%s_poll' % self.hostname)
            poll_protocol = YadtProcessProtocol(self,
                                                poll_command,
                                                out_log_level=logging.INFO)
            poll_protocol.ssh_poll_count = count
            if (count * yadtshell.constants.SSH_POLL_DELAY
                ) < self.ssh_poll_max_seconds:
                poll_protocol.deferred.addErrback(lambda x: task.deferLater(
                    reactor, yadtshell.constants.SSH_POLL_DELAY,
                    poll_rebooting_machine, count + 1))
            cmdline = shlex.split(poll_protocol.cmd)
            reactor.spawnProcess(poll_protocol, cmdline[0], cmdline, None)

            return poll_protocol.deferred

        p.deferred.addErrback(handle_rebooting_machine,
                              self.ssh_poll_max_seconds)

        def display_reboot_info(protocol):
            if hasattr(protocol, 'ssh_poll_count'):
                logger.info('%s: reboot took %d seconds' %
                            (self.uri, protocol.ssh_poll_count *
                             yadtshell.constants.SSH_POLL_DELAY))
            return protocol

        p.deferred.addCallback(display_reboot_info)

        cmdline = shlex.split(p.cmd.encode('ascii'))
        reactor.spawnProcess(p, cmdline[0], cmdline, None)
        return p.deferred