def test_declare(self): self.assert_('answer' not in self.global_FLAGS) flags.DECLARE('answer', 'engine.tests.declare_flags') self.assert_('answer' in self.global_FLAGS) self.assertEqual(self.global_FLAGS.answer, 42) # Make sure we don't overwrite anything self.global_FLAGS.answer = 256 self.assertEqual(self.global_FLAGS.answer, 256) flags.DECLARE('answer', 'engine.tests.declare_flags') self.assertEqual(self.global_FLAGS.answer, 256)
from engine import db from engine import exception from engine import flags from engine import log as logging from engine import rpc from engine import utils from engine.compute import api as compute_api from engine.compute import power_state from engine.compute import vm_states from engine.api.ec2 import ec2utils FLAGS = flags.FLAGS LOG = logging.getLogger('engine.scheduler.driver') flags.DEFINE_integer('service_down_time', 60, 'maximum time since last check-in for up service') flags.DECLARE('instances_path', 'engine.compute.manager') def cast_to_volume_host(context, host, method, update_db=True, **kwargs): """Cast request to a volume host queue""" if update_db: volume_id = kwargs.get('volume_id', None) if volume_id is not None: now = utils.utcnow() db.volume_update(context, volume_id, { 'host': host, 'scheduled_at': now }) rpc.cast(context, db.queue_get_for(context, 'volume', host), { "method": method,
# 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. """Database setup and migration commands.""" from engine import flags from engine import utils FLAGS = flags.FLAGS flags.DECLARE('db_backend', 'engine.db') IMPL = utils.LazyPluggable(FLAGS['db_backend'], sqlalchemy='engine.db.sqlalchemy.migration') def db_sync(version=None): """Migrate the database to `version` or the most recent version.""" return IMPL.db_sync(version=version) def db_version(): """Display the current database version.""" return IMPL.db_version()
import webob.dec import webob.exc from engine.api.x7 import common from engine.api.x7 import wsgi from engine import auth from engine import context from engine import exception from engine import flags from engine import log as logging from engine import utils from engine import wsgi as base_wsgi LOG = logging.getLogger('engine.api.x7.v2.auth') FLAGS = flags.FLAGS flags.DECLARE('use_forwarded_for', 'engine.api.auth') class NoAuthMiddleware(base_wsgi.Middleware): """Return a fake token if one isn't specified.""" @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): if 'X-Auth-Token' not in req.headers: user_id = req.headers.get('X-Auth-User', 'admin') project_id = req.headers.get('X-Auth-Project-Id', 'admin') os_url = os.path.join(req.url, project_id) res = webob.Response() # NOTE(vish): This is expecting and returning Auth(1.1), whereas # keystone uses 2.0 auth. We should probably allow # 2.0 auth here as well. res.headers['X-Auth-Token'] = '%s:%s' % (user_id, project_id)
# License for the specific language governing permissions and limitations # under the License. """ Tests For Console proxy. """ from engine import context from engine import db from engine import exception from engine import flags from engine import test from engine import utils FLAGS = flags.FLAGS flags.DECLARE('console_driver', 'engine.console.manager') class ConsoleTestCase(test.TestCase): """Test case for console proxy""" def setUp(self): super(ConsoleTestCase, self).setUp() self.flags(console_driver='engine.console.fake.FakeConsoleProxy', stub_compute=True) self.console = utils.import_object(FLAGS.console_manager) self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id) self.host = 'test_compute_host' def _create_instance(self):
""" from engine import db from engine import flags from engine import context from engine import test from engine import log as logging from engine import utils import engine.image.fake from engine.compute import utils as compute_utils from engine.compute import instance_types from engine.notifier import test_notifier LOG = logging.getLogger('engine.tests.compute_utils') FLAGS = flags.FLAGS flags.DECLARE('stub_network', 'engine.compute.manager') class UsageInfoTestCase(test.TestCase): def setUp(self): super(UsageInfoTestCase, self).setUp() self.flags(connection_type='fake', stub_network=True, notification_driver='engine.notifier.test_notifier', network_manager='engine.network.manager.FlatManager') self.compute = utils.import_object(FLAGS.compute_manager) self.user_id = 'fake' self.project_id = 'fake' self.context = context.RequestContext(self.user_id, self.project_id) test_notifier.NOTIFICATIONS = []
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Volume drivers for libvirt.""" import os import time from engine import exception from engine import flags from engine import log as logging from engine import utils LOG = logging.getLogger('engine.virt.libvirt.volume') FLAGS = flags.FLAGS flags.DECLARE('num_iscsi_scan_tries', 'engine.volume.driver') class LibvirtVolumeDriver(object): """Base class for volume drivers.""" def __init__(self, connection): self.connection = connection def _pick_volume_driver(self): hypervisor_type = self.connection.get_hypervisor_type().lower() return "phy" if hypervisor_type == "xen" else "qemu" def connect_volume(self, connection_info, mount_device): """Connect the volume. Returns xml for libvirt.""" driver = self._pick_volume_driver() device_path = connection_info['data']['device_path']
from engine.api.ec2 import ec2utils from engine import block_device from engine import compute from engine import context from engine import db from engine import exception from engine import flags from engine import log as logging from engine import network from engine import volume from engine import wsgi LOG = logging.getLogger('engine.api.metadata') FLAGS = flags.FLAGS flags.DECLARE('use_forwarded_for', 'engine.api.auth') flags.DECLARE('dhcp_domain', 'engine.network.manager') _DEFAULT_MAPPINGS = { 'ami': 'sda1', 'ephemeral0': 'sda2', 'root': block_device.DEFAULT_ROOT_DEV_NAME, 'swap': 'sda3' } class Versions(wsgi.Application): @webob.dec.wsgify(RequestClass=wsgi.Request) def __call__(self, req): """Respond to a request for all versions.""" # available api versions
# 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 engine import flags FLAGS = flags.FLAGS flags.DECLARE('volume_driver', 'engine.volume.manager') FLAGS['volume_driver'].SetDefault('engine.volume.driver.FakeISCSIDriver') FLAGS['connection_type'].SetDefault('fake') FLAGS['fake_rabbit'].SetDefault(True) FLAGS['rpc_backend'].SetDefault('engine.rpc.impl_fake') flags.DECLARE('auth_driver', 'engine.auth.manager') FLAGS['auth_driver'].SetDefault('engine.auth.dbdriver.DbDriver') flags.DECLARE('network_size', 'engine.network.manager') flags.DECLARE('num_networks', 'engine.network.manager') flags.DECLARE('fake_network', 'engine.network.manager') FLAGS['network_size'].SetDefault(8) FLAGS['num_networks'].SetDefault(2) FLAGS['fake_network'].SetDefault(True) FLAGS['image_service'].SetDefault('engine.image.fake.FakeImageService') flags.DECLARE('iscsi_num_targets', 'engine.volume.driver') FLAGS['iscsi_num_targets'].SetDefault(8)
from engine.db.sqlalchemy.session import get_session from engine.db.sqlalchemy import models from engine.db.sqlalchemy import api as sqlalchemy_api from engine.api.x7 import wsgi import engine.api.x7.v2 as x7_api from engine.api.x7.v2 import extensions from engine.api.x7.v2 import views from engine.compute import instance_types from engine.scheduler import api as scheduler_api from sqlalchemy.orm import joinedload FLAGS = flags.FLAGS flags.DECLARE('max_gigabytes', 'engine.scheduler.simple') flags.DECLARE('max_cores', 'engine.scheduler.simple') LOG = logging.getLogger('engine.api.x7.admin') class AdminQuotasController(object): def _format_quota_set(self, project_id, quota_set): """Convert the quota object to a result dict""" if quota_set: return { 'id': project_id, 'metadata_items': quota_set['metadata_items'], 'injected_file_content_bytes':
"""vm_vdi_cleaner.py - List or clean orphaned VDIs/instances on XenServer.""" import doctest import optparse import sys import XenAPI from engine import context from engine import db from engine import exception from engine import flags from engine import utils from engine.virt import xenapi_conn flags.DECLARE("resize_confirm_window", "engine.compute.manager") flags.DECLARE("xenapi_connection_url", "engine.virt.xenapi_conn") flags.DECLARE("xenapi_connection_username", "engine.virt.xenapi_conn") flags.DECLARE("xenapi_connection_password", "engine.virt.xenapi_conn") FLAGS = flags.FLAGS # NOTE(sirp): Engine futzs with the sys.argv in order to provide default # flagfile. To isolate this awful practice, we're supplying a dummy # argument list. dummy = ["fakearg"] utils.default_flagfile(args=dummy) FLAGS(dummy) class UnrecognizedNameLabel(Exception): pass
# 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 sqlalchemy import * from sqlalchemy import Column, MetaData, Table, String from engine import flags flags.DECLARE('default_floating_pool', 'engine.network.manager') flags.DECLARE('public_interface', 'engine.network.linux_net') FLAGS = flags.FLAGS meta = MetaData() pool_column = Column('pool', String(255)) interface_column = Column('interface', String(255)) def upgrade(migrate_engine): meta.bind = migrate_engine table = Table('floating_ips', meta, autoload=True) table.create_column(pool_column) table.create_column(interface_column) table.update().values(pool=FLAGS.default_floating_pool,
""" Handles all requests relating to volumes. """ from eventlet import greenthread from engine import exception from engine import flags from engine import log as logging from engine import quota from engine import rpc from engine import utils from engine.db import base FLAGS = flags.FLAGS flags.DECLARE('storage_availability_zone', 'engine.volume.manager') LOG = logging.getLogger('engine.volume') class API(base.Base): """API for interacting with the volume manager.""" def create(self, context, size, snapshot_id, name, description, volume_type=None, metadata=None, availability_zone=None):