def __init__(self, address, port):
"""
RPMDispatcher constructor.
Initialized instance vars and registers this server with the frontend
server.
@param address: Address of this dispatcher server.
@param port: Port assigned to this dispatcher server.
@raise RPMInfrastructureException: Raised if the dispatch server is
unable to register with the frontend
server.
"""
self._address = address
self._port = port
self._lock = threading.Lock()
self._worker_dict = {}
# We assume that the frontend server and dispatchers are running on the
# same host, and the frontend server is listening for connections from
# the external world.
frontend_server_port = rpm_config.getint('RPM_INFRASTRUCTURE',
'frontend_port')
self._frontend_server = 'http://%s:%d' % (socket.gethostname(),
frontend_server_port)
logging.info(
'Registering this rpm dispatcher with the frontend '
'server at %s.', self._frontend_server)
client = xmlrpclib.ServerProxy(self._frontend_server)
# De-register with the frontend when the dispatcher exit's.
atexit.register(self._unregister)
try:
client.register_dispatcher(self._get_serveruri())
except socket.error as er:
err_msg = ('Unable to register with frontend server. Error: %s.' %
errno.errorcode[er.errno])
logging.error(err_msg)
raise RPMInfrastructureException(err_msg)
import os
import pexpect
import Queue
import re
import threading
import time
from config import rpm_config
import dli_urllib
import rpm_logging_config
import common
from autotest_lib.client.common_lib import error
from autotest_lib.client.common_lib.cros import retry
RPM_CALL_TIMEOUT_MINS = rpm_config.getint('RPM_INFRASTRUCTURE',
'call_timeout_mins')
SET_POWER_STATE_TIMEOUT_SECONDS = rpm_config.getint(
'RPM_INFRASTRUCTURE', 'set_power_state_timeout_seconds')
PROCESS_TIMEOUT_BUFFER = 30
class RPMController(object):
"""
This abstract class implements RPM request queueing and
processes queued requests.
The actual interaction with the RPM device will be implemented
by the RPM specific subclasses.
It assumes that you know the RPM hostname and that the device is on
the specified RPM.
# found in the LICENSE file.
import argparse
import logging
import sys
import xmlrpclib
import common
from config import rpm_config
from autotest_lib.client.common_lib import global_config
from autotest_lib.client.common_lib.cros import retry
RPM_FRONTEND_URI = global_config.global_config.get_config_value(
'CROS', 'rpm_frontend_uri', type=str, default='')
RPM_CALL_TIMEOUT_MINS = rpm_config.getint('RPM_INFRASTRUCTURE',
'call_timeout_mins')
POWERUNIT_HOSTNAME_KEY = 'powerunit_hostname'
POWERUNIT_OUTLET_KEY = 'powerunit_outlet'
HYDRA_HOSTNAME_KEY = 'hydra_hostname'
class RemotePowerException(Exception):
"""This is raised when we fail to set the state of the device's outlet."""
pass
def set_power(host, new_state, timeout_mins=RPM_CALL_TIMEOUT_MINS):
"""Sends the power state change request to the RPM Infrastructure.
@param host: A CrosHost or ServoHost instance.
DISPATCHER_URI = 1
LOG_FILENAME_FORMAT = rpm_config.get('GENERAL', 'frontend_logname_format')
DEFAULT_RPM_ID = rpm_config.get('RPM_INFRASTRUCTURE', 'default_rpm_id')
# Valid state values.
VALID_STATE_VALUES = ['ON', 'OFF', 'CYCLE']
# Servo-interface mapping file
MAPPING_FILE = os.path.join(
os.path.dirname(__file__),
rpm_config.get('CiscoPOE', 'servo_interface_mapping_file'))
# Size of the LRU that holds power management unit information related
# to a device, e.g. rpm_hostname, outlet, hydra_hostname, etc.
LRU_SIZE = rpm_config.getint('RPM_INFRASTRUCTURE', 'lru_size')
class RPMFrontendServer(object):
"""
This class is the frontend server of the RPM Infrastructure. All clients
will send their power state requests to this central server who will
forward the requests to an avaliable or already assigned RPM dispatcher
server.
Once the dispatcher processes the request it will return the result
to this frontend server who will send the result back to the client.
All calls to this server are blocking.
@var _dispatcher_minheap: Min heap that returns a list of format-
# found in the LICENSE file.
import mox
import socket
import unittest
from config import rpm_config
import rpm_dispatcher
DUT_SAME_RPM1 = 'chromeos-rack8e-hostbs1'
DUT_SAME_RPM2 = 'chromeos-rack8e-hostbs2'
RPM_HOSTNAME = 'chromeos-rack8e-rpm1'
DUT_DIFFERENT_RPM = 'chromeos-rack1-hostbs1'
FAKE_DISPATCHER_URI = 'fake-dispatcher'
FAKE_DISPATCHER_PORT = 9999
FRONT_END_PORT = rpm_config.getint('RPM_INFRASTRUCTURE', 'frontend_port')
PROPER_URI_FORMAT = 'http://%s:%d'
class TestRPMDispatcher(mox.MoxTestBase):
"""
Simple unit tests to verify that the RPM Dispatcher properly registers with
the frontend server, and also initializes and reuses the same RPM Controller
for DUT requests on the same RPM.
queue_request is the only public method of RPM Dispatcher, however its logic
is simple and relies mostly on the private methods; therefore, I am testing
primarily RPMDispatcher initialization and _get_rpm_controller (which calls
_create_rpm_controller) to verify correct implementation.
"""
def setUp(self):