openstack/trove
Code Issues Proposed changes

Merge pull request #131 from cp16net/create-instance-add-user

Browse Source 
modify prepare call to create the users given on a create instance
This commit is contained in:
Nirmal Ranganathan 2012-06-18 13:30:51 -07:00
commit c4dd9b97c2
8 changed files with 78 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
reddwarf/extensions/mysql/common.py Normal file
View File

@ -0,0 +1,52 @@
# Copyright 2012 OpenStack LLC
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from reddwarf.common import exception
from reddwarf.guestagent.db import models as guest_models
def populate_databases(dbs):
"""
Create a serializable request with user provided data
for creating new databases.
"""
try:
databases = []
for database in dbs:
mydb = guest_models.MySQLDatabase()
mydb.name = database.get('name', '')
mydb.character_set = database.get('character_set', '')
mydb.collate = database.get('collate', '')
databases.append(mydb.serialize())
return databases
except ValueError as ve:
raise exception.BadRequest(ve.message)
def populate_users(users):
"""Create a serializable request containing users"""
try:
users_data = []
for user in users:
u = guest_models.MySQLUser()
u.name = user.get('name', '')
u.password = user.get('password', '')
dbs = user.get('databases', '')
if dbs:
for db in dbs:
u.databases = db.get('name', '')
users_data.append(u.serialize())
return users_data
except ValueError as ve:
raise exception.BadRequest(ve.message)

36
reddwarf/extensions/mysql/models.py
View File

@ -50,42 +50,6 @@ def load_and_verify(context, instance_id):
return instance
def populate_databases(dbs):
"""
Create a serializable request with user provided data
for creating new databases.
"""
try:
databases = []
for database in dbs:
mydb = guest_models.MySQLDatabase()
mydb.name = database.get('name', '')
mydb.character_set = database.get('character_set', '')
mydb.collate = database.get('collate', '')
databases.append(mydb.serialize())
return databases
except ValueError as ve:
raise exception.BadRequest(ve.message)
def populate_users(users):
"""Create a serializable request containing users"""
try:
users_data = []
for user in users:
u = guest_models.MySQLUser()
u.name = user.get('name', '')
u.password = user.get('password', '')
dbs = user.get('databases', '')
if dbs:
for db in dbs:
u.databases = db.get('name', '')
users_data.append(u.serialize())
return users_data
except ValueError as ve:
raise exception.BadRequest(ve.message)
class User(object):
_data_fields = ['name', 'password', 'databases']

6
reddwarf/extensions/mysql/service.py
View File

@ -22,6 +22,8 @@ from reddwarf.common import exception
from reddwarf.common import pagination
from reddwarf.common import wsgi
from reddwarf.guestagent.db import models as guest_models
from reddwarf.extensions.mysql.common import populate_databases
from reddwarf.extensions.mysql.common import populate_users
from reddwarf.extensions.mysql import models
from reddwarf.extensions.mysql import views
@ -121,7 +123,7 @@ class UserController(BaseController):
context = req.environ[wsgi.CONTEXT_KEY]
self.validate(body)
users = body['users']
model_users = models.populate_users(users)
model_users = populate_users(users)
models.User.create(context, instance_id, model_users)
return wsgi.Result(None, 202)
@ -168,7 +170,7 @@ class SchemaController(BaseController):
context = req.environ[wsgi.CONTEXT_KEY]
self.validate(body)
schemas = body['databases']
model_schemas = models.populate_databases(schemas)
model_schemas = populate_databases(schemas)
models.Schema.create(context, instance_id, model_schemas)
return wsgi.Result(None, 202)

25
reddwarf/instance/models.py
View File

@ -56,27 +56,6 @@ def load_server(context, instance_id, server_id):
return server
# This probably should not happen here. Seems like it should
# be in an extension instead
def populate_databases(dbs):
"""
Create a serializable request with user provided data
for creating new databases.
"""
from reddwarf.guestagent.db import models as guest_models
try:
databases = []
for database in dbs:
mydb = guest_models.MySQLDatabase()
mydb.name = database.get('name', '')
mydb.character_set = database.get('character_set', '')
mydb.collate = database.get('collate', '')
databases.append(mydb.serialize())
return databases
except ValueError as ve:
raise exception.BadRequest(ve.message)
class InstanceStatus(object):
ACTIVE = "ACTIVE"
@ -371,7 +350,7 @@ class Instance(BuiltInstance):
@classmethod
def create(cls, context, name, flavor_id, image_id,
databases, service_type, volume_size):
databases, users, service_type, volume_size):
client = create_nova_client(context)
try:
flavor = client.flavors.get(flavor_id)
@ -390,7 +369,7 @@ class Instance(BuiltInstance):
dns_client = create_dns_client(context)
dns_client.update_hostname(db_info)
task_api.API(context).create_instance(db_info.id, name, flavor_id,
flavor.ram, image_id, databases, service_type, volume_size)
flavor.ram, image_id, databases, users, service_type, volume_size)
return SimpleInstance(context, db_info, service_status)

9
reddwarf/instance/service.py
View File

@ -24,6 +24,8 @@ from reddwarf.common import exception
from reddwarf.common import pagination
from reddwarf.common import utils
from reddwarf.common import wsgi
from reddwarf.extensions.mysql.common import populate_databases
from reddwarf.extensions.mysql.common import populate_users
from reddwarf.instance import models, views
@ -235,9 +237,8 @@ class InstanceController(BaseController):
name = body['instance']['name']
flavor_ref = body['instance']['flavorRef']
flavor_id = utils.get_id_from_href(flavor_ref)
databases = body['instance'].get('databases')
if databases is None:
databases = []
databases = populate_databases(body['instance'].get('databases'))
users = populate_users(body['instance'].get('users'))
if body['instance'].get('volume', None) is not None:
try:
volume_size = int(body['instance']['volume']['size'])
@ -246,7 +247,7 @@ class InstanceController(BaseController):
else:
volume_size = None
instance = models.Instance.create(context, name, flavor_id,
image_id, databases,
image_id, databases, users,
service_type, volume_size)
return wsgi.Result(views.InstanceDetailView(instance, req=req,

4
reddwarf/taskmanager/api.py
View File

@ -96,9 +96,9 @@ class API(object):
self._cast("delete_instance", instance_id=instance_id)
def create_instance(self, instance_id, name, flavor_id, flavor_ram,
image_id, databases, service_type, volume_size):
image_id, databases, users, service_type, volume_size):
LOG.debug("Making async call to create instance %s " % instance_id)
self._cast("create_instance", instance_id=instance_id, name=name,
flavor_id=flavor_id, flavor_ram=flavor_ram,
image_id=image_id, databases=databases,
image_id=image_id, databases=databases, users=users,
service_type=service_type, volume_size=volume_size)

6
reddwarf/taskmanager/manager.py
View File

@ -74,8 +74,10 @@ class TaskManager(service.Manager):
instance_tasks.delete_instance()
def create_instance(self, context, instance_id, name, flavor_id,
flavor_ram, image_id, databases, service_type,
flavor_ram, image_id, databases, users, service_type,
volume_size):
instance_tasks = FreshInstanceTasks.load(context, instance_id)
instance_tasks.create_instance(flavor_id, flavor_ram, image_id,
databases, service_type, volume_size)
databases, users, service_type,
volume_size)

17
reddwarf/taskmanager/models.py
View File

@ -30,13 +30,14 @@ from reddwarf.common.remote import create_nova_client
from reddwarf.common.remote import create_nova_volume_client
from reddwarf.common.remote import create_guest_client
from reddwarf.common.utils import poll_until
from reddwarf.extensions.mysql.common import populate_databases
from reddwarf.extensions.mysql.common import populate_users
from reddwarf.instance import models as inst_models
from reddwarf.instance.models import DBInstance
from reddwarf.instance.models import BuiltInstance
from reddwarf.instance.models import FreshInstance
from reddwarf.instance.models import InstanceStatus
from reddwarf.instance.models import InstanceServiceStatus
from reddwarf.instance.models import populate_databases
from reddwarf.instance.models import ServiceStatuses
from reddwarf.instance.views import get_ip_address
@ -46,8 +47,8 @@ LOG = logging.getLogger(__name__)
class FreshInstanceTasks(FreshInstance):
def create_instance(self, flavor_id, flavor_ram,
image_id, databases, service_type, volume_size):
def create_instance(self, flavor_id, flavor_ram, image_id,
databases, users, service_type, volume_size):
try:
volume_info = self._create_volume(volume_size)
block_device_mapping = volume_info['block_device']
@ -57,7 +58,8 @@ class FreshInstanceTasks(FreshInstance):
# Save server ID.
self.update_db(compute_instance_id=server_id)
self._create_dns_entry()
self._guest_prepare(server, flavor_ram, volume_info, databases)
self._guest_prepare(server, flavor_ram, volume_info,
databases, users)
finally:
self.update_db(task_status=inst_models.InstanceTasks.NONE)
@ -127,12 +129,11 @@ class FreshInstanceTasks(FreshInstance):
LOG.debug(_("Created new compute instance %s.") % server.id)
return server
def _guest_prepare(self, server, flavor_ram, volume_info, databases):
def _guest_prepare(self, server, flavor_ram, volume_info,
databases, users):
LOG.info("Entering guest_prepare.")
# Now wait for the response from the create to do additional work
# populate the databases
model_schemas = populate_databases(databases)
self.guest.prepare(flavor_ram, model_schemas, users=[],
self.guest.prepare(flavor_ram, databases, users,
device_path=volume_info['device_path'],
mount_point=volume_info['mount_point'])