| # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging |
| |
| import pm_errors |
| import state_machine |
| |
| from autotest_lib.client.cros.cellular import mm1_constants |
| |
| class DisableMachine(state_machine.StateMachine): |
| """ |
| DisableMachine handles the state transitions involved in bringing the modem |
| to the DISABLED state. |
| |
| """ |
| def __init__(self, modem, return_cb, raise_cb): |
| super(DisableMachine, self).__init__(modem) |
| self.return_cb = return_cb |
| self.raise_cb = raise_cb |
| |
| |
| def _HandleConnectedState(self): |
| logging.info('DisableMachine: Modem is CONNECTED.') |
| assert self._modem.connect_step is None |
| # TODO(armansito): Pass a different raise_cb here to handle |
| # disconnect failure |
| logging.info('DisableMachine: Starting Disconnect.') |
| self._modem.Disconnect(mm1_constants.ROOT_PATH, DisableMachine.Step, |
| DisableMachine.Step, self) |
| return True |
| |
| |
| def _HandleConnectingState(self): |
| logging.info('DisableMachine: Modem is CONNECTING.') |
| assert self._modem.connect_step |
| logging.info('DisableMachine: Canceling connect.') |
| self._modem.connect_step.Cancel() |
| return True |
| |
| |
| def _HandleDisconnectingState(self): |
| logging.info('DisableMachine: Modem is DISCONNECTING.') |
| assert self._modem.disconnect_step |
| logging.info('DisableMachine: Waiting for disconnect.') |
| # wait until disconnect ends |
| return True |
| |
| |
| def _HandleRegisteredState(self): |
| logging.info('DisableMachine: Modem is REGISTERED.') |
| assert not self._modem.IsPendingRegister() |
| assert not self._modem.IsPendingEnable() |
| assert not self._modem.IsPendingConnect() |
| assert not self._modem.IsPendingDisconnect() |
| self._modem.UnregisterWithNetwork() |
| logging.info('DisableMachine: Setting state to DISABLING.') |
| reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED |
| self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_DISABLING, reason) |
| return True |
| |
| |
| def _HandleSearchingState(self): |
| logging.info('DisableMachine: Modem is SEARCHING.') |
| assert self._modem.register_step |
| assert not self._modem.IsPendingEnable() |
| assert not self._modem.IsPendingConnect() |
| logging.info('DisableMachine: Canceling register.') |
| self._modem.register_step.Cancel() |
| return True |
| |
| |
| def _HandleEnabledState(self): |
| logging.info('DisableMachine: Modem is ENABLED.') |
| assert not self._modem.IsPendingRegister() |
| assert not self._modem.IsPendingEnable() |
| assert not self._modem.IsPendingConnect() |
| logging.info('DisableMachine: Setting state to DISABLING.') |
| reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED |
| self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_DISABLING, reason) |
| return True |
| |
| |
| def _HandleDisablingState(self): |
| logging.info('DisableMachine: Modem is DISABLING.') |
| assert not self._modem.IsPendingRegister() |
| assert not self._modem.IsPendingEnable() |
| assert not self._modem.IsPendingConnect() |
| assert not self._modem.IsPendingDisconnect() |
| logging.info('DisableMachine: Setting state to DISABLED.') |
| reason = mm1_constants.MM_MODEM_STATE_CHANGE_REASON_USER_REQUESTED |
| self._modem.ChangeState(mm1_constants.MM_MODEM_STATE_DISABLED, reason) |
| self._modem.disable_step = None |
| if self.return_cb: |
| self.return_cb() |
| return False |
| |
| |
| def _GetModemStateFunctionMap(self): |
| return { |
| mm1_constants.MM_MODEM_STATE_CONNECTED: |
| DisableMachine._HandleConnectedState, |
| mm1_constants.MM_MODEM_STATE_CONNECTING: |
| DisableMachine._HandleConnectingState, |
| mm1_constants.MM_MODEM_STATE_DISCONNECTING: |
| DisableMachine._HandleDisconnectingState, |
| mm1_constants.MM_MODEM_STATE_REGISTERED: |
| DisableMachine._HandleRegisteredState, |
| mm1_constants.MM_MODEM_STATE_SEARCHING: |
| DisableMachine._HandleSearchingState, |
| mm1_constants.MM_MODEM_STATE_ENABLED: |
| DisableMachine._HandleEnabledState, |
| mm1_constants.MM_MODEM_STATE_DISABLING: |
| DisableMachine._HandleDisablingState |
| } |
| |
| |
| def _ShouldStartStateMachine(self): |
| if self._modem.disable_step and self._modem.disable_step != self: |
| # There is already a disable operation in progress. |
| message = 'Modem disable already in progress.' |
| logging.info(message) |
| raise pm_errors.MMCoreError(pm_errors.MMCoreError.IN_PROGRESS, |
| message) |
| elif self._modem.disable_step is None: |
| # There is no disable operation going in, cancelled or otherwise. |
| state = self._modem.Get(mm1_constants.I_MODEM, 'State') |
| if state == mm1_constants.MM_MODEM_STATE_DISABLED: |
| # The reason we're not raising an error here is that |
| # shill will make multiple successive calls to disable |
| # but WON'T check for raised errors, which causes |
| # problems. Treat this particular case as success. |
| logging.info('Already in a disabled state. Ignoring.') |
| if self.return_cb: |
| self.return_cb() |
| return False |
| |
| invalid_states = [ |
| mm1_constants.MM_MODEM_STATE_FAILED, |
| mm1_constants.MM_MODEM_STATE_UNKNOWN, |
| mm1_constants.MM_MODEM_STATE_INITIALIZING, |
| mm1_constants.MM_MODEM_STATE_LOCKED |
| ] |
| if state in invalid_states: |
| raise pm_errors.MMCoreError( |
| pm_errors.MMCoreError.WRONG_STATE, |
| ('Modem disable cannot be initiated while in state' |
| ' %u.') % state) |
| if self._modem.connect_step: |
| logging.info('There is an ongoing Connect, canceling it.') |
| self._modem.connect_step.Cancel() |
| if self._modem.register_step: |
| logging.info('There is an ongoing Register, canceling it.') |
| self._modem.register_step.Cancel() |
| if self._modem.enable_step: |
| # This needs to be done here, because the case where an enable |
| # cycle has been initiated but it hasn't triggered any state |
| # transitions yet would not be detected in a state handler. |
| logging.info('There is an ongoing Enable, canceling it.') |
| logging.info('This should bring the modem to a disabled state.' |
| ' DisableMachine will not start.') |
| self._modem.enable_step.Cancel() |
| assert self._modem.Get(mm1_constants.I_MODEM, 'State') == \ |
| mm1_constants.MM_MODEM_STATE_DISABLED |
| if self._modem.Get(mm1_constants.I_MODEM, 'State') == \ |
| mm1_constants.MM_MODEM_STATE_DISABLED: |
| if self.return_cb: |
| self.return_cb() |
| return False |
| |
| logging.info('Starting Disable.') |
| self._modem.disable_step = self |
| return True |
