def __init__(self, config, logger):
super().__init__(config, logger)
self._volumes = memoize.PersistentDict()
self._volumes.make_permanent(
self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'volumes')
self._volumes.update(self._config.get('SUSHY_EMULATOR_VOLUMES', {}))
def initialize(cls, config, logger, *args, **kwargs):
cls._config = config
cls._logger = logger
cls._devices = memoize.PersistentDict()
if hasattr(cls._devices, 'make_permanent'):
cls._devices.make_permanent(
cls._config.get('SUSHY_EMULATOR_STATE_DIR'), 'vmedia')
device_types = cls._config.get('SUSHY_EMULATOR_VMEDIA_DEVICES')
if device_types is None:
device_types = {
u'Cd': {
u'Name': u'Virtual CD',
u'MediaTypes': [u'CD', u'DVD']
},
u'Floppy': {
u'Name': u'Virtual Removable Media',
u'MediaTypes': [u'Floppy', u'USBStick']
}
}
cls._device_types = device_types
return cls
def __init__(self, config, logger):
super().__init__(config, logger)
self._indicators = memoize.PersistentDict()
if hasattr(self._indicators, 'make_permanent'):
self._indicators.make_permanent(
self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'indicators')
self._indicators.update(
self._config.get('SUSHY_EMULATOR_INDICATOR_LEDS', {}))
def test___delitem__(self, mock_sqlite3, mock_pickle):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_pickle.dumps.return_value = 'pickled-key'
mock_connection = mock_sqlite3.connect.return_value
mock_cursor = mock_connection.cursor.return_value
del pd[1]
mock_cursor.execute.assert_called_with('delete from cache where key=?',
('pickled-key', ))
def test___iter__(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_conn = mock_sqlite3.return_value.__enter__.return_value
mock_cursor = mock_conn.cursor.return_value
mock_cursor.execute.reset_mock()
mock_cursor.fetchall.return_value = [[pickle.dumps('pickled-key')]]
self.assertEqual(['pickled-key'], list(iter(pd)))
mock_cursor.execute.assert_called_once_with('select key from cache')
def initialize(cls, config):
cls._config = config
cls._volumes = memoize.PersistentDict()
if hasattr(cls._volumes, 'make_permanent'):
cls._volumes.make_permanent(config.get('SUSHY_EMULATOR_STATE_DIR'),
'volumes')
cls._volumes.update(config.get('SUSHY_EMULATOR_VOLUMES', {}))
return cls
def test___delitem__(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_conn = mock_sqlite3.return_value.__enter__.return_value
mock_cursor = mock_conn.cursor.return_value
mock_cursor.execute.reset_mock()
del pd[1]
mock_cursor.execute.assert_called_once_with(
'delete from cache where key=?', (pickle.dumps(1), ))
def initialize(cls, config):
cls._config = config
cls._indicators = memoize.PersistentDict()
if hasattr(cls._indicators, 'make_permanent'):
cls._indicators.make_permanent(
config.get('SUSHY_EMULATOR_STATE_DIR'), 'indicators')
cls._indicators.update(
config.get('SUSHY_EMULATOR_INDICATOR_LEDS', {}))
return cls
def test___setitem__(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_conn = mock_sqlite3.return_value.__enter__.return_value
mock_cursor = mock_conn.cursor.return_value
mock_cursor.execute.reset_mock()
pd[1] = 2
mock_cursor.execute.assert_called_once_with(
'insert or replace into cache values (?, ?)',
(pickle.dumps(1), pickle.dumps(2)))
def test___len__(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_conn = mock_sqlite3.return_value.__enter__.return_value
mock_cursor = mock_conn.cursor.return_value
mock_cursor.execute.reset_mock()
mock_cursor.fetchone.return_value = [42]
self.assertEqual(42, len(pd))
mock_cursor.execute.assert_called_once_with(
'select count(*) from cache')
def test___setitem__(self, mock_sqlite3, mock_pickle):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_pickle.dumps.side_effect = ['pickled-key', 'pickled-value']
mock_connection = mock_sqlite3.connect.return_value
mock_cursor = mock_connection.cursor.return_value
pd[1] = 2
mock_cursor.execute.assert_called_with(
'insert or replace into cache values (?, ?)',
('pickled-key', 'pickled-value'))
def test___getitem__(self, mock_sqlite3, mock_pickle):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_pickle.dumps.return_value = 'pickled-key'
mock_connection = mock_sqlite3.connect.return_value
mock_cursor = mock_connection.cursor.return_value
mock_cursor.fetchone.return_value = ['pickled-value']
pd[1]
mock_cursor.execute.assert_called_with(
'select value from cache where key=?', ('pickled-key', ))
mock_pickle.loads.assert_called_once_with('pickled-value')
def test___len__(self, mock_sqlite3, mock_pickle):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_connection = mock_sqlite3.connect.return_value
mock_cursor = mock_connection.cursor.return_value
expected = 1
mock_cursor.fetchone.return_value = [expected]
self.assertEqual(expected, len(pd))
mock_cursor.execute.assert_called_with('select count(*) from cache')
def test___getitem__(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_conn = mock_sqlite3.return_value.__enter__.return_value
mock_cursor = mock_conn.cursor.return_value
mock_cursor.execute.reset_mock()
mock_cursor.fetchone.return_value = [pickle.dumps('pickled-value')]
result = pd[1]
self.assertEqual('pickled-value', result)
mock_cursor.execute.assert_called_with(
'select value from cache where key=?', (pickle.dumps(1), ))
def test___iter__(self, mock_sqlite3, mock_pickle):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_pickle.dumps.return_value = 'pickled-key'
mock_connection = mock_sqlite3.connect.return_value
mock_cursor = mock_connection.cursor.return_value
mock_cursor.fetchall.return_value = [['pickled-key']]
for x in pd:
x += x
mock_cursor.execute.assert_called_with('select key from cache')
mock_pickle.loads.assert_called_once_with('pickled-key')
def test___setitem__retries(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_conn = mock_sqlite3.return_value.__enter__.return_value
mock_cursor = mock_conn.cursor.return_value
mock_cursor.execute.reset_mock()
mock_cursor.execute.side_effect = [sqlite3.OperationalError, None]
pd[1] = 2
mock_cursor.execute.assert_called_with(
'insert or replace into cache values (?, ?)',
(pickle.dumps(1), pickle.dumps(2)))
self.assertEqual(2, mock_cursor.execute.call_count)
def __init__(self):
super().__init__()
self._systems = memoize.PersistentDict()
if hasattr(self._systems, 'make_permanent'):
self._systems.make_permanent(
self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'fakedriver')
for system in self._config['SUSHY_EMULATOR_FAKE_SYSTEMS']:
# Be careful to reduce racing with other processes
if system['uuid'] not in self._systems:
self._systems[system['uuid']] = copy.deepcopy(system)
self._by_name = {
system['name']: uuid
for uuid, system in self._systems.items()
}
def __init__(self, config, logger):
super().__init__(config, logger)
self._devices = memoize.PersistentDict()
if hasattr(self._devices, 'make_permanent'):
self._devices.make_permanent(
self._config.get('SUSHY_EMULATOR_STATE_DIR'), 'vmedia')
device_types = self._config.get('SUSHY_EMULATOR_VMEDIA_DEVICES')
if device_types is None:
device_types = {
u'Cd': {
u'Name': u'Virtual CD',
u'MediaTypes': [u'CD', u'DVD']
},
u'Floppy': {
u'Name': u'Virtual Removable Media',
u'MediaTypes': [u'Floppy', u'USBStick']
}
}
self._device_types = device_types
def test_decode(self, mock_sqlite3):
pd = memoize.PersistentDict()
value = pd.decode(pickle.dumps({1: '2'}))
self.assertEqual({1: '2'}, value)
def test_make_permanent(self, mock_sqlite3):
pd = memoize.PersistentDict()
pd.make_permanent('/', 'file')
mock_sqlite3.connect.assert_called_with('/file.sqlite')
def test_encode(self, mock_pickle):
pd = memoize.PersistentDict()
pd.encode({1: '2'})
mock_pickle.dumps.assert_called_once_with({1: '2'})
def test_decode(self, mock_pickle):
pd = memoize.PersistentDict()
pd.decode('blob')
mock_pickle.loads.assert_called_once_with('blob')
