Merge lp:~eday/nova/compute-abstraction into lp:~hudson-openstack/nova/trunk
- compute-abstraction
- Merge into trunk
Proposed by
Eric Day
| Status: | Merged |
|---|---|
| Approved by: | Vish Ishaya |
| Approved revision: | 427 |
| Merged at revision: | 437 |
| Proposed branch: | lp:~eday/nova/compute-abstraction |
| Merge into: | lp:~hudson-openstack/nova/trunk |
| Diff against target: |
953 lines (+347/-301) 12 files modified
nova/api/ec2/cloud.py (+31/-148) nova/api/openstack/servers.py (+14/-84) nova/compute/api.py (+212/-0) nova/compute/instance_types.py (+20/-0) nova/compute/manager.py (+1/-48) nova/db/base.py (+36/-0) nova/manager.py (+5/-9) nova/quota.py (+5/-0) nova/tests/api/openstack/fakes.py (+1/-1) nova/tests/api/openstack/test_servers.py (+6/-0) nova/tests/compute_unittest.py (+7/-4) nova/tests/quota_unittest.py (+9/-7) |
| To merge this branch: | bzr merge lp:~eday/nova/compute-abstraction |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Michael Gundlach (community) | Approve | ||
| Vish Ishaya (community) | Approve | ||
| Soren Hansen (community) | Approve | ||
|
Review via email:
|
|||
Commit message
Description of the change
Consolidated the start instance logic in the two API classes into a single method. This also cleans up a number of small discrepencies between the two.
To post a comment you must log in.
Revision history for this message
| Soren Hansen (soren) wrote : | # |
2010/11/25 Vish Ishaya <email address hidden>:
> Review: Approve
> Questions on irc were addressed by 424. LGTM. We definitely need to clean up cloud unittests.
It would probably be useful to post the relevant IRC conversation
here. I'd like to know what you talked about, but I'm not really
interested in digging through hours worth of irc logs. :)
--
Soren Hansen
Ubuntu Developer http://
OpenStack Developer http://
Revision history for this message
| Soren Hansen (soren) wrote : | # |
Download full text (3.9 KiB)
2010/11/24 Eric Day <email address hidden>:
> === modified file 'nova/api/
> --- nova/api/
> +++ nova/api/
> @@ -39,7 +39,7 @@
> from nova import quota
> from nova import rpc
> from nova import utils
> -from nova.compute.
> +from nova.compute import instance_types
This needs to move out of code anyway. Filed bug #681411.
> @@ -260,7 +255,7 @@
> return True
>
> def describe_
> - self._ensure_
> + self.compute_
> if context.
> groups = db.security_
> else:
I understand the motivation to consolidate this code in the compute
manager. I just think that instances launched through the EC2 ÁPI should
land in one security group by default and instances launched through the
OpenStack API should land in another by default. EC2 restricts all
access to instances by default, while Rackspace has traditionally left
them open, leaving it to the owner of the instance to shield it off.
I filed bug #681416 to track this.
> @@ -505,9 +500,8 @@
> if quota.allowed_
> logging.warn("Quota exceeeded for %s, tried to create %sG volume",
> context.project_id, size)
> - raise QuotaError("Volume quota exceeded. You cannot "
> - "create a volume of size %s" %
> - size)
> + raise quota.QuotaErro
> + "create a volume of size %s" % size)
We should include a unit, not just the number. Perhaps the user thinks
he's creating a 1000 MB volume, but we're actually blocking him from
creating a 1000 GB volume.
Filed bug #681417.
> === modified file 'nova/compute/
> --- nova/compute/
> +++ nova/compute/
> @@ -36,13 +36,18 @@
>
> import logging +import time
>
> from twisted.internet import defer
>
> +from nova import db
> from nova import exception
> from nova import flags
> from nova import manager
> +from nova import quota
> +from nova import rpc
> from nova import utils
> +from nova.compute import instance_types
> from nova.compute import power_state
>
>
> @@ -53,6 +58,11 @@
> 'Driver to use for volume creation')
>
>
> +def generate_
> + """Default function to generate a hostname given an instance reference."""
> + return str(internal_id)
> +
> +
> class ComputeManager(
> """Manages the running instances from creation to destruction."""
>
> @@ -84,6 +94,126 @@
> """This call passes stright through to the virtualization driver."""
> yield self.driver.
>
> + # TODO(eday): network_topic arg should go away once we push network
> + # allocation into the scheduler or ...
Revision history for this message
| Eric Day (eday) wrote : | # |
I agree on all the points regarding security groups and fixing other things you've filed bugs for. I was trying to just shuffle code around so we only need to edit things in one place, and not actually change the logic.
As far as putting the code in compute manager, I started by creating nova.compute.api, but this felt weird too. It actually made sense to me in the end to put them right next to each other, just knowing they will be on opposite ends of the worker. Perhaps we could just split the class and have both in the manager.py file. I'm open.
Revision history for this message
| Soren Hansen (soren) wrote : | # |
Separate classes in the same file sounds good. It also lets us to things in the individual __init__ methods without worrying it might get run in the wrong context.
The bugs I filed and mentioned weren't meant as comments on your code. It was just stuff I stumbled upon while reading your diff. I guess I should have left it out to avoid the confusion. Just ignore it. :)
Revision history for this message
| Vish Ishaya (vishvananda) wrote : | # |
The stuff in irc was simply noticing that exception handling on image_get wasn't handled consistently. Giving the workers an api seems reasonable to me. I think it is easier conceptually than having the same class work both locally and remote.
How do you see this working for the volume? Code from volume_manager runs on the api host (create the db record), the compute host (discover the volume), and the volume host (create and export the volume). Do we have three separate classes? Or would VolumeAPI encompass all of the functions that are called by other workers (the api host and compute host code)?
Regardless, we need move the other workers code into this format ASAP.
review:
Approve
Revision history for this message
| Soren Hansen (soren) wrote : | # |
This is great stuff! Thanks!
review:
Approve
Revision history for this message
| OpenStack Infra (hudson-openstack) wrote : | # |
Attempt to merge into lp:nova failed due to conflicts:
text conflict in nova/api/
text conflict in nova/compute/
Revision history for this message
| OpenStack Infra (hudson-openstack) wrote : | # |
There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.
Revision history for this message
| OpenStack Infra (hudson-openstack) wrote : | # |
Attempt to merge into lp:nova failed due to conflicts:
text conflict in nova/compute/
Revision history for this message
| Michael Gundlach (gundlach) wrote : | # |
465:s/quote/quota/ and shouldn't that be in multiline triple-quote form?
763:isn't it a pep8 violation to not have blank lines b/w class and comment? also, i'm not sure i like having an extra base class just to set 'self.db', versus making a helper function in the db module that can be called explicitly to set self.db. but that's bikeshedding so i'm ok with how it is now too.
lgtm.
review:
Approve
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'nova/api/ec2/cloud.py' | |||
| 2 | --- nova/api/ec2/cloud.py 2010-11-30 08:19:32 +0000 | |||
| 3 | +++ nova/api/ec2/cloud.py 2010-12-02 17:38:10 +0000 | |||
| 4 | @@ -39,7 +39,8 @@ | |||
| 5 | 39 | from nova import quota | 39 | from nova import quota |
| 6 | 40 | from nova import rpc | 40 | from nova import rpc |
| 7 | 41 | from nova import utils | 41 | from nova import utils |
| 9 | 42 | from nova.compute.instance_types import INSTANCE_TYPES | 42 | from nova.compute import api as compute_api |
| 10 | 43 | from nova.compute import instance_types | ||
| 11 | 43 | from nova.api import cloud | 44 | from nova.api import cloud |
| 12 | 44 | from nova.image.s3 import S3ImageService | 45 | from nova.image.s3 import S3ImageService |
| 13 | 45 | 46 | ||
| 14 | @@ -50,11 +51,6 @@ | |||
| 15 | 50 | InvalidInputException = exception.InvalidInputException | 51 | InvalidInputException = exception.InvalidInputException |
| 16 | 51 | 52 | ||
| 17 | 52 | 53 | ||
| 18 | 53 | class QuotaError(exception.ApiError): | ||
| 19 | 54 | """Quota Exceeeded""" | ||
| 20 | 55 | pass | ||
| 21 | 56 | |||
| 22 | 57 | |||
| 23 | 58 | def _gen_key(context, user_id, key_name): | 54 | def _gen_key(context, user_id, key_name): |
| 24 | 59 | """Generate a key | 55 | """Generate a key |
| 25 | 60 | 56 | ||
| 26 | @@ -99,7 +95,7 @@ | |||
| 27 | 99 | """ | 95 | """ |
| 28 | 100 | def __init__(self): | 96 | def __init__(self): |
| 29 | 101 | self.network_manager = utils.import_object(FLAGS.network_manager) | 97 | self.network_manager = utils.import_object(FLAGS.network_manager) |
| 31 | 102 | self.compute_manager = utils.import_object(FLAGS.compute_manager) | 98 | self.compute_api = compute_api.ComputeAPI() |
| 32 | 103 | self.image_service = S3ImageService() | 99 | self.image_service = S3ImageService() |
| 33 | 104 | self.setup() | 100 | self.setup() |
| 34 | 105 | 101 | ||
| 35 | @@ -127,7 +123,7 @@ | |||
| 36 | 127 | for instance in db.instance_get_all_by_project(context, project_id): | 123 | for instance in db.instance_get_all_by_project(context, project_id): |
| 37 | 128 | if instance['fixed_ip']: | 124 | if instance['fixed_ip']: |
| 38 | 129 | line = '%s slots=%d' % (instance['fixed_ip']['address'], | 125 | line = '%s slots=%d' % (instance['fixed_ip']['address'], |
| 40 | 130 | INSTANCE_TYPES[instance['instance_type']]['vcpus']) | 126 | instance['vcpus']) |
| 41 | 131 | key = str(instance['key_name']) | 127 | key = str(instance['key_name']) |
| 42 | 132 | if key in result: | 128 | if key in result: |
| 43 | 133 | result[key].append(line) | 129 | result[key].append(line) |
| 44 | @@ -260,7 +256,7 @@ | |||
| 45 | 260 | return True | 256 | return True |
| 46 | 261 | 257 | ||
| 47 | 262 | def describe_security_groups(self, context, group_name=None, **kwargs): | 258 | def describe_security_groups(self, context, group_name=None, **kwargs): |
| 49 | 263 | self._ensure_default_security_group(context) | 259 | self.compute_api.ensure_default_security_group(context) |
| 50 | 264 | if context.user.is_admin(): | 260 | if context.user.is_admin(): |
| 51 | 265 | groups = db.security_group_get_all(context) | 261 | groups = db.security_group_get_all(context) |
| 52 | 266 | else: | 262 | else: |
| 53 | @@ -358,7 +354,7 @@ | |||
| 54 | 358 | return False | 354 | return False |
| 55 | 359 | 355 | ||
| 56 | 360 | def revoke_security_group_ingress(self, context, group_name, **kwargs): | 356 | def revoke_security_group_ingress(self, context, group_name, **kwargs): |
| 58 | 361 | self._ensure_default_security_group(context) | 357 | self.compute_api.ensure_default_security_group(context) |
| 59 | 362 | security_group = db.security_group_get_by_name(context, | 358 | security_group = db.security_group_get_by_name(context, |
| 60 | 363 | context.project_id, | 359 | context.project_id, |
| 61 | 364 | group_name) | 360 | group_name) |
| 62 | @@ -383,7 +379,7 @@ | |||
| 63 | 383 | # for these operations, so support for newer API versions | 379 | # for these operations, so support for newer API versions |
| 64 | 384 | # is sketchy. | 380 | # is sketchy. |
| 65 | 385 | def authorize_security_group_ingress(self, context, group_name, **kwargs): | 381 | def authorize_security_group_ingress(self, context, group_name, **kwargs): |
| 67 | 386 | self._ensure_default_security_group(context) | 382 | self.compute_api.ensure_default_security_group(context) |
| 68 | 387 | security_group = db.security_group_get_by_name(context, | 383 | security_group = db.security_group_get_by_name(context, |
| 69 | 388 | context.project_id, | 384 | context.project_id, |
| 70 | 389 | group_name) | 385 | group_name) |
| 71 | @@ -419,7 +415,7 @@ | |||
| 72 | 419 | return source_project_id | 415 | return source_project_id |
| 73 | 420 | 416 | ||
| 74 | 421 | def create_security_group(self, context, group_name, group_description): | 417 | def create_security_group(self, context, group_name, group_description): |
| 76 | 422 | self._ensure_default_security_group(context) | 418 | self.compute_api.ensure_default_security_group(context) |
| 77 | 423 | if db.security_group_exists(context, context.project_id, group_name): | 419 | if db.security_group_exists(context, context.project_id, group_name): |
| 78 | 424 | raise exception.ApiError('group %s already exists' % group_name) | 420 | raise exception.ApiError('group %s already exists' % group_name) |
| 79 | 425 | 421 | ||
| 80 | @@ -505,9 +501,8 @@ | |||
| 81 | 505 | if quota.allowed_volumes(context, 1, size) < 1: | 501 | if quota.allowed_volumes(context, 1, size) < 1: |
| 82 | 506 | logging.warn("Quota exceeeded for %s, tried to create %sG volume", | 502 | logging.warn("Quota exceeeded for %s, tried to create %sG volume", |
| 83 | 507 | context.project_id, size) | 503 | context.project_id, size) |
| 87 | 508 | raise QuotaError("Volume quota exceeded. You cannot " | 504 | raise quota.QuotaError("Volume quota exceeded. You cannot " |
| 88 | 509 | "create a volume of size %s" % | 505 | "create a volume of size %s" % size) |
| 86 | 510 | size) | ||
| 89 | 511 | vol = {} | 506 | vol = {} |
| 90 | 512 | vol['size'] = size | 507 | vol['size'] = size |
| 91 | 513 | vol['user_id'] = context.user.id | 508 | vol['user_id'] = context.user.id |
| 92 | @@ -699,8 +694,8 @@ | |||
| 93 | 699 | if quota.allowed_floating_ips(context, 1) < 1: | 694 | if quota.allowed_floating_ips(context, 1) < 1: |
| 94 | 700 | logging.warn("Quota exceeeded for %s, tried to allocate address", | 695 | logging.warn("Quota exceeeded for %s, tried to allocate address", |
| 95 | 701 | context.project_id) | 696 | context.project_id) |
| 98 | 702 | raise QuotaError("Address quota exceeded. You cannot " | 697 | raise quota.QuotaError("Address quota exceeded. You cannot " |
| 99 | 703 | "allocate any more addresses") | 698 | "allocate any more addresses") |
| 100 | 704 | network_topic = self._get_network_topic(context) | 699 | network_topic = self._get_network_topic(context) |
| 101 | 705 | public_ip = rpc.call(context, | 700 | public_ip = rpc.call(context, |
| 102 | 706 | network_topic, | 701 | network_topic, |
| 103 | @@ -752,137 +747,25 @@ | |||
| 104 | 752 | "args": {"network_id": network_ref['id']}}) | 747 | "args": {"network_id": network_ref['id']}}) |
| 105 | 753 | return db.queue_get_for(context, FLAGS.network_topic, host) | 748 | return db.queue_get_for(context, FLAGS.network_topic, host) |
| 106 | 754 | 749 | ||
| 107 | 755 | def _ensure_default_security_group(self, context): | ||
| 108 | 756 | try: | ||
| 109 | 757 | db.security_group_get_by_name(context, | ||
| 110 | 758 | context.project_id, | ||
| 111 | 759 | 'default') | ||
| 112 | 760 | except exception.NotFound: | ||
| 113 | 761 | values = {'name': 'default', | ||
| 114 | 762 | 'description': 'default', | ||
| 115 | 763 | 'user_id': context.user.id, | ||
| 116 | 764 | 'project_id': context.project_id} | ||
| 117 | 765 | group = db.security_group_create(context, values) | ||
| 118 | 766 | |||
| 119 | 767 | def run_instances(self, context, **kwargs): | 750 | def run_instances(self, context, **kwargs): |
| 238 | 768 | instance_type = kwargs.get('instance_type', 'm1.small') | 751 | max_count = int(kwargs.get('max_count', 1)) |
| 239 | 769 | if instance_type not in INSTANCE_TYPES: | 752 | instances = self.compute_api.create_instances(context, |
| 240 | 770 | raise exception.ApiError("Unknown instance type: %s", | 753 | instance_types.get_by_type(kwargs.get('instance_type', None)), |
| 241 | 771 | instance_type) | 754 | self.image_service, |
| 242 | 772 | # check quota | 755 | kwargs['image_id'], |
| 243 | 773 | max_instances = int(kwargs.get('max_count', 1)) | 756 | self._get_network_topic(context), |
| 244 | 774 | min_instances = int(kwargs.get('min_count', max_instances)) | 757 | min_count=int(kwargs.get('min_count', max_count)), |
| 245 | 775 | num_instances = quota.allowed_instances(context, | 758 | max_count=max_count, |
| 246 | 776 | max_instances, | 759 | kernel_id=kwargs.get('kernel_id'), |
| 247 | 777 | instance_type) | 760 | ramdisk_id=kwargs.get('ramdisk_id'), |
| 248 | 778 | if num_instances < min_instances: | 761 | name=kwargs.get('display_name'), |
| 249 | 779 | logging.warn("Quota exceeeded for %s, tried to run %s instances", | 762 | description=kwargs.get('display_description'), |
| 250 | 780 | context.project_id, min_instances) | 763 | user_data=kwargs.get('user_data', ''), |
| 251 | 781 | raise QuotaError("Instance quota exceeded. You can only " | 764 | key_name=kwargs.get('key_name'), |
| 252 | 782 | "run %s more instances of this type." % | 765 | security_group=kwargs.get('security_group'), |
| 253 | 783 | num_instances, "InstanceLimitExceeded") | 766 | generate_hostname=internal_id_to_ec2_id) |
| 254 | 784 | # make sure user can access the image | 767 | return self._format_run_instances(context, |
| 255 | 785 | # vpn image is private so it doesn't show up on lists | 768 | instances[0]['reservation_id']) |
| 138 | 786 | vpn = kwargs['image_id'] == FLAGS.vpn_image_id | ||
| 139 | 787 | |||
| 140 | 788 | if not vpn: | ||
| 141 | 789 | image = self.image_service.show(context, kwargs['image_id']) | ||
| 142 | 790 | |||
| 143 | 791 | # FIXME(ja): if image is vpn, this breaks | ||
| 144 | 792 | # get defaults from imagestore | ||
| 145 | 793 | image_id = image['imageId'] | ||
| 146 | 794 | kernel_id = image.get('kernelId', FLAGS.default_kernel) | ||
| 147 | 795 | ramdisk_id = image.get('ramdiskId', FLAGS.default_ramdisk) | ||
| 148 | 796 | |||
| 149 | 797 | # API parameters overrides of defaults | ||
| 150 | 798 | kernel_id = kwargs.get('kernel_id', kernel_id) | ||
| 151 | 799 | ramdisk_id = kwargs.get('ramdisk_id', ramdisk_id) | ||
| 152 | 800 | |||
| 153 | 801 | # make sure we have access to kernel and ramdisk | ||
| 154 | 802 | self.image_service.show(context, kernel_id) | ||
| 155 | 803 | self.image_service.show(context, ramdisk_id) | ||
| 156 | 804 | |||
| 157 | 805 | logging.debug("Going to run %s instances...", num_instances) | ||
| 158 | 806 | launch_time = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()) | ||
| 159 | 807 | key_data = None | ||
| 160 | 808 | if 'key_name' in kwargs: | ||
| 161 | 809 | key_pair_ref = db.key_pair_get(context, | ||
| 162 | 810 | context.user.id, | ||
| 163 | 811 | kwargs['key_name']) | ||
| 164 | 812 | key_data = key_pair_ref['public_key'] | ||
| 165 | 813 | |||
| 166 | 814 | security_group_arg = kwargs.get('security_group', ["default"]) | ||
| 167 | 815 | if not type(security_group_arg) is list: | ||
| 168 | 816 | security_group_arg = [security_group_arg] | ||
| 169 | 817 | |||
| 170 | 818 | security_groups = [] | ||
| 171 | 819 | self._ensure_default_security_group(context) | ||
| 172 | 820 | for security_group_name in security_group_arg: | ||
| 173 | 821 | group = db.security_group_get_by_name(context, | ||
| 174 | 822 | context.project_id, | ||
| 175 | 823 | security_group_name) | ||
| 176 | 824 | security_groups.append(group['id']) | ||
| 177 | 825 | |||
| 178 | 826 | reservation_id = utils.generate_uid('r') | ||
| 179 | 827 | base_options = {} | ||
| 180 | 828 | base_options['state_description'] = 'scheduling' | ||
| 181 | 829 | base_options['image_id'] = image_id | ||
| 182 | 830 | base_options['kernel_id'] = kernel_id | ||
| 183 | 831 | base_options['ramdisk_id'] = ramdisk_id | ||
| 184 | 832 | base_options['reservation_id'] = reservation_id | ||
| 185 | 833 | base_options['key_data'] = key_data | ||
| 186 | 834 | base_options['key_name'] = kwargs.get('key_name', None) | ||
| 187 | 835 | base_options['user_id'] = context.user.id | ||
| 188 | 836 | base_options['project_id'] = context.project_id | ||
| 189 | 837 | base_options['user_data'] = kwargs.get('user_data', '') | ||
| 190 | 838 | |||
| 191 | 839 | base_options['display_name'] = kwargs.get('display_name') | ||
| 192 | 840 | base_options['display_description'] = kwargs.get('display_description') | ||
| 193 | 841 | |||
| 194 | 842 | type_data = INSTANCE_TYPES[instance_type] | ||
| 195 | 843 | base_options['instance_type'] = instance_type | ||
| 196 | 844 | base_options['memory_mb'] = type_data['memory_mb'] | ||
| 197 | 845 | base_options['vcpus'] = type_data['vcpus'] | ||
| 198 | 846 | base_options['local_gb'] = type_data['local_gb'] | ||
| 199 | 847 | elevated = context.elevated() | ||
| 200 | 848 | |||
| 201 | 849 | for num in range(num_instances): | ||
| 202 | 850 | |||
| 203 | 851 | instance_ref = self.compute_manager.create_instance(context, | ||
| 204 | 852 | security_groups, | ||
| 205 | 853 | mac_address=utils.generate_mac(), | ||
| 206 | 854 | launch_index=num, | ||
| 207 | 855 | **base_options) | ||
| 208 | 856 | inst_id = instance_ref['id'] | ||
| 209 | 857 | |||
| 210 | 858 | internal_id = instance_ref['internal_id'] | ||
| 211 | 859 | ec2_id = internal_id_to_ec2_id(internal_id) | ||
| 212 | 860 | |||
| 213 | 861 | self.compute_manager.update_instance(context, | ||
| 214 | 862 | inst_id, | ||
| 215 | 863 | hostname=ec2_id) | ||
| 216 | 864 | |||
| 217 | 865 | # TODO(vish): This probably should be done in the scheduler | ||
| 218 | 866 | # or in compute as a call. The network should be | ||
| 219 | 867 | # allocated after the host is assigned and setup | ||
| 220 | 868 | # can happen at the same time. | ||
| 221 | 869 | address = self.network_manager.allocate_fixed_ip(context, | ||
| 222 | 870 | inst_id, | ||
| 223 | 871 | vpn) | ||
| 224 | 872 | network_topic = self._get_network_topic(context) | ||
| 225 | 873 | rpc.cast(elevated, | ||
| 226 | 874 | network_topic, | ||
| 227 | 875 | {"method": "setup_fixed_ip", | ||
| 228 | 876 | "args": {"address": address}}) | ||
| 229 | 877 | |||
| 230 | 878 | rpc.cast(context, | ||
| 231 | 879 | FLAGS.scheduler_topic, | ||
| 232 | 880 | {"method": "run_instance", | ||
| 233 | 881 | "args": {"topic": FLAGS.compute_topic, | ||
| 234 | 882 | "instance_id": inst_id}}) | ||
| 235 | 883 | logging.debug("Casting to scheduler for %s/%s's instance %s" % | ||
| 236 | 884 | (context.project.name, context.user.name, inst_id)) | ||
| 237 | 885 | return self._format_run_instances(context, reservation_id) | ||
| 256 | 886 | 769 | ||
| 257 | 887 | def terminate_instances(self, context, instance_id, **kwargs): | 770 | def terminate_instances(self, context, instance_id, **kwargs): |
| 258 | 888 | """Terminate each instance in instance_id, which is a list of ec2 ids. | 771 | """Terminate each instance in instance_id, which is a list of ec2 ids. |
| 259 | @@ -907,7 +790,7 @@ | |||
| 260 | 907 | id_str) | 790 | id_str) |
| 261 | 908 | continue | 791 | continue |
| 262 | 909 | now = datetime.datetime.utcnow() | 792 | now = datetime.datetime.utcnow() |
| 264 | 910 | self.compute_manager.update_instance(context, | 793 | self.compute_api.update_instance(context, |
| 265 | 911 | instance_ref['id'], | 794 | instance_ref['id'], |
| 266 | 912 | state_description='terminating', | 795 | state_description='terminating', |
| 267 | 913 | state=0, | 796 | state=0, |
| 268 | 914 | 797 | ||
| 269 | === modified file 'nova/api/openstack/servers.py' | |||
| 270 | --- nova/api/openstack/servers.py 2010-12-01 20:18:24 +0000 | |||
| 271 | +++ nova/api/openstack/servers.py 2010-12-02 17:38:10 +0000 | |||
| 272 | @@ -27,6 +27,7 @@ | |||
| 273 | 27 | from nova import context | 27 | from nova import context |
| 274 | 28 | from nova.api import cloud | 28 | from nova.api import cloud |
| 275 | 29 | from nova.api.openstack import faults | 29 | from nova.api.openstack import faults |
| 276 | 30 | from nova.compute import api as compute_api | ||
| 277 | 30 | from nova.compute import instance_types | 31 | from nova.compute import instance_types |
| 278 | 31 | from nova.compute import power_state | 32 | from nova.compute import power_state |
| 279 | 32 | import nova.api.openstack | 33 | import nova.api.openstack |
| 280 | @@ -95,7 +96,7 @@ | |||
| 281 | 95 | db_driver = FLAGS.db_driver | 96 | db_driver = FLAGS.db_driver |
| 282 | 96 | self.db_driver = utils.import_object(db_driver) | 97 | self.db_driver = utils.import_object(db_driver) |
| 283 | 97 | self.network_manager = utils.import_object(FLAGS.network_manager) | 98 | self.network_manager = utils.import_object(FLAGS.network_manager) |
| 285 | 98 | self.compute_manager = utils.import_object(FLAGS.compute_manager) | 99 | self.compute_api = compute_api.ComputeAPI() |
| 286 | 99 | super(Controller, self).__init__() | 100 | super(Controller, self).__init__() |
| 287 | 100 | 101 | ||
| 288 | 101 | def index(self, req): | 102 | def index(self, req): |
| 289 | @@ -140,22 +141,23 @@ | |||
| 290 | 140 | 141 | ||
| 291 | 141 | def create(self, req): | 142 | def create(self, req): |
| 292 | 142 | """ Creates a new server for a given user """ | 143 | """ Creates a new server for a given user """ |
| 293 | 143 | |||
| 294 | 144 | env = self._deserialize(req.body, req) | 144 | env = self._deserialize(req.body, req) |
| 295 | 145 | if not env: | 145 | if not env: |
| 296 | 146 | return faults.Fault(exc.HTTPUnprocessableEntity()) | 146 | return faults.Fault(exc.HTTPUnprocessableEntity()) |
| 297 | 147 | 147 | ||
| 298 | 148 | #try: | ||
| 299 | 149 | inst = self._build_server_instance(req, env) | ||
| 300 | 150 | #except Exception, e: | ||
| 301 | 151 | # return faults.Fault(exc.HTTPUnprocessableEntity()) | ||
| 302 | 152 | |||
| 303 | 153 | user_id = req.environ['nova.context']['user']['id'] | 148 | user_id = req.environ['nova.context']['user']['id'] |
| 309 | 154 | rpc.cast(context.RequestContext(user_id, user_id), | 149 | ctxt = context.RequestContext(user_id, user_id) |
| 310 | 155 | FLAGS.compute_topic, | 150 | key_pair = self.db_driver.key_pair_get_all_by_user(None, user_id)[0] |
| 311 | 156 | {"method": "run_instance", | 151 | instances = self.compute_api.create_instances(ctxt, |
| 312 | 157 | "args": {"instance_id": inst['id']}}) | 152 | instance_types.get_by_flavor_id(env['server']['flavorId']), |
| 313 | 158 | return _entity_inst(inst) | 153 | utils.import_object(FLAGS.image_service), |
| 314 | 154 | env['server']['imageId'], | ||
| 315 | 155 | self._get_network_topic(ctxt), | ||
| 316 | 156 | name=env['server']['name'], | ||
| 317 | 157 | description=env['server']['name'], | ||
| 318 | 158 | key_name=key_pair['name'], | ||
| 319 | 159 | key_data=key_pair['public_key']) | ||
| 320 | 160 | return _entity_inst(instances[0]) | ||
| 321 | 159 | 161 | ||
| 322 | 160 | def update(self, req, id): | 162 | def update(self, req, id): |
| 323 | 161 | """ Updates the server name or password """ | 163 | """ Updates the server name or password """ |
| 324 | @@ -191,78 +193,6 @@ | |||
| 325 | 191 | return faults.Fault(exc.HTTPUnprocessableEntity()) | 193 | return faults.Fault(exc.HTTPUnprocessableEntity()) |
| 326 | 192 | cloud.reboot(id) | 194 | cloud.reboot(id) |
| 327 | 193 | 195 | ||
| 328 | 194 | def _build_server_instance(self, req, env): | ||
| 329 | 195 | """Build instance data structure and save it to the data store.""" | ||
| 330 | 196 | ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()) | ||
| 331 | 197 | inst = {} | ||
| 332 | 198 | |||
| 333 | 199 | user_id = req.environ['nova.context']['user']['id'] | ||
| 334 | 200 | ctxt = context.RequestContext(user_id, user_id) | ||
| 335 | 201 | |||
| 336 | 202 | flavor_id = env['server']['flavorId'] | ||
| 337 | 203 | |||
| 338 | 204 | instance_type, flavor = [(k, v) for k, v in | ||
| 339 | 205 | instance_types.INSTANCE_TYPES.iteritems() | ||
| 340 | 206 | if v['flavorid'] == flavor_id][0] | ||
| 341 | 207 | |||
| 342 | 208 | image_id = env['server']['imageId'] | ||
| 343 | 209 | img_service = utils.import_object(FLAGS.image_service) | ||
| 344 | 210 | |||
| 345 | 211 | image = img_service.show(image_id) | ||
| 346 | 212 | |||
| 347 | 213 | if not image: | ||
| 348 | 214 | raise Exception("Image not found") | ||
| 349 | 215 | |||
| 350 | 216 | inst['image_id'] = image_id | ||
| 351 | 217 | inst['user_id'] = user_id | ||
| 352 | 218 | inst['launch_time'] = ltime | ||
| 353 | 219 | inst['mac_address'] = utils.generate_mac() | ||
| 354 | 220 | inst['project_id'] = user_id | ||
| 355 | 221 | |||
| 356 | 222 | inst['state_description'] = 'scheduling' | ||
| 357 | 223 | inst['kernel_id'] = image.get('kernelId', FLAGS.default_kernel) | ||
| 358 | 224 | inst['ramdisk_id'] = image.get('ramdiskId', FLAGS.default_ramdisk) | ||
| 359 | 225 | inst['reservation_id'] = utils.generate_uid('r') | ||
| 360 | 226 | |||
| 361 | 227 | inst['display_name'] = env['server']['name'] | ||
| 362 | 228 | inst['display_description'] = env['server']['name'] | ||
| 363 | 229 | |||
| 364 | 230 | #TODO(dietz) this may be ill advised | ||
| 365 | 231 | key_pair_ref = self.db_driver.key_pair_get_all_by_user( | ||
| 366 | 232 | None, user_id)[0] | ||
| 367 | 233 | |||
| 368 | 234 | inst['key_data'] = key_pair_ref['public_key'] | ||
| 369 | 235 | inst['key_name'] = key_pair_ref['name'] | ||
| 370 | 236 | |||
| 371 | 237 | #TODO(dietz) stolen from ec2 api, see TODO there | ||
| 372 | 238 | inst['security_group'] = 'default' | ||
| 373 | 239 | |||
| 374 | 240 | # Flavor related attributes | ||
| 375 | 241 | inst['instance_type'] = instance_type | ||
| 376 | 242 | inst['memory_mb'] = flavor['memory_mb'] | ||
| 377 | 243 | inst['vcpus'] = flavor['vcpus'] | ||
| 378 | 244 | inst['local_gb'] = flavor['local_gb'] | ||
| 379 | 245 | inst['mac_address'] = utils.generate_mac() | ||
| 380 | 246 | inst['launch_index'] = 0 | ||
| 381 | 247 | |||
| 382 | 248 | ref = self.compute_manager.create_instance(ctxt, **inst) | ||
| 383 | 249 | inst['id'] = ref['internal_id'] | ||
| 384 | 250 | |||
| 385 | 251 | inst['hostname'] = str(ref['internal_id']) | ||
| 386 | 252 | self.compute_manager.update_instance(ctxt, inst['id'], **inst) | ||
| 387 | 253 | |||
| 388 | 254 | address = self.network_manager.allocate_fixed_ip(ctxt, | ||
| 389 | 255 | inst['id']) | ||
| 390 | 256 | |||
| 391 | 257 | # TODO(vish): This probably should be done in the scheduler | ||
| 392 | 258 | # network is setup when host is assigned | ||
| 393 | 259 | network_topic = self._get_network_topic(ctxt) | ||
| 394 | 260 | rpc.call(ctxt, | ||
| 395 | 261 | network_topic, | ||
| 396 | 262 | {"method": "setup_fixed_ip", | ||
| 397 | 263 | "args": {"address": address}}) | ||
| 398 | 264 | return inst | ||
| 399 | 265 | |||
| 400 | 266 | def _get_network_topic(self, context): | 196 | def _get_network_topic(self, context): |
| 401 | 267 | """Retrieves the network host for a project""" | 197 | """Retrieves the network host for a project""" |
| 402 | 268 | network_ref = self.network_manager.get_network(context) | 198 | network_ref = self.network_manager.get_network(context) |
| 403 | 269 | 199 | ||
| 404 | === added file 'nova/compute/api.py' | |||
| 405 | --- nova/compute/api.py 1970-01-01 00:00:00 +0000 | |||
| 406 | +++ nova/compute/api.py 2010-12-02 17:38:10 +0000 | |||
| 407 | @@ -0,0 +1,212 @@ | |||
| 408 | 1 | # vim: tabstop=4 shiftwidth=4 softtabstop=4 | ||
| 409 | 2 | |||
| 410 | 3 | # Copyright 2010 United States Government as represented by the | ||
| 411 | 4 | # Administrator of the National Aeronautics and Space Administration. | ||
| 412 | 5 | # All Rights Reserved. | ||
| 413 | 6 | # | ||
| 414 | 7 | # Licensed under the Apache License, Version 2.0 (the "License"); you may | ||
| 415 | 8 | # not use this file except in compliance with the License. You may obtain | ||
| 416 | 9 | # a copy of the License at | ||
| 417 | 10 | # | ||
| 418 | 11 | # http://www.apache.org/licenses/LICENSE-2.0 | ||
| 419 | 12 | # | ||
| 420 | 13 | # Unless required by applicable law or agreed to in writing, software | ||
| 421 | 14 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | ||
| 422 | 15 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | ||
| 423 | 16 | # License for the specific language governing permissions and limitations | ||
| 424 | 17 | # under the License. | ||
| 425 | 18 | |||
| 426 | 19 | """ | ||
| 427 | 20 | Handles all API requests relating to instances (guest vms). | ||
| 428 | 21 | """ | ||
| 429 | 22 | |||
| 430 | 23 | import logging | ||
| 431 | 24 | import time | ||
| 432 | 25 | |||
| 433 | 26 | from nova import db | ||
| 434 | 27 | from nova import exception | ||
| 435 | 28 | from nova import flags | ||
| 436 | 29 | from nova import quota | ||
| 437 | 30 | from nova import rpc | ||
| 438 | 31 | from nova import utils | ||
| 439 | 32 | from nova.compute import instance_types | ||
| 440 | 33 | from nova.db import base | ||
| 441 | 34 | |||
| 442 | 35 | FLAGS = flags.FLAGS | ||
| 443 | 36 | |||
| 444 | 37 | |||
| 445 | 38 | def generate_default_hostname(internal_id): | ||
| 446 | 39 | """Default function to generate a hostname given an instance reference.""" | ||
| 447 | 40 | return str(internal_id) | ||
| 448 | 41 | |||
| 449 | 42 | |||
| 450 | 43 | class ComputeAPI(base.Base): | ||
| 451 | 44 | """API for interacting with the compute manager.""" | ||
| 452 | 45 | |||
| 453 | 46 | def __init__(self, **kwargs): | ||
| 454 | 47 | self.network_manager = utils.import_object(FLAGS.network_manager) | ||
| 455 | 48 | super(ComputeAPI, self).__init__(**kwargs) | ||
| 456 | 49 | |||
| 457 | 50 | # TODO(eday): network_topic arg should go away once we push network | ||
| 458 | 51 | # allocation into the scheduler or compute worker. | ||
| 459 | 52 | def create_instances(self, context, instance_type, image_service, image_id, | ||
| 460 | 53 | network_topic, min_count=1, max_count=1, | ||
| 461 | 54 | kernel_id=None, ramdisk_id=None, name='', | ||
| 462 | 55 | description='', user_data='', key_name=None, | ||
| 463 | 56 | key_data=None, security_group='default', | ||
| 464 | 57 | generate_hostname=generate_default_hostname): | ||
| 465 | 58 | """Create the number of instances requested if quote and | ||
| 466 | 59 | other arguments check out ok.""" | ||
| 467 | 60 | |||
| 468 | 61 | num_instances = quota.allowed_instances(context, max_count, | ||
| 469 | 62 | instance_type) | ||
| 470 | 63 | if num_instances < min_count: | ||
| 471 | 64 | logging.warn("Quota exceeeded for %s, tried to run %s instances", | ||
| 472 | 65 | context.project_id, min_count) | ||
| 473 | 66 | raise quota.QuotaError("Instance quota exceeded. You can only " | ||
| 474 | 67 | "run %s more instances of this type." % | ||
| 475 | 68 | num_instances, "InstanceLimitExceeded") | ||
| 476 | 69 | |||
| 477 | 70 | is_vpn = image_id == FLAGS.vpn_image_id | ||
| 478 | 71 | if not is_vpn: | ||
| 479 | 72 | image = image_service.show(context, image_id) | ||
| 480 | 73 | if kernel_id is None: | ||
| 481 | 74 | kernel_id = image.get('kernelId', FLAGS.default_kernel) | ||
| 482 | 75 | if ramdisk_id is None: | ||
| 483 | 76 | ramdisk_id = image.get('ramdiskId', FLAGS.default_ramdisk) | ||
| 484 | 77 | |||
| 485 | 78 | # Make sure we have access to kernel and ramdisk | ||
| 486 | 79 | image_service.show(context, kernel_id) | ||
| 487 | 80 | image_service.show(context, ramdisk_id) | ||
| 488 | 81 | |||
| 489 | 82 | if security_group is None: | ||
| 490 | 83 | security_group = ['default'] | ||
| 491 | 84 | if not type(security_group) is list: | ||
| 492 | 85 | security_group = [security_group] | ||
| 493 | 86 | |||
| 494 | 87 | security_groups = [] | ||
| 495 | 88 | self.ensure_default_security_group(context) | ||
| 496 | 89 | for security_group_name in security_group: | ||
| 497 | 90 | group = db.security_group_get_by_name(context, | ||
| 498 | 91 | context.project_id, | ||
| 499 | 92 | security_group_name) | ||
| 500 | 93 | security_groups.append(group['id']) | ||
| 501 | 94 | |||
| 502 | 95 | if key_data is None and key_name: | ||
| 503 | 96 | key_pair = db.key_pair_get(context, context.user_id, key_name) | ||
| 504 | 97 | key_data = key_pair['public_key'] | ||
| 505 | 98 | |||
| 506 | 99 | type_data = instance_types.INSTANCE_TYPES[instance_type] | ||
| 507 | 100 | base_options = { | ||
| 508 | 101 | 'reservation_id': utils.generate_uid('r'), | ||
| 509 | 102 | 'image_id': image_id, | ||
| 510 | 103 | 'kernel_id': kernel_id, | ||
| 511 | 104 | 'ramdisk_id': ramdisk_id, | ||
| 512 | 105 | 'state_description': 'scheduling', | ||
| 513 | 106 | 'user_id': context.user_id, | ||
| 514 | 107 | 'project_id': context.project_id, | ||
| 515 | 108 | 'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()), | ||
| 516 | 109 | 'instance_type': instance_type, | ||
| 517 | 110 | 'memory_mb': type_data['memory_mb'], | ||
| 518 | 111 | 'vcpus': type_data['vcpus'], | ||
| 519 | 112 | 'local_gb': type_data['local_gb'], | ||
| 520 | 113 | 'display_name': name, | ||
| 521 | 114 | 'display_description': description, | ||
| 522 | 115 | 'key_name': key_name, | ||
| 523 | 116 | 'key_data': key_data} | ||
| 524 | 117 | |||
| 525 | 118 | elevated = context.elevated() | ||
| 526 | 119 | instances = [] | ||
| 527 | 120 | logging.debug("Going to run %s instances...", num_instances) | ||
| 528 | 121 | for num in range(num_instances): | ||
| 529 | 122 | instance = dict(mac_address=utils.generate_mac(), | ||
| 530 | 123 | launch_index=num, | ||
| 531 | 124 | **base_options) | ||
| 532 | 125 | instance_ref = self.create_instance(context, security_groups, | ||
| 533 | 126 | **instance) | ||
| 534 | 127 | instance_id = instance_ref['id'] | ||
| 535 | 128 | internal_id = instance_ref['internal_id'] | ||
| 536 | 129 | hostname = generate_hostname(internal_id) | ||
| 537 | 130 | self.update_instance(context, instance_id, hostname=hostname) | ||
| 538 | 131 | instances.append(dict(id=instance_id, internal_id=internal_id, | ||
| 539 | 132 | hostname=hostname, **instance)) | ||
| 540 | 133 | |||
| 541 | 134 | # TODO(vish): This probably should be done in the scheduler | ||
| 542 | 135 | # or in compute as a call. The network should be | ||
| 543 | 136 | # allocated after the host is assigned and setup | ||
| 544 | 137 | # can happen at the same time. | ||
| 545 | 138 | address = self.network_manager.allocate_fixed_ip(context, | ||
| 546 | 139 | instance_id, | ||
| 547 | 140 | is_vpn) | ||
| 548 | 141 | rpc.cast(elevated, | ||
| 549 | 142 | network_topic, | ||
| 550 | 143 | {"method": "setup_fixed_ip", | ||
| 551 | 144 | "args": {"address": address}}) | ||
| 552 | 145 | |||
| 553 | 146 | logging.debug("Casting to scheduler for %s/%s's instance %s" % | ||
| 554 | 147 | (context.project_id, context.user_id, instance_id)) | ||
| 555 | 148 | rpc.cast(context, | ||
| 556 | 149 | FLAGS.scheduler_topic, | ||
| 557 | 150 | {"method": "run_instance", | ||
| 558 | 151 | "args": {"topic": FLAGS.compute_topic, | ||
| 559 | 152 | "instance_id": instance_id}}) | ||
| 560 | 153 | |||
| 561 | 154 | return instances | ||
| 562 | 155 | |||
| 563 | 156 | def ensure_default_security_group(self, context): | ||
| 564 | 157 | try: | ||
| 565 | 158 | db.security_group_get_by_name(context, context.project_id, | ||
| 566 | 159 | 'default') | ||
| 567 | 160 | except exception.NotFound: | ||
| 568 | 161 | values = {'name': 'default', | ||
| 569 | 162 | 'description': 'default', | ||
| 570 | 163 | 'user_id': context.user_id, | ||
| 571 | 164 | 'project_id': context.project_id} | ||
| 572 | 165 | group = db.security_group_create(context, values) | ||
| 573 | 166 | |||
| 574 | 167 | def create_instance(self, context, security_groups=None, **kwargs): | ||
| 575 | 168 | """Creates the instance in the datastore and returns the | ||
| 576 | 169 | new instance as a mapping | ||
| 577 | 170 | |||
| 578 | 171 | :param context: The security context | ||
| 579 | 172 | :param security_groups: list of security group ids to | ||
| 580 | 173 | attach to the instance | ||
| 581 | 174 | :param kwargs: All additional keyword args are treated | ||
| 582 | 175 | as data fields of the instance to be | ||
| 583 | 176 | created | ||
| 584 | 177 | |||
| 585 | 178 | :retval Returns a mapping of the instance information | ||
| 586 | 179 | that has just been created | ||
| 587 | 180 | |||
| 588 | 181 | """ | ||
| 589 | 182 | instance_ref = self.db.instance_create(context, kwargs) | ||
| 590 | 183 | inst_id = instance_ref['id'] | ||
| 591 | 184 | # Set sane defaults if not specified | ||
| 592 | 185 | if kwargs.get('display_name') is None: | ||
| 593 | 186 | display_name = "Server %s" % instance_ref['internal_id'] | ||
| 594 | 187 | instance_ref['display_name'] = display_name | ||
| 595 | 188 | self.db.instance_update(context, inst_id, | ||
| 596 | 189 | {'display_name': display_name}) | ||
| 597 | 190 | |||
| 598 | 191 | elevated = context.elevated() | ||
| 599 | 192 | if not security_groups: | ||
| 600 | 193 | security_groups = [] | ||
| 601 | 194 | for security_group_id in security_groups: | ||
| 602 | 195 | self.db.instance_add_security_group(elevated, | ||
| 603 | 196 | inst_id, | ||
| 604 | 197 | security_group_id) | ||
| 605 | 198 | return instance_ref | ||
| 606 | 199 | |||
| 607 | 200 | def update_instance(self, context, instance_id, **kwargs): | ||
| 608 | 201 | """Updates the instance in the datastore. | ||
| 609 | 202 | |||
| 610 | 203 | :param context: The security context | ||
| 611 | 204 | :param instance_id: ID of the instance to update | ||
| 612 | 205 | :param kwargs: All additional keyword args are treated | ||
| 613 | 206 | as data fields of the instance to be | ||
| 614 | 207 | updated | ||
| 615 | 208 | |||
| 616 | 209 | :retval None | ||
| 617 | 210 | |||
| 618 | 211 | """ | ||
| 619 | 212 | self.db.instance_update(context, instance_id, kwargs) | ||
| 620 | 0 | 213 | ||
| 621 | === modified file 'nova/compute/instance_types.py' | |||
| 622 | --- nova/compute/instance_types.py 2010-10-18 22:58:42 +0000 | |||
| 623 | +++ nova/compute/instance_types.py 2010-12-02 17:38:10 +0000 | |||
| 624 | @@ -21,9 +21,29 @@ | |||
| 625 | 21 | The built-in instance properties. | 21 | The built-in instance properties. |
| 626 | 22 | """ | 22 | """ |
| 627 | 23 | 23 | ||
| 628 | 24 | from nova import flags | ||
| 629 | 25 | |||
| 630 | 26 | FLAGS = flags.FLAGS | ||
| 631 | 24 | INSTANCE_TYPES = { | 27 | INSTANCE_TYPES = { |
| 632 | 25 | 'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1), | 28 | 'm1.tiny': dict(memory_mb=512, vcpus=1, local_gb=0, flavorid=1), |
| 633 | 26 | 'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2), | 29 | 'm1.small': dict(memory_mb=2048, vcpus=1, local_gb=20, flavorid=2), |
| 634 | 27 | 'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3), | 30 | 'm1.medium': dict(memory_mb=4096, vcpus=2, local_gb=40, flavorid=3), |
| 635 | 28 | 'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4), | 31 | 'm1.large': dict(memory_mb=8192, vcpus=4, local_gb=80, flavorid=4), |
| 636 | 29 | 'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)} | 32 | 'm1.xlarge': dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)} |
| 637 | 33 | |||
| 638 | 34 | |||
| 639 | 35 | def get_by_type(instance_type): | ||
| 640 | 36 | """Build instance data structure and save it to the data store.""" | ||
| 641 | 37 | if instance_type is None: | ||
| 642 | 38 | return FLAGS.default_instance_type | ||
| 643 | 39 | if instance_type not in INSTANCE_TYPES: | ||
| 644 | 40 | raise exception.ApiError("Unknown instance type: %s", | ||
| 645 | 41 | instance_type) | ||
| 646 | 42 | return instance_type | ||
| 647 | 43 | |||
| 648 | 44 | |||
| 649 | 45 | def get_by_flavor_id(flavor_id): | ||
| 650 | 46 | for instance_type, details in INSTANCE_TYPES.iteritems(): | ||
| 651 | 47 | if details['flavorid'] == flavor_id: | ||
| 652 | 48 | return instance_type | ||
| 653 | 49 | return FLAGS.default_instance_type | ||
| 654 | 30 | 50 | ||
| 655 | === modified file 'nova/compute/manager.py' | |||
| 656 | --- nova/compute/manager.py 2010-12-02 16:08:56 +0000 | |||
| 657 | +++ nova/compute/manager.py 2010-12-02 17:38:10 +0000 | |||
| 658 | @@ -39,13 +39,13 @@ | |||
| 659 | 39 | 39 | ||
| 660 | 40 | from twisted.internet import defer | 40 | from twisted.internet import defer |
| 661 | 41 | 41 | ||
| 662 | 42 | from nova import db | ||
| 663 | 42 | from nova import exception | 43 | from nova import exception |
| 664 | 43 | from nova import flags | 44 | from nova import flags |
| 665 | 44 | from nova import manager | 45 | from nova import manager |
| 666 | 45 | from nova import utils | 46 | from nova import utils |
| 667 | 46 | from nova.compute import power_state | 47 | from nova.compute import power_state |
| 668 | 47 | 48 | ||
| 669 | 48 | |||
| 670 | 49 | FLAGS = flags.FLAGS | 49 | FLAGS = flags.FLAGS |
| 671 | 50 | flags.DEFINE_string('instances_path', '$state_path/instances', | 50 | flags.DEFINE_string('instances_path', '$state_path/instances', |
| 672 | 51 | 'where instances are stored on disk') | 51 | 'where instances are stored on disk') |
| 673 | @@ -84,53 +84,6 @@ | |||
| 674 | 84 | """This call passes stright through to the virtualization driver.""" | 84 | """This call passes stright through to the virtualization driver.""" |
| 675 | 85 | yield self.driver.refresh_security_group(security_group_id) | 85 | yield self.driver.refresh_security_group(security_group_id) |
| 676 | 86 | 86 | ||
| 677 | 87 | def create_instance(self, context, security_groups=None, **kwargs): | ||
| 678 | 88 | """Creates the instance in the datastore and returns the | ||
| 679 | 89 | new instance as a mapping | ||
| 680 | 90 | |||
| 681 | 91 | :param context: The security context | ||
| 682 | 92 | :param security_groups: list of security group ids to | ||
| 683 | 93 | attach to the instance | ||
| 684 | 94 | :param kwargs: All additional keyword args are treated | ||
| 685 | 95 | as data fields of the instance to be | ||
| 686 | 96 | created | ||
| 687 | 97 | |||
| 688 | 98 | :retval Returns a mapping of the instance information | ||
| 689 | 99 | that has just been created | ||
| 690 | 100 | |||
| 691 | 101 | """ | ||
| 692 | 102 | instance_ref = self.db.instance_create(context, kwargs) | ||
| 693 | 103 | inst_id = instance_ref['id'] | ||
| 694 | 104 | # Set sane defaults if not specified | ||
| 695 | 105 | if kwargs.get('display_name') is None: | ||
| 696 | 106 | display_name = "Server %s" % instance_ref['internal_id'] | ||
| 697 | 107 | instance_ref['display_name'] = display_name | ||
| 698 | 108 | self.db.instance_update(context, inst_id, | ||
| 699 | 109 | {'display_name': display_name}) | ||
| 700 | 110 | |||
| 701 | 111 | elevated = context.elevated() | ||
| 702 | 112 | if not security_groups: | ||
| 703 | 113 | security_groups = [] | ||
| 704 | 114 | for security_group_id in security_groups: | ||
| 705 | 115 | self.db.instance_add_security_group(elevated, | ||
| 706 | 116 | inst_id, | ||
| 707 | 117 | security_group_id) | ||
| 708 | 118 | return instance_ref | ||
| 709 | 119 | |||
| 710 | 120 | def update_instance(self, context, instance_id, **kwargs): | ||
| 711 | 121 | """Updates the instance in the datastore. | ||
| 712 | 122 | |||
| 713 | 123 | :param context: The security context | ||
| 714 | 124 | :param instance_id: ID of the instance to update | ||
| 715 | 125 | :param kwargs: All additional keyword args are treated | ||
| 716 | 126 | as data fields of the instance to be | ||
| 717 | 127 | updated | ||
| 718 | 128 | |||
| 719 | 129 | :retval None | ||
| 720 | 130 | |||
| 721 | 131 | """ | ||
| 722 | 132 | self.db.instance_update(context, instance_id, kwargs) | ||
| 723 | 133 | |||
| 724 | 134 | @defer.inlineCallbacks | 87 | @defer.inlineCallbacks |
| 725 | 135 | @exception.wrap_exception | 88 | @exception.wrap_exception |
| 726 | 136 | def run_instance(self, context, instance_id, **_kwargs): | 89 | def run_instance(self, context, instance_id, **_kwargs): |
| 727 | 137 | 90 | ||
| 728 | === added file 'nova/db/base.py' | |||
| 729 | --- nova/db/base.py 1970-01-01 00:00:00 +0000 | |||
| 730 | +++ nova/db/base.py 2010-12-02 17:38:10 +0000 | |||
| 731 | @@ -0,0 +1,36 @@ | |||
| 732 | 1 | # vim: tabstop=4 shiftwidth=4 softtabstop=4 | ||
| 733 | 2 | |||
| 734 | 3 | # Copyright 2010 United States Government as represented by the | ||
| 735 | 4 | # Administrator of the National Aeronautics and Space Administration. | ||
| 736 | 5 | # All Rights Reserved. | ||
| 737 | 6 | # | ||
| 738 | 7 | # Licensed under the Apache License, Version 2.0 (the "License"); you may | ||
| 739 | 8 | # not use this file except in compliance with the License. You may obtain | ||
| 740 | 9 | # a copy of the License at | ||
| 741 | 10 | # | ||
| 742 | 11 | # http://www.apache.org/licenses/LICENSE-2.0 | ||
| 743 | 12 | # | ||
| 744 | 13 | # Unless required by applicable law or agreed to in writing, software | ||
| 745 | 14 | # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | ||
| 746 | 15 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | ||
| 747 | 16 | # License for the specific language governing permissions and limitations | ||
| 748 | 17 | # under the License. | ||
| 749 | 18 | |||
| 750 | 19 | """ | ||
| 751 | 20 | Base class for classes that need modular database access. | ||
| 752 | 21 | """ | ||
| 753 | 22 | |||
| 754 | 23 | from nova import utils | ||
| 755 | 24 | from nova import flags | ||
| 756 | 25 | |||
| 757 | 26 | FLAGS = flags.FLAGS | ||
| 758 | 27 | flags.DEFINE_string('db_driver', 'nova.db.api', | ||
| 759 | 28 | 'driver to use for database access') | ||
| 760 | 29 | |||
| 761 | 30 | |||
| 762 | 31 | class Base(object): | ||
| 763 | 32 | """DB driver is injected in the init method""" | ||
| 764 | 33 | def __init__(self, db_driver=None): | ||
| 765 | 34 | if not db_driver: | ||
| 766 | 35 | db_driver = FLAGS.db_driver | ||
| 767 | 36 | self.db = utils.import_object(db_driver) # pylint: disable-msg=C0103 | ||
| 768 | 0 | 37 | ||
| 769 | === modified file 'nova/manager.py' | |||
| 770 | --- nova/manager.py 2010-11-07 19:51:40 +0000 | |||
| 771 | +++ nova/manager.py 2010-12-02 17:38:10 +0000 | |||
| 772 | @@ -53,23 +53,19 @@ | |||
| 773 | 53 | 53 | ||
| 774 | 54 | from nova import utils | 54 | from nova import utils |
| 775 | 55 | from nova import flags | 55 | from nova import flags |
| 776 | 56 | from nova.db import base | ||
| 777 | 56 | 57 | ||
| 778 | 57 | from twisted.internet import defer | 58 | from twisted.internet import defer |
| 779 | 58 | 59 | ||
| 780 | 59 | FLAGS = flags.FLAGS | 60 | FLAGS = flags.FLAGS |
| 787 | 60 | flags.DEFINE_string('db_driver', 'nova.db.api', | 61 | |
| 788 | 61 | 'driver to use for volume creation') | 62 | |
| 789 | 62 | 63 | class Manager(base.Base): | |
| 784 | 63 | |||
| 785 | 64 | class Manager(object): | ||
| 786 | 65 | """DB driver is injected in the init method""" | ||
| 790 | 66 | def __init__(self, host=None, db_driver=None): | 64 | def __init__(self, host=None, db_driver=None): |
| 791 | 67 | if not host: | 65 | if not host: |
| 792 | 68 | host = FLAGS.host | 66 | host = FLAGS.host |
| 793 | 69 | self.host = host | 67 | self.host = host |
| 797 | 70 | if not db_driver: | 68 | super(Manager, self).__init__(db_driver) |
| 795 | 71 | db_driver = FLAGS.db_driver | ||
| 796 | 72 | self.db = utils.import_object(db_driver) # pylint: disable-msg=C0103 | ||
| 798 | 73 | 69 | ||
| 799 | 74 | @defer.inlineCallbacks | 70 | @defer.inlineCallbacks |
| 800 | 75 | def periodic_tasks(self, context=None): | 71 | def periodic_tasks(self, context=None): |
| 801 | 76 | 72 | ||
| 802 | === modified file 'nova/quota.py' | |||
| 803 | --- nova/quota.py 2010-10-21 18:49:51 +0000 | |||
| 804 | +++ nova/quota.py 2010-12-02 17:38:10 +0000 | |||
| 805 | @@ -94,3 +94,8 @@ | |||
| 806 | 94 | quota = get_quota(context, project_id) | 94 | quota = get_quota(context, project_id) |
| 807 | 95 | allowed_floating_ips = quota['floating_ips'] - used_floating_ips | 95 | allowed_floating_ips = quota['floating_ips'] - used_floating_ips |
| 808 | 96 | return min(num_floating_ips, allowed_floating_ips) | 96 | return min(num_floating_ips, allowed_floating_ips) |
| 809 | 97 | |||
| 810 | 98 | |||
| 811 | 99 | class QuotaError(exception.ApiError): | ||
| 812 | 100 | """Quota Exceeeded""" | ||
| 813 | 101 | pass | ||
| 814 | 97 | 102 | ||
| 815 | === modified file 'nova/tests/api/openstack/fakes.py' | |||
| 816 | --- nova/tests/api/openstack/fakes.py 2010-11-30 18:52:46 +0000 | |||
| 817 | +++ nova/tests/api/openstack/fakes.py 2010-12-02 17:38:10 +0000 | |||
| 818 | @@ -72,7 +72,7 @@ | |||
| 819 | 72 | 72 | ||
| 820 | 73 | 73 | ||
| 821 | 74 | def stub_out_image_service(stubs): | 74 | def stub_out_image_service(stubs): |
| 823 | 75 | def fake_image_show(meh, id): | 75 | def fake_image_show(meh, context, id): |
| 824 | 76 | return dict(kernelId=1, ramdiskId=1) | 76 | return dict(kernelId=1, ramdiskId=1) |
| 825 | 77 | 77 | ||
| 826 | 78 | stubs.Set(nova.image.local.LocalImageService, 'show', fake_image_show) | 78 | stubs.Set(nova.image.local.LocalImageService, 'show', fake_image_show) |
| 827 | 79 | 79 | ||
| 828 | === modified file 'nova/tests/api/openstack/test_servers.py' | |||
| 829 | --- nova/tests/api/openstack/test_servers.py 2010-12-01 20:18:24 +0000 | |||
| 830 | +++ nova/tests/api/openstack/test_servers.py 2010-12-02 17:38:10 +0000 | |||
| 831 | @@ -43,6 +43,10 @@ | |||
| 832 | 43 | return [stub_instance(i, user_id) for i in xrange(5)] | 43 | return [stub_instance(i, user_id) for i in xrange(5)] |
| 833 | 44 | 44 | ||
| 834 | 45 | 45 | ||
| 835 | 46 | def return_security_group(context, instance_id, security_group_id): | ||
| 836 | 47 | pass | ||
| 837 | 48 | |||
| 838 | 49 | |||
| 839 | 46 | def stub_instance(id, user_id=1): | 50 | def stub_instance(id, user_id=1): |
| 840 | 47 | return Instance(id=id, state=0, image_id=10, display_name='server%s' % id, | 51 | return Instance(id=id, state=0, image_id=10, display_name='server%s' % id, |
| 841 | 48 | user_id=user_id) | 52 | user_id=user_id) |
| 842 | @@ -63,6 +67,8 @@ | |||
| 843 | 63 | return_server) | 67 | return_server) |
| 844 | 64 | self.stubs.Set(nova.db.api, 'instance_get_all_by_user', | 68 | self.stubs.Set(nova.db.api, 'instance_get_all_by_user', |
| 845 | 65 | return_servers) | 69 | return_servers) |
| 846 | 70 | self.stubs.Set(nova.db.api, 'instance_add_security_group', | ||
| 847 | 71 | return_security_group) | ||
| 848 | 66 | 72 | ||
| 849 | 67 | def tearDown(self): | 73 | def tearDown(self): |
| 850 | 68 | self.stubs.UnsetAll() | 74 | self.stubs.UnsetAll() |
| 851 | 69 | 75 | ||
| 852 | === modified file 'nova/tests/compute_unittest.py' | |||
| 853 | --- nova/tests/compute_unittest.py 2010-12-02 16:08:56 +0000 | |||
| 854 | +++ nova/tests/compute_unittest.py 2010-12-02 17:38:10 +0000 | |||
| 855 | @@ -31,6 +31,7 @@ | |||
| 856 | 31 | from nova import test | 31 | from nova import test |
| 857 | 32 | from nova import utils | 32 | from nova import utils |
| 858 | 33 | from nova.auth import manager | 33 | from nova.auth import manager |
| 859 | 34 | from nova.compute import api as compute_api | ||
| 860 | 34 | 35 | ||
| 861 | 35 | FLAGS = flags.FLAGS | 36 | FLAGS = flags.FLAGS |
| 862 | 36 | 37 | ||
| 863 | @@ -43,6 +44,7 @@ | |||
| 864 | 43 | self.flags(connection_type='fake', | 44 | self.flags(connection_type='fake', |
| 865 | 44 | network_manager='nova.network.manager.FlatManager') | 45 | network_manager='nova.network.manager.FlatManager') |
| 866 | 45 | self.compute = utils.import_object(FLAGS.compute_manager) | 46 | self.compute = utils.import_object(FLAGS.compute_manager) |
| 867 | 47 | self.compute_api = compute_api.ComputeAPI() | ||
| 868 | 46 | self.manager = manager.AuthManager() | 48 | self.manager = manager.AuthManager() |
| 869 | 47 | self.user = self.manager.create_user('fake', 'fake', 'fake') | 49 | self.user = self.manager.create_user('fake', 'fake', 'fake') |
| 870 | 48 | self.project = self.manager.create_project('fake', 'fake', 'fake') | 50 | self.project = self.manager.create_project('fake', 'fake', 'fake') |
| 871 | @@ -70,7 +72,8 @@ | |||
| 872 | 70 | """Verify that an instance cannot be created without a display_name.""" | 72 | """Verify that an instance cannot be created without a display_name.""" |
| 873 | 71 | cases = [dict(), dict(display_name=None)] | 73 | cases = [dict(), dict(display_name=None)] |
| 874 | 72 | for instance in cases: | 74 | for instance in cases: |
| 876 | 73 | ref = self.compute.create_instance(self.context, None, **instance) | 75 | ref = self.compute_api.create_instance(self.context, None, |
| 877 | 76 | **instance) | ||
| 878 | 74 | try: | 77 | try: |
| 879 | 75 | self.assertNotEqual(ref.display_name, None) | 78 | self.assertNotEqual(ref.display_name, None) |
| 880 | 76 | finally: | 79 | finally: |
| 881 | @@ -86,9 +89,9 @@ | |||
| 882 | 86 | 'user_id': self.user.id, | 89 | 'user_id': self.user.id, |
| 883 | 87 | 'project_id': self.project.id} | 90 | 'project_id': self.project.id} |
| 884 | 88 | group = db.security_group_create(self.context, values) | 91 | group = db.security_group_create(self.context, values) |
| 888 | 89 | ref = self.compute.create_instance(self.context, | 92 | ref = self.compute_api.create_instance(self.context, |
| 889 | 90 | security_groups=[group['id']], | 93 | security_groups=[group['id']], |
| 890 | 91 | **inst) | 94 | **inst) |
| 891 | 92 | # reload to get groups | 95 | # reload to get groups |
| 892 | 93 | instance_ref = db.instance_get(self.context, ref['id']) | 96 | instance_ref = db.instance_get(self.context, ref['id']) |
| 893 | 94 | try: | 97 | try: |
| 894 | 95 | 98 | ||
| 895 | === modified file 'nova/tests/quota_unittest.py' | |||
| 896 | --- nova/tests/quota_unittest.py 2010-11-17 21:23:12 +0000 | |||
| 897 | +++ nova/tests/quota_unittest.py 2010-12-02 17:38:10 +0000 | |||
| 898 | @@ -94,11 +94,12 @@ | |||
| 899 | 94 | for i in range(FLAGS.quota_instances): | 94 | for i in range(FLAGS.quota_instances): |
| 900 | 95 | instance_id = self._create_instance() | 95 | instance_id = self._create_instance() |
| 901 | 96 | instance_ids.append(instance_id) | 96 | instance_ids.append(instance_id) |
| 903 | 97 | self.assertRaises(cloud.QuotaError, self.cloud.run_instances, | 97 | self.assertRaises(quota.QuotaError, self.cloud.run_instances, |
| 904 | 98 | self.context, | 98 | self.context, |
| 905 | 99 | min_count=1, | 99 | min_count=1, |
| 906 | 100 | max_count=1, | 100 | max_count=1, |
| 908 | 101 | instance_type='m1.small') | 101 | instance_type='m1.small', |
| 909 | 102 | image_id='fake') | ||
| 910 | 102 | for instance_id in instance_ids: | 103 | for instance_id in instance_ids: |
| 911 | 103 | db.instance_destroy(self.context, instance_id) | 104 | db.instance_destroy(self.context, instance_id) |
| 912 | 104 | 105 | ||
| 913 | @@ -106,11 +107,12 @@ | |||
| 914 | 106 | instance_ids = [] | 107 | instance_ids = [] |
| 915 | 107 | instance_id = self._create_instance(cores=4) | 108 | instance_id = self._create_instance(cores=4) |
| 916 | 108 | instance_ids.append(instance_id) | 109 | instance_ids.append(instance_id) |
| 918 | 109 | self.assertRaises(cloud.QuotaError, self.cloud.run_instances, | 110 | self.assertRaises(quota.QuotaError, self.cloud.run_instances, |
| 919 | 110 | self.context, | 111 | self.context, |
| 920 | 111 | min_count=1, | 112 | min_count=1, |
| 921 | 112 | max_count=1, | 113 | max_count=1, |
| 923 | 113 | instance_type='m1.small') | 114 | instance_type='m1.small', |
| 924 | 115 | image_id='fake') | ||
| 925 | 114 | for instance_id in instance_ids: | 116 | for instance_id in instance_ids: |
| 926 | 115 | db.instance_destroy(self.context, instance_id) | 117 | db.instance_destroy(self.context, instance_id) |
| 927 | 116 | 118 | ||
| 928 | @@ -119,7 +121,7 @@ | |||
| 929 | 119 | for i in range(FLAGS.quota_volumes): | 121 | for i in range(FLAGS.quota_volumes): |
| 930 | 120 | volume_id = self._create_volume() | 122 | volume_id = self._create_volume() |
| 931 | 121 | volume_ids.append(volume_id) | 123 | volume_ids.append(volume_id) |
| 933 | 122 | self.assertRaises(cloud.QuotaError, self.cloud.create_volume, | 124 | self.assertRaises(quota.QuotaError, self.cloud.create_volume, |
| 934 | 123 | self.context, | 125 | self.context, |
| 935 | 124 | size=10) | 126 | size=10) |
| 936 | 125 | for volume_id in volume_ids: | 127 | for volume_id in volume_ids: |
| 937 | @@ -129,7 +131,7 @@ | |||
| 938 | 129 | volume_ids = [] | 131 | volume_ids = [] |
| 939 | 130 | volume_id = self._create_volume(size=20) | 132 | volume_id = self._create_volume(size=20) |
| 940 | 131 | volume_ids.append(volume_id) | 133 | volume_ids.append(volume_id) |
| 942 | 132 | self.assertRaises(cloud.QuotaError, | 134 | self.assertRaises(quota.QuotaError, |
| 943 | 133 | self.cloud.create_volume, | 135 | self.cloud.create_volume, |
| 944 | 134 | self.context, | 136 | self.context, |
| 945 | 135 | size=10) | 137 | size=10) |
| 946 | @@ -146,6 +148,6 @@ | |||
| 947 | 146 | # make an rpc.call, the test just finishes with OK. It | 148 | # make an rpc.call, the test just finishes with OK. It |
| 948 | 147 | # appears to be something in the magic inline callbacks | 149 | # appears to be something in the magic inline callbacks |
| 949 | 148 | # that is breaking. | 150 | # that is breaking. |
| 951 | 149 | self.assertRaises(cloud.QuotaError, self.cloud.allocate_address, | 151 | self.assertRaises(quota.QuotaError, self.cloud.allocate_address, |
| 952 | 150 | self.context) | 152 | self.context) |
| 953 | 151 | db.floating_ip_destroy(context.get_admin_context(), address) | 153 | db.floating_ip_destroy(context.get_admin_context(), address) |
Questions on irc were addressed by 424. LGTM. We definitely need to clean up cloud unittests.