blob: 0b07c2624f6d51ce5f099c1f2db21dbd1ab0dfe8 [file] [log] [blame]
#!/usr/bin/env python
# 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.
"""This file starts a server for factory shop floor system.
To use it, invoke as a standalone program and assign the shop floor system
module you want to use (modules are located in "shopfloor" subdirectory).
Example:
./shopfloor_server -m cros.factory.shopfloor.simple_shopfloor
"""
import glob
import logging
import optparse
import os
import shutil
import SimpleXMLRPCServer
import signal
import socket
import SocketServer
import threading
import time
from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
import factory_common # pylint: disable=W0611
from cros.factory import shopfloor
from cros.factory.utils import debug_utils
from cros.factory.utils import net_utils
DEFAULT_SERVER_PORT = 8082
# By default, this server is supposed to serve on same host running omaha
# server, accepting connections from client devices; so the address to bind is
# "all interfaces (0.0.0.0)". For partners running server on clients, they may
# want to change address to "localhost".
_DEFAULT_SERVER_ADDRESS = '0.0.0.0'
# File containing name of default shopfloor module
SHOPFLOOR_MODULE_TXT = 'shopfloor_module.txt'
# Environment variables that can be used to set shop floor sever address and
# port.
SHOPFLOOR_ADDR_ENV_VAR = 'CROS_SHOPFLOOR_ADDR'
SHOPFLOOR_PORT_ENV_VAR = 'CROS_SHOPFLOOR_PORT'
# pylint: disable=W0212
def _LoadShopFloorModule(module_name):
"""Loads a specified python module.
Args:
module_name: Name of module containing a ShopFloor class.
Returns:
Module reference.
"""
logging.debug('_LoadShopFloorModule: trying %s', module_name)
return __import__(module_name, fromlist=['ShopFloor']).ShopFloor
def _LoadFactoryUpdater(updater_name):
"""Loads factory updater module.
Args:
updater_name: Name of updater module containing a FactoryUpdateServer class.
Returns:
Module reference.
"""
logging.debug('_LoadUpdater: trying %s', updater_name)
return __import__(updater_name,
fromlist=['FactoryUpdater']).FactoryUpdater
class MyXMLRPCServer(SocketServer.ThreadingMixIn,
SimpleXMLRPCServer):
"""XML/RPC server subclass that logs method calls."""
# For saving method name and exception between _marshaled_dispatch and
# _dispatch.
local = threading.local()
def _marshaled_dispatch( # pylint: disable=W0221
self, data, dispatch_method=None, path=None):
self.local.method = None
self.local.exception = None
response_data = ''
start_time = time.time()
try:
extra_args = [path] if path else []
response_data = SimpleXMLRPCServer._marshaled_dispatch(
self, data, dispatch_method, *extra_args)
return response_data
finally:
logging.info('%s %s [%.3f s, %d B in, %d B out]%s',
self.local.client_address[0],
self.local.method,
time.time() - start_time,
len(data),
len(response_data),
(': %s' % self.local.exception
if self.local.exception else ''))
def _dispatch(self, method, params):
try:
self.local.method = method
return SimpleXMLRPCServer._dispatch(self, method, params)
except:
logging.exception('Exception in method %s', method)
self.local.exception = debug_utils.FormatExceptionOnly()
raise
class MyXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
def do_POST(self):
MyXMLRPCServer.local.client_address = self.client_address
SimpleXMLRPCRequestHandler.do_POST(self)
def _GetServer(address, port, instance):
"""Get a XML-RPC server in given address and port.
Args:
address: Address to bind server.
port: Port for server to listen.
instance: Server instance for incoming XML RPC requests.
Returns:
The XML-RPC server.
"""
server = MyXMLRPCServer((address, port),
MyXMLRPCRequestHandler,
allow_none=True,
logRequests=False)
server.register_introspection_functions()
server.register_instance(instance)
return server
def GetDefaultShopFloorModule():
"""Returns the default shopfloor module.
This is read from SHOPFLOOR_MODULE_TXT; if that file does not
exist, then cros.factory.shopfloor is used.
"""
module_txt = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
SHOPFLOOR_MODULE_TXT)
if os.path.exists(module_txt):
with open(module_txt) as f:
return f.read().strip()
return 'cros.factory.shopfloor'
def main():
"""Main entry when being invoked by command line."""
default_data_dir = 'shopfloor_data'
external_updater_dir = 'updates'
if not os.path.exists(default_data_dir) and (
'CROS_WORKON_SRCROOT' in os.environ):
default_data_dir = os.path.join(
os.environ['CROS_WORKON_SRCROOT'],
'src', 'platform', 'factory', 'shopfloor_data')
parser = optparse.OptionParser()
parser.add_option('-a', '--address', dest='address', metavar='ADDR',
default=_DEFAULT_SERVER_ADDRESS,
help='address to bind (default: %default)')
parser.add_option('-p', '--port', dest='port', metavar='PORT', type='int',
default=DEFAULT_SERVER_PORT,
help='port to bind (default: %default)')
parser.add_option(
'-m', '--module', dest='module', metavar='MODULE',
default=GetDefaultShopFloorModule(),
help=('shop floor system module to load, in '
'PACKAGE.MODULE.CLASS format. E.g.: '
'cros.factory.shopfloor.simple_shopfloor '
'(default: %default; may be overridden with a file '
'called shopfloor_module.txt)'))
parser.add_option('-c', '--config', dest='config', metavar='CONFIG',
help='configuration data for shop floor system')
parser.add_option('-d', '--data-dir', dest='data_dir', metavar='DIR',
default=default_data_dir,
help=('data directory for shop floor system '
'(default: %default)'))
parser.add_option('-v', '--verbose', action='count', dest='verbose',
help='increase message verbosity')
parser.add_option('-q', '--quiet', action='store_true', dest='quiet',
help='turn off verbose messages')
parser.add_option(
'--auto-archive-logs', metavar='TEMPLATE',
default='/media/shopfloorlg/logs.DATE.tar.bz2',
help=("File in which to automatically archive previous few days' logs. "
"Logs will be archived if this path's parent exists. The format "
"must contain the string 'DATE'; this will be replaced with "
'the date. (default: %default)'))
parser.add_option(
'--auto-archive-logs-days', metavar='NUM_DAYS', type=int,
default=3, help="Number of previous days' logs to save to USB.")
parser.add_option('--simple', action='store_true',
help=('use simple shopfloor server (equivalent to '
'-m cros.factory.shopfloor.simple_shopfloor)'))
parser.add_option('--dummy', action='store_true',
help=('run dummy shopfloor server, using simple shopfloor '
'server and data from testdata directory (implies '
'--simple)'))
parser.add_option('-u', '--updater', dest='updater', metavar='UPDATER',
default=None,
help=('factory updater module to load, in'
'PACKAGE.MODULE.CLASS format. E.g.: '
'cros.factory.shopfloor.launcher.external_updater '
'(default: %default)'))
parser.add_option('--updater-dir', dest='updater_dir', metavar='UPDATE_DIR',
default=external_updater_dir,
help='external updater module dir. (default: %default)')
(options, args) = parser.parse_args()
if args:
parser.error('Invalid args: %s' % ' '.join(args))
if not options.module:
parser.error('You need to assign the module to be loaded (-m).')
verbosity_map = {0: logging.INFO,
1: logging.DEBUG}
verbosity = verbosity_map.get(options.verbose or 0, logging.NOTSET)
log_format = '%(asctime)s %(levelname)s '
if options.verbose > 0:
log_format += '(%(filename)s:%(lineno)d) '
log_format += '%(message)s'
logging.basicConfig(level=verbosity, format=log_format)
if options.quiet:
logging.disable(logging.INFO)
# If address and/or port are set in env variables, use them.
if os.environ.get(SHOPFLOOR_ADDR_ENV_VAR):
options.address = os.environ.get(SHOPFLOOR_ADDR_ENV_VAR)
if os.environ.get(SHOPFLOOR_PORT_ENV_VAR):
options.port = int(os.environ.get(SHOPFLOOR_PORT_ENV_VAR))
debug_utils.MaybeStartDebugServer()
# Disable all DNS lookups, since otherwise the logging code may try to
# resolve IP addresses, which may delay request handling.
def FakeGetFQDN(name=''):
return name or 'localhost'
socket.getfqdn = FakeGetFQDN
if options.dummy:
options.simple = True
if options.simple:
options.module = 'cros.factory.shopfloor.simple_shopfloor'
SHOPFLOOR_SUFFIX = '.ShopFloor'
if options.module.endswith(SHOPFLOOR_SUFFIX):
options.module = options.module[0:-len(SHOPFLOOR_SUFFIX)]
logging.warn("The value of the '-m' flag no longer needs to end with %r; "
"use '-m %s' instead", SHOPFLOOR_SUFFIX, options.module)
updater = None
if options.updater:
logging.debug('Loading factory updater: %s', options.updater)
updater = _LoadFactoryUpdater(options.updater)(options.updater_dir)
try:
logging.debug('Loading shop floor system module: %s', options.module)
instance = _LoadShopFloorModule(options.module)()
if not isinstance(instance, shopfloor.ShopFloorBase):
logging.critical('Module does not inherit ShopFloorBase: %s',
options.module)
exit(1)
instance.data_dir = options.data_dir
instance.config = options.config
instance.address = options.address
instance.port = options.port
# Shopfloor module contains update server in its base class. When it is
# configured to FastCGI mode, update server will be started by launcher.
instance._InitBase(options.auto_archive_logs,
options.auto_archive_logs_days,
updater=updater)
if options.dummy:
unused_root, ext, unused_path = __file__.partition('.par/')
if ext:
# Since testdata are not included in factory.par, we create an dummy
# devices.csv file here. This is for testing only.
with open(os.path.join(instance.data_dir,
os.path.basename('devices.csv')),
'w') as out:
out.write(
'# Dummy devices.csv file to make simple_shopfloor module happy.')
else:
pattern = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'testdata', '*.csv')
csvs = glob.glob(pattern)
if not csvs:
logging.critical('No test files matching %s', pattern)
exit(1)
for f in csvs:
logging.warn('Using data file %s from dummy shopfloor server', f)
shutil.copy(f, instance.data_dir)
instance.Init()
except: # pylint: disable=W0702
logging.exception('Failed loading module: %s', options.module)
exit(1)
def handler(signum, frame):
del signum, frame # Unused.
raise SystemExit
signal.signal(signal.SIGTERM, handler)
signal.signal(signal.SIGINT, handler)
server = _GetServer(
address=options.address, port=options.port, instance=instance)
try:
instance._StartBase()
logging.debug('Starting RPC server...')
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True
thread.start()
logging.info('Server started: http://%s:%s "%s" version %s',
options.address, options.port, instance.NAME,
instance.VERSION)
signal.pause()
finally:
logging.debug('Stopping RPC Server')
net_utils.ShutdownTCPServer(server)
thread.join()
instance._StopBase()
if __name__ == '__main__':
main()