def prepare(self, context, databases, memory_mb, users, device_path=None,
mount_point=None, backup_id=None, config_location=None,
config_contents=None):
"""Makes ready DBAAS on a Guest container."""
MySqlAppStatus.get().begin_mysql_install()
# status end_mysql_install set with secure()
app = MySqlApp(MySqlAppStatus.get())
restart_mysql = False
if device_path:
device = volume.VolumeDevice(device_path)
device.format()
#if a /var/lib/mysql folder exists, back it up.
if os.path.exists(CONF.mount_point):
#stop and do not update database
app.stop_db()
#rsync exiting data
if not backup_id:
restart_mysql = True
device.migrate_data(CONF.mount_point)
#mount the volume
device.mount(mount_point)
LOG.debug(_("Mounted the volume."))
#check mysql was installed and stopped
if restart_mysql:
app.start_mysql()
app.install_if_needed()
if backup_id:
self._perform_restore(backup_id, context, CONF.mount_point, app)
LOG.info(_("Securing mysql now."))
app.secure(config_location, config_contents)
enable_root_on_restore = (backup_id and MySqlAdmin().is_root_enabled())
if enable_root_on_restore:
MySqlAdmin().report_root_enabled(context)
app.secure_root(secure_remote_root=not enable_root_on_restore)
app.complete_install_or_restart()
if databases:
self.create_database(context, databases)
if users:
self.create_user(context, users)
LOG.info('"prepare" call has finished.')
def test_list_databases(self):
mock_conn = mock_admin_sql_connection()
when(mock_conn).execute(
TextClauseMatcher('schema_name as name')).thenReturn(
ResultSetStub([('db1', 'utf8', 'utf8_bin'),
('db2', 'utf8', 'utf8_bin'),
('db3', 'utf8', 'utf8_bin')]))
databases, next_marker = MySqlAdmin().list_databases(limit=10)
self.assertThat(next_marker, Is(None))
self.assertThat(len(databases), Is(3))
def setUp(self):
super(MySqlAdminTest, self).setUp()
self.orig_get_engine = dbaas.get_engine
self.orig_LocalSqlClient = dbaas.LocalSqlClient
self.orig_LocalSqlClient_enter = dbaas.LocalSqlClient.__enter__
self.orig_LocalSqlClient_exit = dbaas.LocalSqlClient.__exit__
self.orig_LocalSqlClient_execute = dbaas.LocalSqlClient.execute
self.orig_MySQLUser_is_valid_user_name = \
models.MySQLUser._is_valid_user_name
dbaas.get_engine = MagicMock(name='get_engine')
dbaas.LocalSqlClient = Mock
dbaas.LocalSqlClient.__enter__ = Mock()
dbaas.LocalSqlClient.__exit__ = Mock()
dbaas.LocalSqlClient.execute = Mock()
self.mySqlAdmin = MySqlAdmin()
def delete_user(self, context, user):
MySqlAdmin().delete_user(user)
def is_root_enabled(self, context):
return MySqlAdmin().is_root_enabled()
def enable_root(self, context):
return MySqlAdmin().enable_root()
def list_users(self, context, limit=None, marker=None,
include_marker=False):
return MySqlAdmin().list_users(limit, marker,
include_marker)
def list_access(self, context, username, hostname):
return MySqlAdmin().list_access(username, hostname)
def revoke_access(self, context, username, hostname, database):
return MySqlAdmin().revoke_access(username, hostname, database)
def grant_access(self, context, username, hostname, databases):
return MySqlAdmin().grant_access(username, hostname, databases)
def get_user(self, context, username, hostname):
return MySqlAdmin().get_user(username, hostname)
def delete_database(self, context, database):
return MySqlAdmin().delete_database(database)
def create_user(self, context, users):
MySqlAdmin().create_user(users)
def create_database(self, context, databases):
return MySqlAdmin().create_database(databases)
def update_attributes(self, context, username, hostname, user_attrs):
return MySqlAdmin().update_attributes(username, hostname, user_attrs)
def change_passwords(self, context, users):
return MySqlAdmin().change_passwords(users)
def test_enable_root_failed(self):
when(models.MySQLUser)._is_valid_user_name(any()).thenReturn(False)
self.assertRaises(ValueError, MySqlAdmin().enable_root)
