def _start_mc(self): from mpfmc.core.mc import MpfMc # prevent sleep in clock Clock._max_fps = 0 mpf_config = ConfigProcessor.load_config_file( os.path.abspath( os.path.join(mpfmc.__path__[0], os.pardir, self.get_options()['mcconfigfile'])), 'machine') machine_path = self.getAbsoluteMachinePath() mpf_config = load_machine_config( Util.string_to_list(self.getConfigFile()), machine_path, mpf_config['mpf-mc']['paths']['config'], mpf_config) self.preprocess_config(mpf_config) self.mc = MpfMc(options=self.get_options(), config=mpf_config, machine_path=machine_path) from kivy.core.window import Window Window.create_window() Window.canvas.clear() self._start_app_as_slave()
def _start_mc(self): from mpfmc.core.mc import MpfMc # prevent sleep in clock Clock._max_fps = 0 machine_path = self.getAbsoluteMachinePath() self.mc = MpfMc(options=self.get_options(), machine_path=machine_path) from kivy.core.window import Window Window.create_window() Window.canvas.clear() self._start_app_as_slave()
def run(self, name): Clock._events = [[] for i in range(256)] self._test_started = time() self._test_name = self.id() self._test = name # This setup is done in run() because we need to give control to the # kivy event loop which we can only do by returning from the run() # that's called. So we override run() and setup mpf-mc and then call # our own run_test() on a callback. Then we can wait until the # environment is setup (which can take a few frames), then we call # super().run() to get the actual TestCase.run() method to run and # we return the results. # We have to do this in run() and not setUp() because run actually # calls setUp(), so since we were overriding it ours doesn't call it # so we just do our setup here since if we manually called setUp() then # it would be called again when we call super().run(). from mpf.core.player import Player Player.monitor_enabled = False mpf_config = ConfigProcessor.load_config_file( os.path.abspath( os.path.join(mpfmc.__path__[0], os.pardir, self.get_options()['mcconfigfile'])), 'machine') machine_path = os.path.abspath( os.path.join(mpfmc.__path__[0], os.pardir, 'mpfmc', self.get_machine_path())) mpf_config = load_machine_config( Util.string_to_list(self.get_config_file()), machine_path, mpf_config['mpf-mc']['paths']['config'], mpf_config) self.preprocess_config(mpf_config) self.mc = MpfMc(options=self.get_options(), config=mpf_config, machine_path=machine_path) self.patch_bcp() from kivy.core.window import Window Window.create_window() Window.canvas.clear() Clock.schedule_once(self.run_test, 0) self.mc.run()
def _start_mc(self): from mpfmc.core.mc import MpfMc # prevent sleep in clock Clock._max_fps = 0 machine_path = self.get_absolute_machine_path() config_loader = UnitTestConfigLoader(machine_path, self.machine.options['configfile'], {}, {}, {}) config = config_loader.load_mc_config() self.mc = MpfMc(config=config, options=self.get_options()) from kivy.core.window import Window Window.create_window() Window.canvas.clear() self._start_app_as_slave()
def setUp(self): # Most of the setup is done in run(). Explanation is there. Config._named_configs.pop('app', None) self._start_time = time() self._current_time = self._start_time Clock._start_tick = self._start_time Clock._last_tick = self._start_time Clock.time = self._mc_time # prevent sleep in clock Clock._max_fps = 0 # reset clock Clock._root_event = None from mpf.core.player import Player Player.monitor_enabled = False machine_path = self.get_absolute_machine_path() # load config config_loader = UnitTestConfigLoader(machine_path, [self.get_config_file()], {}, {}, {}) config = config_loader.load_mc_config() try: self.mc = MpfMc(options=self.get_options(), config=config) self.patch_bcp() from kivy.core.window import Window Window.create_window() Window.canvas.clear() self._start_app_as_slave() except Exception: if hasattr(self, "mc") and self.mc: # prevent dead locks with two asset manager threads self.mc.stop() raise
def setUp(self): # Most of the setup is done in run(). Explanation is there. Config._named_configs.pop('app', None) self._start_time = time() self._current_time = self._start_time Clock._start_tick = self._start_time Clock._last_tick = self._start_time Clock.time = self._mc_time # prevent sleep in clock Clock._max_fps = 0 Clock._events = [[] for i in range(256)] self._test_started = self._start_time from mpf.core.player import Player Player.monitor_enabled = False mpf_config = ConfigProcessor.load_config_file( os.path.abspath( os.path.join(mpfmc.__path__[0], os.pardir, self.get_options()['mcconfigfile'])), 'machine') machine_path = self.getAbsoluteMachinePath() mpf_config = load_machine_config( Util.string_to_list(self.get_config_file()), machine_path, mpf_config['mpf-mc']['paths']['config'], mpf_config) self.preprocess_config(mpf_config) self.mc = MpfMc(options=self.get_options(), config=mpf_config, machine_path=machine_path) self.patch_bcp() from kivy.core.window import Window Window.create_window() Window.canvas.clear() self._start_app_as_slave()
def setUp(self): # Most of the setup is done in run(). Explanation is there. Config._named_configs.pop('app', None) self._start_time = time() self._current_time = self._start_time Clock._start_tick = self._start_time Clock._last_tick = self._start_time Clock.time = self._mc_time # prevent sleep in clock Clock._max_fps = 0 Clock._events = [[] for i in range(256)] self._test_started = self._start_time from mpf.core.player import Player Player.monitor_enabled = False machine_path = self.getAbsoluteMachinePath() try: self.mc = MpfMc(options=self.get_options(), machine_path=machine_path) self.patch_bcp() from kivy.core.window import Window Window.create_window() Window.canvas.clear() self._start_app_as_slave() except Exception: if self.mc: # prevent dead locks with two asset manager threads self.mc.stop() raise
def __init__(self, mpf_path, machine_path, args): """Run MC.""" p = psutil.Process(os.getpid()) # increase priority slightly. this will keep MPF responsive when MC lags if sys.platform == "win32": p.nice(psutil.BELOW_NORMAL_PRIORITY_CLASS) else: p.nice(10) # undo all of Kivy's built-in logging so we can do it our way os.environ['KIVY_NO_FILELOG'] = '1' os.environ['KIVY_NO_CONSOLELOG'] = '1' from kivy.logger import Logger for handler in Logger.handlers: Logger.removeHandler(handler) sys.stderr = sys.__stderr__ # Need to have these in here because we don't want them to load when # the module is loaded as an mpf.command from mpf.core.utility_functions import Util del mpf_path parser = argparse.ArgumentParser( description='Starts the MPF Media Controller') parser.add_argument("-b", action="store_false", dest="bcp", default=True, help="Do not set up the BCP server threads") parser.add_argument( "-c", action="store", dest="configfile", default="config", metavar='config_file(s)', help="The name of a config file to load. Default is " "config.yaml. Multiple files can be used via a comma-" "separated list (no spaces between)") parser.add_argument( "-C", action="store", dest="mcconfigfile", default="mcconfig.yaml", metavar='config_file', help="The MPF framework default config file. Default is " "<mpf-mc install folder>/mcconfig.yaml") parser.add_argument("-f", action="store_true", dest="force_assets_load", default=False, help="Load all assets upon startup. Useful for " "ensuring all assets are set up properly " "during development.") parser.add_argument( "-l", action="store", dest="logfile", metavar='file_name', default=os.path.join( "logs", datetime.now().strftime("%Y-%m-%d-%H-%M-%S-mc-" + socket.gethostname() + ".log")), help="The name (and path) of the log file") parser.add_argument("-L", action="store", dest="mc_logfile", metavar='file_name', default=None, help="The name (and path) of the log file") parser.add_argument("-p", action="store_true", dest="pause", default=False, help="Pause the terminal window on exit. Useful " "when launching in a separate window so you can " "see any errors before the window closes.") parser.add_argument( "-P", action="store_true", dest="production", default=False, help= "Production mode. Will suppress errors, wait for hardware on start and " "try to exit when startup fails. Run this inside a loop.") parser.add_argument("-t", action="store_false", dest='text_ui', default=True, help="Use the ASCII text-based UI") parser.add_argument("-v", action="store_const", dest="loglevel", const=logging.DEBUG, default=logging.INFO, help="Enables verbose logging to the" " log file") parser.add_argument( "-V", action="store_true", dest="consoleloglevel", default=logging.INFO, help="Enables verbose logging to the console. Do NOT on " "Windows platforms") parser.add_argument("-a", action="store_true", dest="no_load_cache", help="Forces the config to be loaded from files " "and not cache") parser.add_argument("-A", action="store_false", dest="create_config_cache", help="Does not create the cache config files") # The following are just included for full compatibility with mpf.py # which is needed when using "mpf both". parser.add_argument("-x", action="store_const", dest="force_platform", const='virtual', help=argparse.SUPPRESS) parser.add_argument("-X", action="store_const", dest="force_platform", const='smart_virtual', help=argparse.SUPPRESS) args = parser.parse_args(args) args.configfile = Util.string_to_list(args.configfile) # Configure logging. Creates a logfile and logs to the console. # Formatting options are documented here: # https://docs.python.org/2.7/library/logging.html#logrecord-attributes try: os.makedirs(os.path.join(machine_path, 'logs')) except OSError as exception: if exception.errno != errno.EEXIST: raise if args.mc_logfile: args.logfile = args.mc_logfile full_logfile_path = os.path.join(machine_path, args.logfile) try: os.remove(full_logfile_path) except OSError: pass logging.basicConfig(level=args.loglevel, format='%(asctime)s : %(name)s : %(message)s', filename=full_logfile_path, filemode='a') # define a Handler which writes INFO messages or higher to the # sys.stderr if args.text_ui: console = logging.NullHandler() console.setLevel(logging.ERROR) else: console = logging.StreamHandler() console.setLevel(args.consoleloglevel) # set a format which is simpler for console use formatter = logging.Formatter('%(name)s: %(message)s') # tell the handler to use this format console.setFormatter(formatter) # add the handler to the root logger logging.getLogger('').addHandler(console) from mpfmc.core.mc import MpfMc logging.info("Loading MPF-MC controller") thread_stopper = threading.Event() try: MpfMc(options=vars(args), machine_path=machine_path, thread_stopper=thread_stopper).run() logging.info("MC run loop ended.") except Exception as e: # noqa logging.exception(str(e)) logging.info("Stopping child threads... (%s remaining)", len(threading.enumerate()) - 1) thread_stopper.set() while len(threading.enumerate()) > 1: time.sleep(.1) logging.info("All child threads stopped.") logging.shutdown() if args.pause: input('Press ENTER to continue...') sys.exit()
def __init__(self, mpf_path, machine_path, args): # undo all of Kivy's built-in logging so we can do it our way os.environ['KIVY_NO_FILELOG'] = '1' os.environ['KIVY_NO_CONSOLELOG'] = '1' from kivy.logger import Logger for handler in Logger.handlers: Logger.removeHandler(handler) sys.stderr = sys.__stderr__ # Need to have these in here because we don't want them to load when # the module is loaded as an mpf.command import mpfmc from mpf.core.utility_functions import Util from mpfmc.core.config_processor import ConfigProcessor from mpfmc.core.utils import set_machine_path, load_machine_config del mpf_path parser = argparse.ArgumentParser(description='Starts the MPF Media Controller') parser.add_argument("-b", action="store_false", dest="bcp", default=True, help="Do not set up the BCP server threads") parser.add_argument("-c", action="store", dest="configfile", default="config", metavar='config_file(s)', help="The name of a config file to load. Default is " "config.yaml. Multiple files can be used via a comma-" "separated list (no spaces between)") parser.add_argument("-C", action="store", dest="mcconfigfile", default="mcconfig.yaml", metavar='config_file', help="The MPF framework default config file. Default is " "<mpf-mc install folder>/mcconfig.yaml") parser.add_argument("-f", action="store_true", dest="force_assets_load", default=False, help="Load all assets upon startup. Useful for " "ensuring all assets are set up properly " "during development.") parser.add_argument("-l", action="store", dest="logfile", metavar='file_name', default=os.path.join("logs", datetime.now().strftime( "%Y-%m-%d-%H-%M-%S-mc-" + socket.gethostname() + ".log")), help="The name (and path) of the log file") parser.add_argument("-p", action="store_true", dest="pause", default=False, help="Pause the terminal window on exit. Useful " "when launching in a separate window so you can " "see any errors before the window closes.") parser.add_argument("-v", action="store_const", dest="loglevel", const=logging.DEBUG, default=logging.INFO, help="Enables verbose logging to the" " log file") parser.add_argument("-V", action="store_true", dest="consoleloglevel", default=logging.INFO, help="Enables verbose logging to the console. Do NOT on " "Windows platforms") # The following are just included for full compatibility with mpf.py # which is needed when using "mpf both". parser.add_argument("-a", action="store_const", dest="force_platform", const='no_load_cache', help=argparse.SUPPRESS) parser.add_argument("-A", action="store_const", dest="force_platform", const='create_config_cache', help=argparse.SUPPRESS) parser.add_argument("-x", action="store_const", dest="force_platform", const='virtual', help=argparse.SUPPRESS) parser.add_argument("-X", action="store_const", dest="force_platform", const='smart_virtual', help=argparse.SUPPRESS) args = parser.parse_args(args) args.configfile = Util.string_to_list(args.configfile) # Configure logging. Creates a logfile and logs to the console. # Formatting options are documented here: # https://docs.python.org/2.7/library/logging.html#logrecord-attributes try: os.makedirs(os.path.join(machine_path, 'logs')) except OSError as exception: if exception.errno != errno.EEXIST: raise logging.basicConfig(level=args.loglevel, format='%(asctime)s : %(levelname)s : %(name)s : ' '%(message)s', filename=os.path.join(machine_path, args.logfile), filemode='w') # define a Handler which writes INFO messages or higher to the # sys.stderr console = logging.StreamHandler() console.setLevel(args.consoleloglevel) # set a format which is simpler for console use formatter = logging.Formatter('%(levelname)s : %(name)s : %(message)s') # tell the handler to use this format console.setFormatter(formatter) # add the handler to the root logger logging.getLogger('').addHandler(console) mpf_config = ConfigProcessor.load_config_file(os.path.join( mpfmc.__path__[0], args.mcconfigfile), 'machine') machine_path = set_machine_path(machine_path, mpf_config['mpf-mc']['paths'][ 'machine_files']) mpf_config = load_machine_config(args.configfile, machine_path, mpf_config['mpf-mc']['paths'][ 'config'], mpf_config) self.preprocess_config(mpf_config) from mpfmc.core.mc import MpfMc logging.info("Loading MPF-MC controller") thread_stopper = threading.Event() try: MpfMc(options=vars(args), config=mpf_config, machine_path=machine_path, thread_stopper=thread_stopper).run() logging.info("MC run loop ended.") except Exception as e: logging.exception(str(e)) logging.info("Stopping child threads... (%s remaining)", len(threading.enumerate()) - 1) thread_stopper.set() while len(threading.enumerate()) > 1: time.sleep(.1) logging.info("All child threads stopped.") if args.pause: input('Press ENTER to continue...') sys.exit()