openstack
/
astara
Code Issues Proposed changes

Step 3 of module rename 

In this step all of the imports and usage of akanda.rug is updated to
use astara. Addtionally rename all internal references from Akanda to
Astara.

Change-Id: I0cb8596066d949bceaadc4718b210fc373b5f296
Depends-On: I87106ae63747291bb6424839b5155f53136c54f9
Implements: blueprint convert-to-astara
This commit is contained in:
Mark McClain 2015-11-25 12:01:48 -05:00
parent 948c3742c8
commit a5ab32c80f
115 changed files with 625 additions and 641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
akanda/__init__.py
View File

@ -1,35 +0,0 @@
# Copyright 2014 DreamHost, LLC
#
# Author: DreamHost, 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.
# Copyright 2014 DreamHost, LLC
#
# Author: DreamHost, 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.
__import__('pkg_resources').declare_namespace(__name__)

1
akanda/rug
View File

@ -1 +0,0 @@
../astara

14
astara/api/akanda_client.py → astara/api/astara_client.py
View File

@ -21,9 +21,9 @@ from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_serialization import jsonutils from oslo_serialization import jsonutils
AKANDA_ULA_PREFIX = 'fdca:3ba5:a17a:acda::/64' ASTARA_ULA_PREFIX = 'fdca:3ba5:a17a:acda::/64'
AKANDA_MGT_SERVICE_PORT = 5000 ASTARA_MGT_SERVICE_PORT = 5000
AKANDA_BASE_PATH = '/v1/' ASTARA_BASE_PATH = '/v1/'
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
CONF = cfg.CONF CONF = cfg.CONF
@ -49,7 +49,7 @@ def _get_proxyless_session():
def is_alive(host, port): def is_alive(host, port):
path = AKANDA_BASE_PATH + 'firewall/rules' path = ASTARA_BASE_PATH + 'firewall/rules'
try: try:
s = _get_proxyless_session() s = _get_proxyless_session()
r = s.get(_mgt_url(host, port, path), timeout=cfg.CONF.alive_timeout) r = s.get(_mgt_url(host, port, path), timeout=cfg.CONF.alive_timeout)
@ -61,14 +61,14 @@ def is_alive(host, port):
def get_interfaces(host, port): def get_interfaces(host, port):
path = AKANDA_BASE_PATH + 'system/interfaces' path = ASTARA_BASE_PATH + 'system/interfaces'
s = _get_proxyless_session() s = _get_proxyless_session()
r = s.get(_mgt_url(host, port, path), timeout=30) r = s.get(_mgt_url(host, port, path), timeout=30)
return r.json().get('interfaces', []) return r.json().get('interfaces', [])
def update_config(host, port, config_dict): def update_config(host, port, config_dict):
path = AKANDA_BASE_PATH + 'system/config' path = ASTARA_BASE_PATH + 'system/config'
headers = {'Content-type': 'application/json'} headers = {'Content-type': 'application/json'}
s = _get_proxyless_session() s = _get_proxyless_session()
@ -85,7 +85,7 @@ def update_config(host, port, config_dict):
def read_labels(host, port): def read_labels(host, port):
path = AKANDA_BASE_PATH + 'firewall/labels' path = ASTARA_BASE_PATH + 'firewall/labels'
s = _get_proxyless_session() s = _get_proxyless_session()
r = s.post(_mgt_url(host, port, path), timeout=30) r = s.post(_mgt_url(host, port, path), timeout=30)
return r.json().get('labels', []) return r.json().get('labels', [])

2
astara/api/config/common.py
View File

@ -73,7 +73,7 @@ def _allocation_config(ports, subnets_dict):
allocations = [] allocations = []
for port in ports: for port in ports:
if port.name.startswith('AKANDA:VRRP:'): if port.name.startswith('ASTARA:VRRP:'):
continue continue
addrs = { addrs = {

2
astara/api/config/loadbalancer.py
View File

@ -16,7 +16,7 @@
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.api.config import common from astara.api.config import common
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

4
astara/api/config/router.py
View File

@ -21,8 +21,8 @@ from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_serialization import jsonutils from oslo_serialization import jsonutils
from akanda.rug.common.i18n import _LI, _LW from astara.common.i18n import _LI, _LW
from akanda.rug.api.config import common from astara.api.config import common
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

70
astara/api/neutron.py
View File

@ -31,10 +31,10 @@ from oslo_context import context
from oslo_log import log as logging from oslo_log import log as logging
from oslo_utils import importutils from oslo_utils import importutils
from akanda.rug.common.i18n import _, _LI, _LW from astara.common.i18n import _, _LI, _LW
from akanda.rug.common.linux import ip_lib from astara.common.linux import ip_lib
from akanda.rug.api import keystone from astara.api import keystone
from akanda.rug.common import rpc from astara.common import rpc
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
CONF = cfg.CONF CONF = cfg.CONF
@ -47,11 +47,15 @@ neutron_opts = [
cfg.StrOpt('external_subnet_id'), cfg.StrOpt('external_subnet_id'),
cfg.StrOpt('management_prefix', default='fdca:3ba5:a17a:acda::/64'), cfg.StrOpt('management_prefix', default='fdca:3ba5:a17a:acda::/64'),
cfg.StrOpt('external_prefix', default='172.16.77.0/24'), cfg.StrOpt('external_prefix', default='172.16.77.0/24'),
cfg.IntOpt('akanda_mgt_service_port', default=5000), cfg.IntOpt('astara_mgt_service_port', default=5000),
cfg.StrOpt('default_instance_flavor', default=1), cfg.StrOpt('default_instance_flavor', default=1),
cfg.StrOpt('interface_driver'), cfg.StrOpt('interface_driver'),
cfg.BoolOpt('neutron_port_security_extension_enabled', default=True), cfg.BoolOpt('neutron_port_security_extension_enabled', default=True),
# legacy_fallback option is deprecated and will be removed in the N-release
cfg.BoolOpt('legacy_fallback_mode', default=True,
help=_('Check for resources using the Liberty naming scheme '
'when the modern name does not exist.'))
] ]
CONF.register_opts(neutron_opts) CONF.register_opts(neutron_opts)
@ -61,7 +65,7 @@ DEVICE_OWNER_ROUTER_MGT = "network:router_management"
DEVICE_OWNER_ROUTER_INT = "network:router_interface" DEVICE_OWNER_ROUTER_INT = "network:router_interface"
DEVICE_OWNER_ROUTER_GW = "network:router_gateway" DEVICE_OWNER_ROUTER_GW = "network:router_gateway"
DEVICE_OWNER_FLOATINGIP = "network:floatingip" DEVICE_OWNER_FLOATINGIP = "network:floatingip"
DEVICE_OWNER_RUG = "network:akanda" DEVICE_OWNER_RUG = "network:astara"
PLUGIN_ROUTER_RPC_TOPIC = 'q-l3-plugin' PLUGIN_ROUTER_RPC_TOPIC = 'q-l3-plugin'
@ -461,8 +465,8 @@ class Member(DictModelBase):
) )
class AkandaExtClientWrapper(client.Client): class AstaraExtClientWrapper(client.Client):
"""Add client support for Akanda Extensions. """ """Add client support for Astara Extensions. """
routerstatus_path = '/dhrouterstatus' routerstatus_path = '/dhrouterstatus'
lbstatus_path = '/akloadbalancerstatus' lbstatus_path = '/akloadbalancerstatus'
@ -515,7 +519,7 @@ class Neutron(object):
def __init__(self, conf): def __init__(self, conf):
self.conf = conf self.conf = conf
ks_session = keystone.KeystoneSession() ks_session = keystone.KeystoneSession()
self.api_client = AkandaExtClientWrapper( self.api_client = AstaraExtClientWrapper(
session=ks_session.session, session=ks_session.session,
) )
self.l3_rpc_client = L3PluginApi(PLUGIN_ROUTER_RPC_TOPIC, self.l3_rpc_client = L3PluginApi(PLUGIN_ROUTER_RPC_TOPIC,
@ -666,7 +670,7 @@ class Neutron(object):
port_dict = dict( port_dict = dict(
admin_state_up=True, admin_state_up=True,
network_id=network_id, network_id=network_id,
name='AKANDA:%s:%s' % (label, object_id), name='ASTARA:%s:%s' % (label, object_id),
security_groups=[] security_groups=[]
) )
@ -688,9 +692,16 @@ class Neutron(object):
return port return port
def delete_vrrp_port(self, object_id, label='VRRP'): def delete_vrrp_port(self, object_id, label='VRRP'):
name = 'AKANDA:%s:%s' % (label, object_id) name = 'ASTARA:%s:%s' % (label, object_id)
response = self.api_client.list_ports(name=name) response = self.api_client.list_ports(name=name)
port_data = response.get('ports') port_data = response.get('ports')
if not port_data and self.conf.legacy_fallback_mode:
name = name.replace('ASTARA', 'AKANDA')
LOG.info(_LI('Attempting legacy query for %s.'), name)
response = self.api_client.list_ports(name=name)
port_data = response.get('ports')
if not port_data: if not port_data:
LOG.warning(_LW( LOG.warning(_LW(
'Unable to find VRRP port to delete with name %s.'), name) 'Unable to find VRRP port to delete with name %s.'), name)
@ -761,7 +772,7 @@ class Neutron(object):
host_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, socket.gethostname())) host_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, socket.gethostname()))
name = 'AKANDA:RUG:%s' % network_type.upper() name = 'ASTARA:RUG:%s' % network_type.upper()
query_dict = dict(device_owner=DEVICE_OWNER_RUG, query_dict = dict(device_owner=DEVICE_OWNER_RUG,
device_id=host_id, device_id=host_id,
@ -770,7 +781,31 @@ class Neutron(object):
ports = self.api_client.list_ports(**query_dict)['ports'] ports = self.api_client.list_ports(**query_dict)['ports']
if ports: if not ports and self.conf.legacy_fallback_mode:
LOG.info(_LI('Attempting legacy query for %s.'), name)
query_dict.update({
'name': name.replace('ASTARA', 'AKANDA'),
'device_owner': DEVICE_OWNER_RUG.replace('astara', 'akanda')
})
ports = self.api_client.list_ports(**query_dict)['ports']
if ports and 'AKANDA' in ports[0]['name']:
port = Port.from_dict(ports[0])
LOG.info(
_LI('migrating port to ASTARA for port %r and using local %s'),
port,
network_type
)
self.api_client.update_port(
port.id,
{
'port': {
'name': port.name.replace('AKANDA', 'ASTARA'),
'device_owner': DEVICE_OWNER_RUG
}
}
)
elif ports:
port = Port.from_dict(ports[0]) port = Port.from_dict(ports[0])
LOG.info(_LI('already have local %s port, using %r'), LOG.info(_LI('already have local %s port, using %r'),
network_type, port) network_type, port)
@ -838,11 +873,18 @@ class Neutron(object):
host_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, socket.gethostname())) host_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, socket.gethostname()))
query_dict = dict( query_dict = dict(
device_owner=DEVICE_OWNER_RUG, device_owner=DEVICE_OWNER_RUG,
name='AKANDA:RUG:MANAGEMENT', name='ASTARA:RUG:MANAGEMENT',
device_id=host_id device_id=host_id
) )
ports = self.api_client.list_ports(**query_dict)['ports'] ports = self.api_client.list_ports(**query_dict)['ports']
if not ports and self.conf.legacy_fallback_mode:
query_dict.update({
'name': 'AKANDA:RUG:MANAGEMENT',
'device_owner': DEVICE_OWNER_RUG.replace('astara', 'akanda')
})
ports = self.api_client.list_ports(**query_dict)['ports']
if ports: if ports:
port = Port.from_dict(ports[0]) port = Port.from_dict(ports[0])
device_name = driver.get_device_name(port) device_name = driver.get_device_name(port)

12
astara/api/nova.py
View File

@ -23,11 +23,11 @@ from novaclient import exceptions as novaclient_exceptions
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.common.i18n import _LW, _LE, _LI from astara.common.i18n import _LW, _LE, _LI
from akanda.rug.api import keystone from astara.api import keystone
from akanda.rug.api import neutron from astara.api import neutron
from akanda.rug.common import config from astara.common import config
from akanda.rug.pez import rpcapi as pez_api from astara.pez import rpcapi as pez_api
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -125,7 +125,7 @@ class InstanceProvider(object):
class PezInstanceProvider(InstanceProvider): class PezInstanceProvider(InstanceProvider):
def __init__(self, client): def __init__(self, client):
super(PezInstanceProvider, self).__init__(client) super(PezInstanceProvider, self).__init__(client)
self.rpc_client = pez_api.AkandaPezAPI(rpc_topic='akanda-pez') self.rpc_client = pez_api.AstaraPezAPI(rpc_topic='astara-pez')
LOG.info(_LI( LOG.info(_LI(
'Initialized %s with rpc client %s'), 'Initialized %s with rpc client %s'),
self.__class__.__name__, self.rpc_client) self.__class__.__name__, self.rpc_client)

4
astara/api/rug.py
View File

@ -26,8 +26,8 @@ from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_log import loggers from oslo_log import loggers
from akanda.rug.cli import app from astara.cli import app
from akanda.rug.common.i18n import _, _LE, _LI, _LW from astara.common.i18n import _, _LE, _LI, _LW
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

6
astara/cli/app.py
View File

@ -22,7 +22,7 @@ from cliff import commandmanager
from oslo_config import cfg from oslo_config import cfg
import pkg_resources import pkg_resources
from akanda.rug.common import config from astara.common import config
class RugController(app.App): class RugController(app.App):
@ -32,9 +32,9 @@ class RugController(app.App):
def __init__(self): def __init__(self):
dist = pkg_resources.get_distribution('astara') dist = pkg_resources.get_distribution('astara')
super(RugController, self).__init__( super(RugController, self).__init__(
description='controller for the Akanda RUG service', description='controller for the Astara Orchestrator service',
version=dist.version, version=dist.version,
command_manager=commandmanager.CommandManager('akanda.rug.cli'), command_manager=commandmanager.CommandManager('astara.cli'),
) )
def initialize_app(self, argv): def initialize_app(self, argv):

12
astara/cli/browse.py
View File

@ -31,18 +31,18 @@ try:
except ImportError: except ImportError:
# blessed is not part of openstack global-requirements. # blessed is not part of openstack global-requirements.
raise Exception("The 'blessed' python module is required to browse" raise Exception("The 'blessed' python module is required to browse"
" Akanda routers. Please install and try again.") " Astara routers. Please install and try again.")
from oslo_config import cfg from oslo_config import cfg
from akanda.rug import commands from astara import commands
from akanda.rug.api import nova as nova_api from astara.api import nova as nova_api
from akanda.rug.api import neutron as neutron_api from astara.api import neutron as neutron_api
from akanda.rug.cli import message from astara.cli import message
logging.getLogger("urllib3").setLevel(logging.ERROR) logging.getLogger("urllib3").setLevel(logging.ERROR)
cfg.CONF.import_opt('host', 'akanda.rug.main') cfg.CONF.import_opt('host', 'astara.main')
class FakeConfig(object): class FakeConfig(object):

4
astara/cli/config.py
View File

@ -19,8 +19,8 @@
""" """
import logging import logging
from akanda.rug import commands from astara import commands
from akanda.rug.cli import message from astara.cli import message
class ConfigReload(message.MessageSending): class ConfigReload(message.MessageSending):

4
astara/cli/global_debug.py
View File

@ -19,8 +19,8 @@
""" """
import logging import logging
from akanda.rug import commands from astara import commands
from akanda.rug.cli import message from astara.cli import message
class GlobalDebug(message.MessageSending): class GlobalDebug(message.MessageSending):

2
astara/cli/main.py
View File

@ -17,7 +17,7 @@
import sys import sys
from akanda.rug.cli import app from astara.cli import app
def main(args=sys.argv[1:]): def main(args=sys.argv[1:]):

4
astara/cli/message.py
View File

@ -22,7 +22,7 @@ import logging
from cliff import command from cliff import command
from akanda.rug import notifications from astara import notifications
class MessageSending(command.Command): class MessageSending(command.Command):
@ -49,4 +49,4 @@ class MessageSending(command.Command):
def send_message(self, payload): def send_message(self, payload):
sender = notifications.Sender() sender = notifications.Sender()
self.log.debug('sending %r', payload) self.log.debug('sending %r', payload)
sender.send(event_type='akanda.rug.command', message=payload) sender.send(event_type='astara.command', message=payload)

4
astara/cli/poll.py
View File

@ -19,8 +19,8 @@
""" """
import logging import logging
from akanda.rug import commands from astara import commands
from akanda.rug.cli import message from astara.cli import message
class Poll(message.MessageSending): class Poll(message.MessageSending):

6
astara/cli/resource.py
View File

@ -17,9 +17,9 @@
"""Commands related to routers. """Commands related to routers.
""" """
from akanda.rug.api import nova from astara.api import nova
from akanda.rug.cli import message from astara.cli import message
from akanda.rug import commands from astara import commands
from novaclient import exceptions from novaclient import exceptions
from oslo_config import cfg from oslo_config import cfg

8
astara/cli/router.py
View File

@ -21,10 +21,10 @@ import argparse
import subprocess import subprocess
import sys import sys
from akanda.rug.common.i18n import _LW from astara.common.i18n import _LW
from akanda.rug import commands from astara import commands
from akanda.rug.cli import message from astara.cli import message
from akanda.rug.api import keystone, nova, neutron from astara.api import keystone, nova, neutron
from novaclient import exceptions from novaclient import exceptions
from oslo_config import cfg from oslo_config import cfg

4
astara/cli/tenant.py
View File

@ -19,8 +19,8 @@
""" """
import logging import logging
from akanda.rug import commands from astara import commands
from akanda.rug.cli import message from astara.cli import message
class _TenantCmd(message.MessageSending): class _TenantCmd(message.MessageSending):

4
astara/cli/worker.py
View File

@ -19,8 +19,8 @@
""" """
import logging import logging
from akanda.rug import commands from astara import commands
from akanda.rug.cli import message from astara.cli import message
class WorkerDebug(message.MessageSending): class WorkerDebug(message.MessageSending):

2
astara/common/config.py
View File

@ -78,7 +78,7 @@ def parse_config(argv, default_config_files=DEFAULT_CONFIG_FILES):
'stevedore=INFO', 'stevedore=INFO',
'eventlet.wsgi.server=WARN', 'eventlet.wsgi.server=WARN',
'requests=WARN', 'requests=WARN',
'akanda.rug.openstack.common.rpc.amqp=INFO', 'astara.openstack.common.rpc.amqp=INFO',
'neutronclient.client=INFO', 'neutronclient.client=INFO',
'oslo.messaging=INFO', 'oslo.messaging=INFO',
'iso8601=INFO', 'iso8601=INFO',

4
astara/common/hash_ring.py
View File

@ -22,7 +22,7 @@ import threading
from oslo_config import cfg from oslo_config import cfg
import six import six
from akanda.rug.common.i18n import _ from astara.common.i18n import _
hash_opts = [ hash_opts = [
cfg.IntOpt('hash_partition_exponent', cfg.IntOpt('hash_partition_exponent',
@ -47,7 +47,7 @@ CONF.register_opts(hash_opts)
# A static key that can be used to choose a single host when from the # A static key that can be used to choose a single host when from the
# ring we have no other data to hash with. # ring we have no other data to hash with.
DC_KEY = 'akanda_designated_coordinator' DC_KEY = 'astara_designated_coordinator'
class Invalid(Exception): class Invalid(Exception):

2
astara/common/i18n.py
View File

@ -16,7 +16,7 @@
import oslo_i18n import oslo_i18n
_translators = oslo_i18n.TranslatorFactory(domain='akanda-rug') _translators = oslo_i18n.TranslatorFactory(domain='astara')
_ = _translators.primary _ = _translators.primary
_LI = _translators.log_info _LI = _translators.log_info

8
astara/common/linux/interface.py
View File

@ -39,10 +39,10 @@ import netaddr
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.common.i18n import _, _LE, _LW from astara.common.i18n import _, _LE, _LW
from akanda.rug.common.linux import ip_lib from astara.common.linux import ip_lib
from akanda.rug.common.linux import ovs_lib from astara.common.linux import ovs_lib
from akanda.rug.common.linux import utils from astara.common.linux import utils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

4
astara/common/linux/ip_lib.py
View File

@ -33,8 +33,8 @@
import netaddr import netaddr
from akanda.rug.common.linux import utils from astara.common.linux import utils
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from oslo_log import log from oslo_log import log

4
astara/common/linux/ovs_lib.py
View File

@ -37,8 +37,8 @@
import re import re
from akanda.rug.common.linux import utils from astara.common.linux import utils
from akanda.rug.common.i18n import _, _LE, _LW from astara.common.i18n import _, _LE, _LW
from oslo_log import log as logging from oslo_log import log as logging

2
astara/common/linux/utils.py
View File

@ -44,7 +44,7 @@ import tempfile
from eventlet.green import subprocess from eventlet.green import subprocess
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from oslo_log import log as logging from oslo_log import log as logging

6
astara/common/rpc.py
View File

@ -21,7 +21,7 @@ from oslo_log import log as logging
from oslo_config import cfg from oslo_config import cfg
import oslo_messaging import oslo_messaging
from akanda.rug.common.i18n import _LW from astara.common.i18n import _LW
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -119,7 +119,7 @@ class Connection(object):
def create_notification_listener(self, endpoints, exchange=None, def create_notification_listener(self, endpoints, exchange=None,
topic='notifications'): topic='notifications'):
"""Creates an oslo.messaging notificatino listener associated with """Creates an oslo.messaging notification listener associated with
provided endpoints. Adds the resulting listener to the pool of RPC provided endpoints. Adds the resulting listener to the pool of RPC
server threads. server threads.
@ -132,7 +132,7 @@ class Connection(object):
transport = get_transport() transport = get_transport()
target = get_target(topic=topic, fanout=False, target = get_target(topic=topic, fanout=False,
exchange=exchange) exchange=exchange)
pool = 'akanda.' + topic + '.' + cfg.CONF.host pool = 'astara.' + topic + '.' + cfg.CONF.host
server = oslo_messaging.get_notification_listener( server = oslo_messaging.get_notification_listener(
transport, [target], endpoints, pool=pool) transport, [target], endpoints, pool=pool)
LOG.debug( LOG.debug(

4
astara/coordination.py
View File

@ -23,8 +23,8 @@ from oslo_log import log
import tooz import tooz
from tooz import coordination as tz_coordination from tooz import coordination as tz_coordination
from akanda.rug import event as ak_event from astara import event as ak_event
from akanda.rug.common.i18n import _, _LI from astara.common.i18n import _, _LI
LOG = log.getLogger(__name__) LOG = log.getLogger(__name__)

2
astara/daemon.py
View File

@ -22,7 +22,7 @@ import signal
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.common.i18n import _LI from astara.common.i18n import _LI
def ignore_signals(): def ignore_signals():

2
astara/db/api.py
View File

@ -22,7 +22,7 @@ from oslo_db import api as db_api
_BACKEND_MAPPING = { _BACKEND_MAPPING = {
'sqlalchemy': 'akanda.rug.db.sqlalchemy.api' 'sqlalchemy': 'astara.db.sqlalchemy.api'
} }
IMPL = db_api.DBAPI.from_config( IMPL = db_api.DBAPI.from_config(

2
astara/db/migration.py
View File

@ -26,7 +26,7 @@ def get_backend():
global _IMPL global _IMPL
if not _IMPL: if not _IMPL:
cfg.CONF.import_opt('backend', 'oslo_db.options', group='database') cfg.CONF.import_opt('backend', 'oslo_db.options', group='database')
_IMPL = driver.DriverManager("akanda.database.migration_backend", _IMPL = driver.DriverManager("astara.database.migration_backend",
cfg.CONF.database.backend).driver cfg.CONF.database.backend).driver
return _IMPL return _IMPL

4
astara/db/sqlalchemy/alembic/env.py
View File

@ -21,8 +21,8 @@ try:
except ImportError: except ImportError:
pass pass
from akanda.rug.db.sqlalchemy import api as sqla_api from astara.db.sqlalchemy import api as sqla_api
from akanda.rug.db.sqlalchemy import models from astara.db.sqlalchemy import models
# this is the Alembic Config object, which provides # this is the Alembic Config object, which provides
# access to the values within the .ini file in use. # access to the values within the .ini file in use.

4
astara/db/sqlalchemy/api.py
View File

@ -22,8 +22,8 @@ from oslo_db import exception as db_exc
from oslo_db.sqlalchemy import session as db_session from oslo_db.sqlalchemy import session as db_session
from oslo_log import log from oslo_log import log
from akanda.rug.db import api from astara.db import api
from akanda.rug.db.sqlalchemy import models from astara.db.sqlalchemy import models
CONF = cfg.CONF CONF = cfg.CONF
LOG = log.getLogger(__name__) LOG = log.getLogger(__name__)

13
astara/db/sqlalchemy/dbsync.py
View File

@ -21,7 +21,7 @@ from alembic import config as alembic_config
from alembic import util as alembic_util from alembic import util as alembic_util
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.common.i18n import _ from astara.common.i18n import _
_db_opts = [ _db_opts = [
@ -90,14 +90,7 @@ CONF.register_cli_opt(command_opt)
def get_alembic_config(): def get_alembic_config():
# TODO(markmcclain): remove next 5 lines once the transition is complete config = alembic_config.Config(os.path.join(os.path.dirname(__file__),
try:
from astara.db import sqlalchemy as preferred_sql
except ImportError:
from akanda.rug.db import sqlalchemy as preferred_sql
filename = preferred_sql.__file__
config = alembic_config.Config(os.path.join(os.path.dirname(filename),
'alembic.ini')) 'alembic.ini'))
return config return config
@ -105,5 +98,5 @@ def get_alembic_config():
def main(): def main():
CONF(project='astara-orchestrator') CONF(project='astara-orchestrator')
config = get_alembic_config() config = get_alembic_config()
config.akanda_config = CONF config.astara_config = CONF
CONF.command.func(config, CONF.command.name) CONF.command.func(config, CONF.command.name)

12
astara/db/sqlalchemy/migration.py
View File

@ -21,18 +21,12 @@ from alembic import config as alembic_config
import alembic.migration as alembic_migration import alembic.migration as alembic_migration
from oslo_db import exception as db_exc from oslo_db import exception as db_exc
from akanda.rug.db.sqlalchemy import api as sqla_api from astara.db.sqlalchemy import api as sqla_api
from akanda.rug.db.sqlalchemy import models from astara.db.sqlalchemy import models
def _alembic_config(): def _alembic_config():
# TODO(markmcclain): remove next 5 lines once the transition is complete path = os.path.join(os.path.dirname(__file__), 'alembic.ini')
try:
from astara.db import sqlalchemy as preferred_sql
except ImportError:
from akanda.rug.db import sqlalchemy as preferred_sql
path = os.path.join(os.path.dirname(preferred_sql.__file__), 'alembic.ini')
config = alembic_config.Config(path) config = alembic_config.Config(path)
return config return config

12
astara/db/sqlalchemy/models.py
View File

@ -19,7 +19,7 @@
SQLAlchemy models for baremetal data. SQLAlchemy models for baremetal data.
""" """
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from oslo_config import cfg from oslo_config import cfg
from oslo_db import options as db_options from oslo_db import options as db_options
@ -37,7 +37,7 @@ sql_opts = [
help=_('MySQL engine to use.')) help=_('MySQL engine to use.'))
] ]
_DEFAULT_SQL_CONNECTION = 'sqlite:///akanda-rug.db' _DEFAULT_SQL_CONNECTION = 'sqlite:///astara.db'
cfg.CONF.register_opts(sql_opts, 'database') cfg.CONF.register_opts(sql_opts, 'database')
@ -52,7 +52,7 @@ def table_args():
return None return None
class AkandaBase(models.TimestampMixin, class AstaraBase(models.TimestampMixin,
models.ModelBase): models.ModelBase):
metadata = None metadata = None
@ -64,14 +64,14 @@ class AkandaBase(models.TimestampMixin,
return d return d
def save(self, session=None): def save(self, session=None):
import akanda.rug.db.sqlalchemy.api as db_api import astara.db.sqlalchemy.api as db_api
if session is None: if session is None:
session = db_api.get_session() session = db_api.get_session()
super(AkandaBase, self).save(session) super(AstaraBase, self).save(session)
Base = declarative_base(cls=AkandaBase) Base = declarative_base(cls=AstaraBase)
class ResourceDebug(Base): class ResourceDebug(Base):

8
astara/debug.py
View File

@ -21,10 +21,10 @@ import sys
from oslo_config import cfg from oslo_config import cfg
from akanda.rug import state from astara import state
from akanda.rug import worker from astara import worker
from akanda.rug.common import config from astara.common import config
DEBUG_OPTS = [ DEBUG_OPTS = [
@ -51,7 +51,7 @@ def debug_one_router(args=sys.argv[1:]):
# Add our extra option for specifying the router-id to debug # Add our extra option for specifying the router-id to debug
cfg.CONF.register_cli_opts(DEBUG_OPTS) cfg.CONF.register_cli_opts(DEBUG_OPTS)
cfg.CONF.set_override('boot_timeout', 60000) cfg.CONF.set_override('boot_timeout', 60000)
cfg.CONF.import_opt('host', 'akanda.rug.main') cfg.CONF.import_opt('host', 'astara.main')
config.parse_config(args) config.parse_config(args)
logging.basicConfig( logging.basicConfig(

4
astara/drivers/__init__.py
View File

@ -15,8 +15,8 @@
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.drivers.router import Router from astara.drivers.router import Router
from akanda.rug.drivers.loadbalancer import LoadBalancer from astara.drivers.loadbalancer import LoadBalancer
DRIVER_OPTS = [ DRIVER_OPTS = [
cfg.ListOpt('enabled_drivers', cfg.ListOpt('enabled_drivers',

4
astara/drivers/base.py
View File

@ -1,4 +1,4 @@
# Copyright (c) 2015 AKANDA, INC. All Rights Reserved. # Copyright (c) 2015 Akanda, Inc. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # 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 # not use this file except in compliance with the License. You may obtain
@ -166,7 +166,7 @@ class BaseDriver(object):
def ports(self): def ports(self):
"""Lists ports associated with the resource. """Lists ports associated with the resource.
:returns: A list of akanda.rug.api.neutron.Port objects or [] :returns: A list of astara.api.neutron.Port objects or []
""" """
def get_interfaces(self, management_address): def get_interfaces(self, management_address):

28
astara/drivers/loadbalancer.py
View File

@ -1,4 +1,4 @@
# Copyright (c) 2015 AKANDA, INC. All Rights Reserved. # Copyright (c) 2015 Akanda, Inc. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # 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 # not use this file except in compliance with the License. You may obtain
@ -18,14 +18,14 @@ from oslo_log import log as logging
from neutronclient.common import exceptions as q_exceptions from neutronclient.common import exceptions as q_exceptions
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from akanda.rug.api import akanda_client from astara.api import astara_client
from akanda.rug.api.config import loadbalancer as config from astara.api.config import loadbalancer as config
from akanda.rug import event from astara import event
from akanda.rug.api import neutron from astara.api import neutron
from akanda.rug.drivers.base import BaseDriver from astara.drivers.base import BaseDriver
from akanda.rug.drivers import states from astara.drivers import states
from akanda.rug.common.i18n import _LW from astara.common.i18n import _LW
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -83,7 +83,7 @@ class LoadBalancer(BaseDriver):
def ports(self): def ports(self):
"""Lists ports associated with the resource. """Lists ports associated with the resource.
:returns: A list of akanda.rug.api.neutron.Port objects or [] :returns: A list of astara.api.neutron.Port objects or []
""" """
if self._loadbalancer: if self._loadbalancer:
return [p for p in self._loadbalancer.ports] return [p for p in self._loadbalancer.ports]
@ -130,7 +130,7 @@ class LoadBalancer(BaseDriver):
appliance appliance
""" """
self.log.info(_('Updating config for %s'), self.name) self.log.info(_('Updating config for %s'), self.name)
akanda_client.update_config(management_address, self.mgt_port, config) astara_client.update_config(management_address, self.mgt_port, config)
def pre_plug(self, worker_context): def pre_plug(self, worker_context):
"""pre-plug hook """pre-plug hook
@ -306,7 +306,7 @@ class LoadBalancer(BaseDriver):
return states.GONE return states.GONE
else: else:
# NOTE(adam_g): We probably want to map this status back to # NOTE(adam_g): We probably want to map this status back to
# an internal akanda status # an internal astara status
return self._loadbalancer.status return self._loadbalancer.status
def synchronize_state(self, worker_context, state): def synchronize_state(self, worker_context, state):
@ -332,7 +332,7 @@ class LoadBalancer(BaseDriver):
:returns: A list of interfaces :returns: A list of interfaces
""" """
return akanda_client.get_interfaces(management_address, return astara_client.get_interfaces(management_address,
self.mgt_port) self.mgt_port)
def is_alive(self, management_address): def is_alive(self, management_address):
@ -340,4 +340,4 @@ class LoadBalancer(BaseDriver):
:returns: bool True if alive, False if not :returns: bool True if alive, False if not
""" """
return akanda_client.is_alive(management_address, self.mgt_port) return astara_client.is_alive(management_address, self.mgt_port)

28
astara/drivers/router.py
View File

@ -1,4 +1,4 @@
# Copyright (c) 2015 AKANDA, INC. All Rights Reserved. # Copyright (c) 2015 Akanda, Inc. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # 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 # not use this file except in compliance with the License. You may obtain
@ -19,14 +19,14 @@ from oslo_utils import timeutils
from neutronclient.common import exceptions as q_exceptions from neutronclient.common import exceptions as q_exceptions
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from akanda.rug.api import akanda_client from astara.api import astara_client
from akanda.rug.api.config import router as configuration from astara.api.config import router as configuration
from akanda.rug import event from astara import event
from akanda.rug.api import neutron from astara.api import neutron
from akanda.rug.drivers.base import BaseDriver from astara.drivers.base import BaseDriver
from akanda.rug.drivers import states from astara.drivers import states
from akanda.rug.common.i18n import _LW from astara.common.i18n import _LW
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -109,7 +109,7 @@ class Router(BaseDriver):
def ports(self): def ports(self):
"""Lists ports associated with the resource. """Lists ports associated with the resource.
:returns: A list of akanda.rug.api.neutron.Port objects or [] :returns: A list of astara.api.neutron.Port objects or []
""" """
if self._router: if self._router:
return [p for p in self._router.ports] return [p for p in self._router.ports]
@ -158,7 +158,7 @@ class Router(BaseDriver):
self.log.info(_('Updating config for %s'), self.name) self.log.info(_('Updating config for %s'), self.name)
start_time = timeutils.utcnow() start_time = timeutils.utcnow()
akanda_client.update_config( astara_client.update_config(
management_address, self.mgt_port, config) management_address, self.mgt_port, config)
delta = timeutils.delta_seconds(start_time, timeutils.utcnow()) delta = timeutils.delta_seconds(start_time, timeutils.utcnow())
self.log.info(_('Config updated for %s after %s seconds'), self.log.info(_('Config updated for %s after %s seconds'),
@ -321,7 +321,7 @@ class Router(BaseDriver):
return states.GONE return states.GONE
else: else:
# NOTE(adam_g): We probably want to map this status back to # NOTE(adam_g): We probably want to map this status back to
# an internal akanda status # an internal astara status
return self._router.status return self._router.status
def synchronize_state(self, worker_context, state): def synchronize_state(self, worker_context, state):
@ -346,7 +346,7 @@ class Router(BaseDriver):
:returns: A list of interfaces :returns: A list of interfaces
""" """
return akanda_client.get_interfaces(management_address, return astara_client.get_interfaces(management_address,
self.mgt_port) self.mgt_port)
def is_alive(self, management_address): def is_alive(self, management_address):
@ -354,4 +354,4 @@ class Router(BaseDriver):
:returns: bool True if alive, False if not :returns: bool True if alive, False if not
""" """
return akanda_client.is_alive(management_address, self.mgt_port) return astara_client.is_alive(management_address, self.mgt_port)

2
astara/drivers/states.py
View File

@ -1,4 +1,4 @@
# Copyright (c) 2015 AKANDA, INC. All Rights Reserved. # Copyright (c) 2015 Akanda, Inc. All Rights Reserved.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); you may # 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 # not use this file except in compliance with the License. You may obtain

2
astara/health.py
View File

@ -23,7 +23,7 @@ import time
from oslo_config import cfg from oslo_config import cfg
from akanda.rug import event from astara import event
from oslo_log import log as logging from oslo_log import log as logging

4
astara/instance_manager.py
View File

@ -19,8 +19,8 @@ import time
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.drivers import states from astara.drivers import states
from akanda.rug.common.i18n import _LE, _LI from astara.common.i18n import _LE, _LI
CONF = cfg.CONF CONF = cfg.CONF
INSTANCE_MANAGER_OPTS = [ INSTANCE_MANAGER_OPTS = [

26
astara/main.py
View File

@ -26,17 +26,17 @@ import threading
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log from oslo_log import log
from akanda.rug.common.i18n import _LE, _LI from astara.common.i18n import _LE, _LI
from akanda.rug.common import config as ak_cfg from astara.common import config as ak_cfg
from akanda.rug import coordination from astara import coordination
from akanda.rug import daemon from astara import daemon
from akanda.rug import health from astara import health
from akanda.rug import metadata from astara import metadata
from akanda.rug import notifications from astara import notifications
from akanda.rug import scheduler from astara import scheduler
from akanda.rug import populate from astara import populate
from akanda.rug import worker from astara import worker
from akanda.rug.api import neutron as neutron_api from astara.api import neutron as neutron_api
LOG = log.getLogger(__name__) LOG = log.getLogger(__name__)
@ -45,7 +45,7 @@ CONF = cfg.CONF
MAIN_OPTS = [ MAIN_OPTS = [
cfg.StrOpt('host', cfg.StrOpt('host',
default=socket.getfqdn(), default=socket.getfqdn(),
help="The hostname Akanda is running on"), help="The hostname Astara is running on"),
cfg.BoolOpt('plug_external_port', default=False), cfg.BoolOpt('plug_external_port', default=False),
] ]
CONF.register_opts(MAIN_OPTS) CONF.register_opts(MAIN_OPTS)
@ -168,7 +168,7 @@ def main(argv=sys.argv[1:]):
) )
metadata_proc.start() metadata_proc.start()
from akanda.rug.api import rug as rug_api from astara.api import rug as rug_api
rug_api_proc = multiprocessing.Process( rug_api_proc = multiprocessing.Process(
target=rug_api.serve, target=rug_api.serve,
args=(mgt_ip_address,), args=(mgt_ip_address,),

2
astara/metadata.py
View File

@ -55,7 +55,7 @@ import webob.exc
from oslo_log import log as logging from oslo_log import log as logging
from oslo_log import loggers from oslo_log import loggers
from akanda.rug.common.i18n import _, _LE, _LI, _LW from astara.common.i18n import _, _LE, _LI, _LW
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

12
astara/notifications.py
View File

@ -21,16 +21,16 @@
import Queue import Queue
import threading import threading
from akanda.rug import commands from astara import commands
from akanda.rug import drivers from astara import drivers
from akanda.rug import event from astara import event
from akanda.rug.common import rpc from astara.common import rpc
from oslo_config import cfg from oslo_config import cfg
from oslo_context import context from oslo_context import context
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.common.i18n import _LE from astara.common.i18n import _LE
cfg.CONF.register_group(cfg.OptGroup(name='rabbit', cfg.CONF.register_group(cfg.OptGroup(name='rabbit',
@ -137,7 +137,7 @@ class NotificationsEndpoint(object):
crud = event.UPDATE crud = event.UPDATE
e = None e = None
events = [] events = []
if event_type.startswith('akanda.rug.command'): if event_type.startswith('astara.command'):
LOG.debug('received a command: %r', payload) LOG.debug('received a command: %r', payload)
crud = event.COMMAND crud = event.COMMAND
if payload.get('command') == commands.POLL: if payload.get('command') == commands.POLL:

2
astara/openstack/common/excutils.py
View File

@ -41,7 +41,7 @@ import logging
import sys import sys
import traceback import traceback
from akanda.rug.common.i18n import _LE from astara.common.i18n import _LE
@contextlib.contextmanager @contextlib.contextmanager

2
astara/openstack/common/gettextutils.py
View File

@ -37,7 +37,7 @@ gettext for openstack-common modules.
Usual usage in an openstack.common module: Usual usage in an openstack.common module:
from akanda.rug.openstack.common.gettextutils import _ from astara.openstack.common.gettextutils import _
""" """
import gettext import gettext

2
astara/openstack/common/jsonutils.py
View File

@ -57,7 +57,7 @@ import itertools
import json import json
import xmlrpclib import xmlrpclib
from akanda.rug.openstack.common import timeutils from astara.openstack.common import timeutils
def to_primitive(value, convert_instances=False, convert_datetime=True, def to_primitive(value, convert_instances=False, convert_datetime=True,

6
astara/openstack/common/loopingcall.py
View File

@ -39,9 +39,9 @@ import sys
from eventlet import event from eventlet import event
from eventlet import greenthread from eventlet import greenthread
from akanda.rug.common.i18n import _LE, _LW from astara.common.i18n import _LE, _LW
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
from akanda.rug.openstack.common import timeutils from astara.openstack.common import timeutils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

2
astara/openstack/common/manager.py
View File

@ -68,7 +68,7 @@ This module provides Manager, a base class for managers.
""" """
from akanda.rug.openstack.common import periodic_task from astara.openstack.common import periodic_task
class Manager(periodic_task.PeriodicTasks): class Manager(periodic_task.PeriodicTasks):

12
astara/openstack/common/notifier/api.py
View File

@ -34,12 +34,12 @@ import uuid
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.common.i18n import _, _LE from astara.common.i18n import _, _LE
from akanda.rug.openstack.common import context from astara.openstack.common import context
from akanda.rug.openstack.common import importutils from astara.openstack.common import importutils
from akanda.rug.openstack.common import jsonutils from astara.openstack.common import jsonutils
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
from akanda.rug.openstack.common import timeutils from astara.openstack.common import timeutils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

6
astara/openstack/common/notifier/log_notifier.py
View File

@ -32,8 +32,8 @@
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.openstack.common import jsonutils from astara.openstack.common import jsonutils
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
CONF = cfg.CONF CONF = cfg.CONF
@ -47,6 +47,6 @@ def notify(_context, message):
CONF.default_notification_level) CONF.default_notification_level)
priority = priority.lower() priority = priority.lower()
logger = logging.getLogger( logger = logging.getLogger(
'akanda.rug.openstack.common.notification.%s' % 'astara.openstack.common.notification.%s' %
message['event_type']) message['event_type'])
getattr(logger, priority)(jsonutils.dumps(message)) getattr(logger, priority)(jsonutils.dumps(message))

6
astara/openstack/common/notifier/rabbit_notifier.py
View File

@ -31,9 +31,9 @@
# under the License. # under the License.
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
from akanda.rug.openstack.common.notifier import rpc_notifier from astara.openstack.common.notifier import rpc_notifier
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

4
astara/openstack/common/periodic_task.py
View File

@ -30,8 +30,8 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from akanda.rug.common.i18n import _LE from astara.common.i18n import _LE
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

12
astara/openstack/common/service.py
View File

@ -47,14 +47,14 @@ import eventlet
import logging as std_logging import logging as std_logging
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.common.i18n import _LE, _LI, _LW from astara.common.i18n import _LE, _LI, _LW
from akanda.rug.openstack.common import eventlet_backdoor from astara.openstack.common import eventlet_backdoor
from akanda.rug.openstack.common import importutils from astara.openstack.common import importutils
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
from akanda.rug.openstack.common import threadgroup from astara.openstack.common import threadgroup
rpc = importutils.try_import('akanda.rug.openstack.common.rpc') rpc = importutils.try_import('astara.openstack.common.rpc')
CONF = cfg.CONF CONF = cfg.CONF
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

2
astara/openstack/common/setup.py
View File

@ -45,7 +45,7 @@ import sys
from setuptools.command import sdist from setuptools.command import sdist
from akanda.rug.common.i18n import _ from astara.common.i18n import _
def parse_mailmap(mailmap='.mailmap'): def parse_mailmap(mailmap='.mailmap'):

4
astara/openstack/common/threadgroup.py
View File

@ -35,8 +35,8 @@ from eventlet import greenlet
from eventlet import greenpool from eventlet import greenpool
from eventlet import greenthread from eventlet import greenthread
from akanda.rug.openstack.common import log as logging from astara.openstack.common import log as logging
from akanda.rug.openstack.common import loopingcall from astara.openstack.common import loopingcall
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

10
astara/pez/manager.py
View File

@ -19,8 +19,8 @@ import threading
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.common.i18n import _ from astara.common.i18n import _
from akanda.rug.pez import pool from astara.pez import pool
CONF = cfg.CONF CONF = cfg.CONF
@ -35,7 +35,7 @@ PEZ_OPTIONS = [
help=_('Image uuid to boot.')), help=_('Image uuid to boot.')),
cfg.StrOpt('flavor', cfg.StrOpt('flavor',
help=_('Nova flavor to boot')), help=_('Nova flavor to boot')),
cfg.StrOpt('rpc_topic', default='akanda-pez'), cfg.StrOpt('rpc_topic', default='astara-pez'),
] ]
@ -43,8 +43,8 @@ CONF.register_group(cfg.OptGroup(name='pez'))
CONF.register_opts(PEZ_OPTIONS, group='pez') CONF.register_opts(PEZ_OPTIONS, group='pez')
CONF.import_opt('host', 'akanda.rug.main') CONF.import_opt('host', 'astara.main')
CONF.import_opt('management_network_id', 'akanda.rug.api.neutron') CONF.import_opt('management_network_id', 'astara.api.neutron')
class PezManager(object): class PezManager(object):

18
astara/pez/pool.py
View File

@ -22,15 +22,15 @@ from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from oslo_utils import timeutils from oslo_utils import timeutils
from akanda.rug.common.i18n import _LE, _LI from astara.common.i18n import _LE, _LI
from akanda.rug import drivers from astara import drivers
from akanda.rug.api import neutron from astara.api import neutron
from akanda.rug.api import nova from astara.api import nova
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
# Unused instances are launched with a known name # Unused instances are launched with a known name
INSTANCE_FREE = 'AKANDA:UNUSED:%(resource_name)s' INSTANCE_FREE = 'ASTARA:UNUSED:%(resource_name)s'
# When an instance is reserved, its renamed accordingly # When an instance is reserved, its renamed accordingly
# TODO(adam_g): We ideally want to make all instance naming template-able # TODO(adam_g): We ideally want to make all instance naming template-able
@ -42,7 +42,7 @@ ACTIVE = 'active'
ERROR = 'error' ERROR = 'error'
DELETING = 'deleting' DELETING = 'deleting'
PEZ_LOCK = 'akanda-pez' PEZ_LOCK = 'astara-pez'
class PezPoolExhausted(Exception): class PezPoolExhausted(Exception):
@ -59,7 +59,7 @@ class WorkerContext(object):
class PezPoolManager(object): class PezPoolManager(object):
"""Akanda Pez Pool Manager """Astara Pez Pool Manager
This manages a pool of instances of a configurable size. All instance This manages a pool of instances of a configurable size. All instance
state is managed and tracked in Nova itself. state is managed and tracked in Nova itself.
@ -224,8 +224,8 @@ class PezPoolManager(object):
LOG.info(_LI( LOG.info(_LI(
'Launching %s %s instances.'), driver.RESOURCE_NAME, count) 'Launching %s %s instances.'), driver.RESOURCE_NAME, count)
for i in range(0, count): for i in range(0, count):
# NOTE: Use a fake UUID so akanda-neutron's name matching still # NOTE: Use a fake UUID so astara-neutron's name matching still
# catches this port as an akanda port. This can be avoided if # catches this port as an astara port. This can be avoided if
# we use a mgt security group in the future. # we use a mgt security group in the future.
mgt_port = self.ctxt.neutron_client.create_management_port( mgt_port = self.ctxt.neutron_client.create_management_port(
'00000000-0000-0000-0000-000000000000') '00000000-0000-0000-0000-000000000000')

8
astara/pez/rpcapi.py
View File

@ -14,13 +14,13 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from akanda.rug.common import rpc from astara.common import rpc
from oslo_context import context from oslo_context import context
class AkandaPezAPI(object): class AstaraPezAPI(object):
""""Client side of the Akanda Pez RPC API. """"Client side of the Astara Pez RPC API.
""" """
def __init__(self, rpc_topic): def __init__(self, rpc_topic):
self.topic = rpc_topic self.topic = rpc_topic
@ -34,7 +34,7 @@ class AkandaPezAPI(object):
attach any required instance ports during the reservation process. attach any required instance ports during the reservation process.
The dict returned here should be enough for the caller to construct The dict returned here should be enough for the caller to construct
a InstanceInfo object. Note that the port information are serialized a InstanceInfo object. Note that the port information are serialized
akanda.rug.api.neutron.Port objects that can be deserialized by the astara.api.neutron.Port objects that can be deserialized by the
caller during creation of InstanceInfo. caller during creation of InstanceInfo.
:param resource_type: The str name of the driver that manages the :param resource_type: The str name of the driver that manages the

12
astara/pez/service.py
View File

@ -17,11 +17,11 @@
import logging import logging
import sys import sys
from akanda.rug.common.i18n import _LI from astara.common.i18n import _LI
from akanda.rug.common import config as ak_cfg from astara.common import config as ak_cfg
from akanda.rug.common import rpc from astara.common import rpc
from akanda.rug.pez import manager from astara.pez import manager
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log from oslo_log import log
@ -55,10 +55,10 @@ class PezService(service.Service):
def main(argv=sys.argv[1:]): def main(argv=sys.argv[1:]):
ak_cfg.parse_config(argv) ak_cfg.parse_config(argv)
log.setup(CONF, 'akanda-pez') log.setup(CONF, 'astara-pez')
CONF.log_opt_values(LOG, logging.INFO) CONF.log_opt_values(LOG, logging.INFO)
LOG.info(_LI("Starting Akanda Pez service.")) LOG.info(_LI("Starting Astara Pez service."))
mgr = PezService() mgr = PezService()
launcher = service.launch(CONF, mgr) launcher = service.launch(CONF, mgr)

4
astara/populate.py
View File

@ -22,8 +22,8 @@ import threading
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug import event from astara import event
from akanda.rug import drivers from astara import drivers
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

6
astara/scheduler.py
View File

@ -24,9 +24,9 @@ import uuid
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug import commands from astara import commands
from akanda.rug.common.i18n import _, _LE, _LI, _LW from astara.common.i18n import _, _LE, _LI, _LW
from akanda.rug import daemon from astara import daemon
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)

10
astara/service.py
View File

@ -23,9 +23,9 @@ import eventlet
from oslo_config import cfg from oslo_config import cfg
from oslo_log import log from oslo_log import log
from akanda.rug import manager from astara import manager
from akanda.rug.openstack.common.rpc import service as rpc_service from astara.openstack.common.rpc import service as rpc_service
from akanda.rug.openstack.common import service from astara.openstack.common import service
L3_AGENT_TOPIC = 'l3_agent' L3_AGENT_TOPIC = 'l3_agent'
@ -53,9 +53,9 @@ class PeriodicService(rpc_service.Service):
def main(): def main():
eventlet.monkey_patch() eventlet.monkey_patch()
cfg.CONF(sys.argv[1:], project='astara-orchestrator') cfg.CONF(sys.argv[1:], project='astara-orchestrator')
log.setup('akanda') log.setup('astara')
mgr = manager.AkandaL3Manager() mgr = manager.AstaraL3Manager()
svc = PeriodicService( svc = PeriodicService(
host=cfg.CONF.host, topic=L3_AGENT_TOPIC, manager=mgr host=cfg.CONF.host, topic=L3_AGENT_TOPIC, manager=mgr
) )

8
astara/state.py
View File

@ -25,10 +25,10 @@
import collections import collections
import itertools import itertools
from akanda.rug.common.i18n import _LE, _LI, _LW from astara.common.i18n import _LE, _LI, _LW
from akanda.rug.event import POLL, CREATE, READ, UPDATE, DELETE, REBUILD from astara.event import POLL, CREATE, READ, UPDATE, DELETE, REBUILD
from akanda.rug import instance_manager from astara import instance_manager
from akanda.rug.drivers import states from astara.drivers import states
class StateParams(object): class StateParams(object):

10
astara/tenant.py
View File

@ -23,10 +23,10 @@ import threading
from oslo_log import log as logging from oslo_log import log as logging
from akanda.rug.common.i18n import _LE from astara.common.i18n import _LE
from akanda.rug import state from astara import state
from akanda.rug import drivers from astara import drivers
from akanda.rug.openstack.common import timeutils from astara.openstack.common import timeutils
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
@ -119,7 +119,7 @@ class TenantResourceManager(object):
msg = { msg = {
'tenant_id': self.tenant_id, 'tenant_id': self.tenant_id,
'timestamp': timeutils.isotime(), 'timestamp': timeutils.isotime(),
'event_type': 'akanda.bandwidth.used', 'event_type': 'astara.bandwidth.used',
'payload': dict((b.pop('name'), b) for b in bandwidth), 'payload': dict((b.pop('name'), b) for b in bandwidth),
'uuid': resource_id, 'uuid': resource_id,
} }

16
astara/test/functional/base.py
View File

@ -5,7 +5,7 @@ import os
import testtools import testtools
import time import time
from akanda.rug.api import akanda_client from astara.api import astara_client
from novaclient.v1_1 import client as _novaclient from novaclient.v1_1 import client as _novaclient
from neutronclient.v2_0 import client as _neutronclient from neutronclient.v2_0 import client as _neutronclient
@ -14,14 +14,14 @@ DEFAULT_CONFIG = os.path.join(os.path.dirname(__file__), 'test.conf')
DEFAULT_ACTIVE_TIMEOUT = 340 DEFAULT_ACTIVE_TIMEOUT = 340
class AkandaFunctionalBase(testtools.TestCase): class AstaraFunctionalBase(testtools.TestCase):
def setUp(self): def setUp(self):
super(AkandaFunctionalBase, self).setUp() super(AstaraFunctionalBase, self).setUp()
self.config = self._get_config() self.config = self._get_config()
self.ak_cfg = mock.patch.object(akanda_client.cfg, 'CONF').start() self.ak_cfg = mock.patch.object(astara_client.cfg, 'CONF').start()
self.ak_cfg.alive_timeout = 10 self.ak_cfg.alive_timeout = 10
self.ak_client = akanda_client self.ak_client = astara_client
self.novaclient = _novaclient.Client( self.novaclient = _novaclient.Client(
self.config['os_username'], self.config['os_username'],
@ -41,7 +41,7 @@ class AkandaFunctionalBase(testtools.TestCase):
self._management_address = None self._management_address = None
def _get_config(self): def _get_config(self):
config_file = os.environ.get('AKANDA_TEST_CONFIG', config_file = os.environ.get('ASTARA_TEST_CONFIG',
DEFAULT_CONFIG) DEFAULT_CONFIG)
config = ConfigParser.SafeConfigParser() config = ConfigParser.SafeConfigParser()
if not config.read(config_file): if not config.read(config_file):
@ -51,7 +51,7 @@ class AkandaFunctionalBase(testtools.TestCase):
req_conf_settings = ['os_auth_url', 'os_username', 'os_password', req_conf_settings = ['os_auth_url', 'os_username', 'os_password',
'os_tenant_name', 'service_tenant_name', 'os_tenant_name', 'service_tenant_name',
'service_tenant_id', 'appliance_api_port', 'service_tenant_id', 'appliance_api_port',
'akanda_test_router_uuid'] 'astara_test_router_uuid']
out = {} out = {}
for c in req_conf_settings: for c in req_conf_settings:
try: try:
@ -94,7 +94,7 @@ class AkandaFunctionalBase(testtools.TestCase):
def assert_router_is_active(self, router_uuid=None): def assert_router_is_active(self, router_uuid=None):
if not router_uuid: if not router_uuid:
router_uuid = self.config['akanda_test_router_uuid'] router_uuid = self.config['astara_test_router_uuid']
i = 0 i = 0
router = self.neutronclient.show_router(router_uuid)['router'] router = self.neutronclient.show_router(router_uuid)['router']
while router['status'] != 'ACTIVE': while router['status'] != 'ACTIVE':

4
astara/test/functional/test.conf.sample
View File

@ -10,8 +10,8 @@ service_tenant_id=80095e2039db4af0a88351d6360c1977
# The configured appliance API port # The configured appliance API port
appliance_api_port=5000 appliance_api_port=5000
# The UUID of a running akanda router that will be used for running # The UUID of a running astara router that will be used for running
# tests against. Devstack creates this for you but you may have one # tests against. Devstack creates this for you but you may have one
# that you wish to use instead. If not supplied here, tools/run_functional.sh # that you wish to use instead. If not supplied here, tools/run_functional.sh
# will attempt to find it for you. # will attempt to find it for you.
akanda_test_router_uuid=650da79d-30ee-460f-bf91-8b7e04a5a5f6 astara_test_router_uuid=650da79d-30ee-460f-bf91-8b7e04a5a5f6

6
astara/test/functional/test_service_instance.py
View File

@ -1,13 +1,13 @@
from akanda.rug.test.functional import base from astara.test.functional import base
class AkandaApplianceInstanceTest(base.AkandaFunctionalBase): class AstaraApplianceInstanceTest(base.AstaraFunctionalBase):
"""Basic tests to ensure a service instance and its associated router is """Basic tests to ensure a service instance and its associated router is
alive and well. alive and well.
""" """
def setUp(self): def setUp(self):
super(AkandaApplianceInstanceTest, self).setUp() super(AstaraApplianceInstanceTest, self).setUp()
# ensure the devstack spawned router instance becomes active before # ensure the devstack spawned router instance becomes active before
# starting to run any test cases. this in itself is a test that # starting to run any test cases. this in itself is a test that
# devstack produced a functional router. # devstack produced a functional router.

10
astara/test/unit/api/config/config_fakes.py
View File

@ -14,7 +14,7 @@
import netaddr import netaddr
from akanda.rug.api.neutron import Subnet from astara.api.neutron import Subnet
class FakeModel(object): class FakeModel(object):
@ -34,14 +34,14 @@ fake_ext_port = FakeModel(
fake_mgt_port = FakeModel( fake_mgt_port = FakeModel(
'2', '2',
name='AKANDA:MGT:foo', name='ASTARA:MGT:foo',
mac_address='aa:bb:cc:cc:bb:aa', mac_address='aa:bb:cc:cc:bb:aa',
network_id='mgt-net', network_id='mgt-net',
device_id='m-m-m-m') device_id='m-m-m-m')
fake_int_port = FakeModel( fake_int_port = FakeModel(
'3', '3',
name='AKANDA:RUG:foo', name='ASTARA:RUG:foo',
mac_address='aa:aa:aa:aa:aa:aa', mac_address='aa:aa:aa:aa:aa:aa',
network_id='int-net', network_id='int-net',
fixed_ips=[FakeModel('', ip_address='192.168.1.1', subnet_id='s1')], fixed_ips=[FakeModel('', ip_address='192.168.1.1', subnet_id='s1')],
@ -58,7 +58,7 @@ fake_instance_port = FakeModel(
fake_instance_mgt_port = FakeModel( fake_instance_mgt_port = FakeModel(
'4', '4',
name='AKANDA:MGT:foo', name='ASTARA:MGT:foo',
mac_address='aa:aa:aa:aa:aa:bb', mac_address='aa:aa:aa:aa:aa:bb',
network_id='int-net', network_id='int-net',
fixed_ips=[FakeModel('', ip_address='192.168.1.2', subnet_id='s1')], fixed_ips=[FakeModel('', ip_address='192.168.1.2', subnet_id='s1')],
@ -67,7 +67,7 @@ fake_instance_mgt_port = FakeModel(
fake_instance_vrrp_port = FakeModel( fake_instance_vrrp_port = FakeModel(
'4', '4',
name='AKANDA:VRRP:foo', name='ASTARA:VRRP:foo',
mac_address='aa:aa:aa:aa:aa:bb', mac_address='aa:aa:aa:aa:aa:bb',
network_id='int-net', network_id='int-net',
fixed_ips=[FakeModel('', ip_address='192.168.1.2', subnet_id='s1')], fixed_ips=[FakeModel('', ip_address='192.168.1.2', subnet_id='s1')],

4
astara/test/unit/api/config/test_common_config.py
View File

@ -20,9 +20,9 @@ import netaddr
from oslo_config import cfg from oslo_config import cfg
import unittest2 as unittest import unittest2 as unittest
from akanda.rug.api.config import common from astara.api.config import common
from akanda.rug.test.unit.api.config import config_fakes as fakes from astara.test.unit.api.config import config_fakes as fakes
class TestCommonConfig(unittest.TestCase): class TestCommonConfig(unittest.TestCase):

6
astara/test/unit/api/config/test_loadbalancer_config.py
View File

@ -17,12 +17,12 @@
import mock import mock
from akanda.rug.api.config import loadbalancer as lb_config from astara.api.config import loadbalancer as lb_config
from akanda.rug.test.unit import base, fakes from astara.test.unit import base, fakes
class TestLoadbalancerConfigAPI(base.RugTestBase): class TestLoadbalancerConfigAPI(base.RugTestBase):
@mock.patch('akanda.rug.api.config.common.network_config') @mock.patch('astara.api.config.common.network_config')
def test_build_config(self, fake_network_config): def test_build_config(self, fake_network_config):
fake_client = mock.Mock() fake_client = mock.Mock()
fake_lb = fakes.fake_loadbalancer() fake_lb = fakes.fake_loadbalancer()

10
astara/test/unit/api/config/test_router_config.py
View File

@ -21,12 +21,12 @@ from oslo_config import cfg
import unittest2 as unittest import unittest2 as unittest
from six.moves import builtins as __builtins__ from six.moves import builtins as __builtins__
from akanda.rug.api.config import router as conf_mod from astara.api.config import router as conf_mod
from akanda.rug.test.unit.api.config import config_fakes as fakes from astara.test.unit.api.config import config_fakes as fakes
class TestAkandaClient(unittest.TestCase): class TestAstaraClient(unittest.TestCase):
def setUp(self): def setUp(self):
cfg.CONF.set_override('provider_rules_path', '/the/path') cfg.CONF.set_override('provider_rules_path', '/the/path')
@ -110,7 +110,7 @@ class TestAkandaClient(unittest.TestCase):
res = conf_mod.load_provider_rules('/tmp/path') res = conf_mod.load_provider_rules('/tmp/path')
self.assertEqual(res, {}) self.assertEqual(res, {})
@mock.patch('akanda.rug.api.config.common.network_config') @mock.patch('astara.api.config.common.network_config')
def test_generate_network_config(self, mock_net_conf): def test_generate_network_config(self, mock_net_conf):
mock_client = mock.Mock() mock_client = mock.Mock()
@ -160,7 +160,7 @@ class TestAkandaClient(unittest.TestCase):
self.assertEqual(result, expected) self.assertEqual(result, expected)
class TestAkandaClientGateway(unittest.TestCase): class TestAstaraClientGateway(unittest.TestCase):
def setUp(self): def setUp(self):
cfg.CONF.set_override('provider_rules_path', '/the/path') cfg.CONF.set_override('provider_rules_path', '/the/path')

28
astara/test/unit/api/test_akanda_router.py → astara/test/unit/api/test_astara_router.py
View File

@ -18,13 +18,13 @@
import mock import mock
import unittest2 as unittest import unittest2 as unittest
from akanda.rug.api import akanda_client from astara.api import astara_client
class TestAkandaClient(unittest.TestCase): class TestAstaraClient(unittest.TestCase):
def setUp(self): def setUp(self):
self.mock_create_session = mock.patch.object( self.mock_create_session = mock.patch.object(
akanda_client, astara_client,
'_get_proxyless_session' '_get_proxyless_session'
).start() ).start()
self.mock_get = self.mock_create_session.return_value.get self.mock_get = self.mock_create_session.return_value.get
@ -35,14 +35,14 @@ class TestAkandaClient(unittest.TestCase):
def test_mgt_url(self): def test_mgt_url(self):
self.assertEqual('http://[fe80::2]:5000/', self.assertEqual('http://[fe80::2]:5000/',
akanda_client._mgt_url('fe80::2', 5000, '/')) astara_client._mgt_url('fe80::2', 5000, '/'))
self.assertEqual('http://192.168.1.1:5000/', self.assertEqual('http://192.168.1.1:5000/',
akanda_client._mgt_url('192.168.1.1', 5000, '/')) astara_client._mgt_url('192.168.1.1', 5000, '/'))
def test_is_alive_success(self): def test_is_alive_success(self):
self.mock_get.return_value.status_code = 200 self.mock_get.return_value.status_code = 200
self.assertTrue(akanda_client.is_alive('fe80::2', 5000)) self.assertTrue(astara_client.is_alive('fe80::2', 5000))
self.mock_get.assert_called_once_with( self.mock_get.assert_called_once_with(
'http://[fe80::2]:5000/v1/firewall/rules', 'http://[fe80::2]:5000/v1/firewall/rules',
timeout=3.0 timeout=3.0
@ -51,7 +51,7 @@ class TestAkandaClient(unittest.TestCase):
def test_is_alive_bad_status(self): def test_is_alive_bad_status(self):
self.mock_get.return_value.status_code = 500 self.mock_get.return_value.status_code = 500
self.assertFalse(akanda_client.is_alive('fe80::2', 5000)) self.assertFalse(astara_client.is_alive('fe80::2', 5000))
self.mock_get.assert_called_once_with( self.mock_get.assert_called_once_with(
'http://[fe80::2]:5000/v1/firewall/rules', 'http://[fe80::2]:5000/v1/firewall/rules',
timeout=3.0 timeout=3.0
@ -60,7 +60,7 @@ class TestAkandaClient(unittest.TestCase):
def test_is_alive_exception(self): def test_is_alive_exception(self):
self.mock_get.side_effect = Exception self.mock_get.side_effect = Exception
self.assertFalse(akanda_client.is_alive('fe80::2', 5000)) self.assertFalse(astara_client.is_alive('fe80::2', 5000))
self.mock_get.assert_called_once_with( self.mock_get.assert_called_once_with(
'http://[fe80::2]:5000/v1/firewall/rules', 'http://[fe80::2]:5000/v1/firewall/rules',
timeout=3.0 timeout=3.0
@ -72,7 +72,7 @@ class TestAkandaClient(unittest.TestCase):
'interfaces': 'the_interfaces' 'interfaces': 'the_interfaces'
} }
self.assertEqual(akanda_client.get_interfaces('fe80::2', 5000), self.assertEqual(astara_client.get_interfaces('fe80::2', 5000),
'the_interfaces') 'the_interfaces')
self.mock_get.assert_called_once_with( self.mock_get.assert_called_once_with(
'http://[fe80::2]:5000/v1/system/interfaces', 'http://[fe80::2]:5000/v1/system/interfaces',
@ -84,7 +84,7 @@ class TestAkandaClient(unittest.TestCase):
self.mock_put.return_value.status_code = 200 self.mock_put.return_value.status_code = 200
self.mock_put.return_value.json.return_value = config self.mock_put.return_value.json.return_value = config
resp = akanda_client.update_config('fe80::2', 5000, config) resp = astara_client.update_config('fe80::2', 5000, config)
self.mock_put.assert_called_once_with( self.mock_put.assert_called_once_with(
'http://[fe80::2]:5000/v1/system/config', 'http://[fe80::2]:5000/v1/system/config',
@ -98,9 +98,9 @@ class TestAkandaClient(unittest.TestCase):
self.mock_put.return_value.status_code = 200 self.mock_put.return_value.status_code = 200
self.mock_put.return_value.json.return_value = config self.mock_put.return_value.json.return_value = config
with mock.patch.object(akanda_client.cfg, 'CONF') as cfg: with mock.patch.object(astara_client.cfg, 'CONF') as cfg:
cfg.config_timeout = 5 cfg.config_timeout = 5
resp = akanda_client.update_config('fe80::2', 5000, config) resp = astara_client.update_config('fe80::2', 5000, config)
self.mock_put.assert_called_once_with( self.mock_put.assert_called_once_with(
'http://[fe80::2]:5000/v1/system/config', 'http://[fe80::2]:5000/v1/system/config',
@ -116,7 +116,7 @@ class TestAkandaClient(unittest.TestCase):
self.mock_put.return_value.text = 'error_text' self.mock_put.return_value.text = 'error_text'
with self.assertRaises(Exception): with self.assertRaises(Exception):
akanda_client.update_config('fe80::2', 5000, config) astara_client.update_config('fe80::2', 5000, config)
self.mock_put.assert_called_once_with( self.mock_put.assert_called_once_with(
'http://[fe80::2]:5000/v1/system/config', 'http://[fe80::2]:5000/v1/system/config',
@ -130,7 +130,7 @@ class TestAkandaClient(unittest.TestCase):
self.mock_post.return_value.json.return_value = { self.mock_post.return_value.json.return_value = {
'labels': ['label1', 'label2'] 'labels': ['label1', 'label2']
} }
resp = akanda_client.read_labels('fe80::2', 5000) resp = astara_client.read_labels('fe80::2', 5000)
self.mock_post.assert_called_once_with( self.mock_post.assert_called_once_with(
'http://[fe80::2]:5000/v1/firewall/labels', 'http://[fe80::2]:5000/v1/firewall/labels',

4
astara/test/unit/api/test_keystone.py
View File

@ -13,9 +13,9 @@
# under the License. # under the License.
import mock import mock
from akanda.rug.api import keystone from astara.api import keystone
from akanda.rug.test.unit import base from astara.test.unit import base
from oslo_config import cfg from oslo_config import cfg

41
astara/test/unit/api/test_neutron_wrapper.py
View File

@ -20,8 +20,8 @@ import copy
import mock import mock
import netaddr import netaddr
from akanda.rug.test.unit import base from astara.test.unit import base
from akanda.rug.api import neutron from astara.api import neutron
class TestuNeutronModels(base.RugTestBase): class TestuNeutronModels(base.RugTestBase):
@ -244,9 +244,9 @@ class FakeConf:
class TestNeutronWrapper(base.RugTestBase): class TestNeutronWrapper(base.RugTestBase):
@mock.patch('akanda.rug.api.neutron.cfg') @mock.patch('astara.api.neutron.cfg')
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
@mock.patch('akanda.rug.api.neutron.importutils') @mock.patch('astara.api.neutron.importutils')
def test_purge_management_interface(self, import_utils, ak_wrapper, cfg): def test_purge_management_interface(self, import_utils, ak_wrapper, cfg):
conf = mock.Mock() conf = mock.Mock()
driver = mock.Mock() driver = mock.Mock()
@ -265,7 +265,7 @@ class TestNeutronWrapper(base.RugTestBase):
'PORT1', {'port': {'device_id': ''}} 'PORT1', {'port': {'device_id': ''}}
) )
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_neutron_router_status_update_error(self, client_wrapper): def test_neutron_router_status_update_error(self, client_wrapper):
urs = client_wrapper.return_value.update_status urs = client_wrapper.return_value.update_status
urs.side_effect = RuntimeError('should be caught') urs.side_effect = RuntimeError('should be caught')
@ -273,14 +273,14 @@ class TestNeutronWrapper(base.RugTestBase):
neutron_wrapper = neutron.Neutron(conf) neutron_wrapper = neutron.Neutron(conf)
neutron_wrapper.update_router_status('router-id', 'new-status') neutron_wrapper.update_router_status('router-id', 'new-status')
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def _test_create_vrrp_port_success_hlpr(self, ext_enabled, client_wrapper): def _test_create_vrrp_port_success_hlpr(self, ext_enabled, client_wrapper):
conf = mock.Mock() conf = mock.Mock()
conf.neutron_port_security_extension_enabled = ext_enabled conf.neutron_port_security_extension_enabled = ext_enabled
expected_port_data = { expected_port_data = {
'port': { 'port': {
'name': 'AKANDA:VRRP:obj_id', 'name': 'ASTARA:VRRP:obj_id',
'admin_state_up': True, 'admin_state_up': True,
'network_id': 'the_net_id', 'network_id': 'the_net_id',
'fixed_ips': [], 'fixed_ips': [],
@ -314,7 +314,7 @@ class TestNeutronWrapper(base.RugTestBase):
def test_create_vrrp_port_success_port_security_disabled(self): def test_create_vrrp_port_success_port_security_disabled(self):
self._test_create_vrrp_port_success_hlpr(False) self._test_create_vrrp_port_success_hlpr(False)
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_create_vrrp_port_error(self, client_wrapper): def test_create_vrrp_port_error(self, client_wrapper):
neutron_wrapper = neutron.Neutron(mock.Mock()) neutron_wrapper = neutron.Neutron(mock.Mock())
api_client = neutron_wrapper.api_client api_client = neutron_wrapper.api_client
@ -327,7 +327,7 @@ class TestNeutronWrapper(base.RugTestBase):
'the_net_id' 'the_net_id'
) )
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_delete_vrrp_ports(self, client_wrapper): def test_delete_vrrp_ports(self, client_wrapper):
conf = mock.Mock() conf = mock.Mock()
neutron_wrapper = neutron.Neutron(conf) neutron_wrapper = neutron.Neutron(conf)
@ -339,12 +339,12 @@ class TestNeutronWrapper(base.RugTestBase):
neutron_wrapper.api_client.delete_port = mock.Mock() neutron_wrapper.api_client.delete_port = mock.Mock()
neutron_wrapper.delete_vrrp_port(object_id='foo') neutron_wrapper.delete_vrrp_port(object_id='foo')
neutron_wrapper.api_client.list_ports.assert_called_with( neutron_wrapper.api_client.list_ports.assert_called_with(
name='AKANDA:VRRP:foo' name='ASTARA:VRRP:foo'
) )
neutron_wrapper.api_client.delete_port.assert_called_with( neutron_wrapper.api_client.delete_port.assert_called_with(
'fake_port_id') 'fake_port_id')
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_delete_vrrp_ports_not_found(self, client_wrapper): def test_delete_vrrp_ports_not_found(self, client_wrapper):
conf = mock.Mock() conf = mock.Mock()
neutron_wrapper = neutron.Neutron(conf) neutron_wrapper = neutron.Neutron(conf)
@ -353,8 +353,11 @@ class TestNeutronWrapper(base.RugTestBase):
) )
neutron_wrapper.api_client.delete_port = mock.Mock() neutron_wrapper.api_client.delete_port = mock.Mock()
neutron_wrapper.delete_vrrp_port(object_id='foo') neutron_wrapper.delete_vrrp_port(object_id='foo')
neutron_wrapper.api_client.list_ports.assert_called_with( neutron_wrapper.api_client.list_ports.assert_has_calls(
name='AKANDA:VRRP:foo' [
mock.call(name='ASTARA:VRRP:foo'),
mock.call(name='AKANDA:VRRP:foo'),
]
) )
self.assertFalse(neutron_wrapper.api_client.delete_port.called) self.assertFalse(neutron_wrapper.api_client.delete_port.called)
@ -453,7 +456,7 @@ class TestExternalPort(base.RugTestBase):
self.conf.external_network_id = self.EXTERNAL_NET_ID self.conf.external_network_id = self.EXTERNAL_NET_ID
self.router = neutron.Router.from_dict(self.ROUTER) self.router = neutron.Router.from_dict(self.ROUTER)
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_create(self, client_wrapper): def test_create(self, client_wrapper):
mock_client = mock.Mock() mock_client = mock.Mock()
mock_client.show_router.return_value = {'router': self.ROUTER} mock_client.show_router.return_value = {'router': self.ROUTER}
@ -467,7 +470,7 @@ class TestExternalPort(base.RugTestBase):
port = neutron_wrapper.create_router_external_port(self.router) port = neutron_wrapper.create_router_external_port(self.router)
self.assertEqual(port.id, self.EXTERNAL_PORT_ID) self.assertEqual(port.id, self.EXTERNAL_PORT_ID)
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_create_missing_gateway_port(self, client_wrapper): def test_create_missing_gateway_port(self, client_wrapper):
self.conf.retry_delay = 0 self.conf.retry_delay = 0
mock_client = mock.Mock() mock_client = mock.Mock()
@ -486,7 +489,7 @@ class TestExternalPort(base.RugTestBase):
self.router self.router
) )
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_missing_v4(self, client_wrapper): def test_missing_v4(self, client_wrapper):
mock_client = mock.Mock() mock_client = mock.Mock()
@ -509,7 +512,7 @@ class TestExternalPort(base.RugTestBase):
else: else:
self.fail('Should have seen MissingIPAllocation') self.fail('Should have seen MissingIPAllocation')
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_missing_v6(self, client_wrapper): def test_missing_v6(self, client_wrapper):
mock_client = mock.Mock() mock_client = mock.Mock()
@ -532,7 +535,7 @@ class TestExternalPort(base.RugTestBase):
else: else:
self.fail('Should have seen MissingIPAllocation') self.fail('Should have seen MissingIPAllocation')
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
def test_missing_both(self, client_wrapper): def test_missing_both(self, client_wrapper):
mock_client = mock.Mock() mock_client = mock.Mock()

11
astara/test/unit/api/test_nova_wrapper.py
View File

@ -18,12 +18,11 @@
from datetime import datetime, timedelta from datetime import datetime, timedelta
import mock import mock
from six.moves import builtins as __builtins__
from akanda.rug.api import nova
from akanda.rug.test.unit import base
from novaclient import exceptions as novaclient_exceptions from novaclient import exceptions as novaclient_exceptions
from six.moves import builtins as __builtins__
from astara.api import nova
from astara.test.unit import base
class FakeNovaServer(object): class FakeNovaServer(object):
@ -412,7 +411,7 @@ class TestPezInstanceProvider(base.RugTestBase):
self.nova_client_cls = patch.start() self.nova_client_cls = patch.start()
self.nova_client_cls.return_value = self.nova_client self.nova_client_cls.return_value = self.nova_client
patch = mock.patch('akanda.rug.pez.rpcapi.AkandaPezAPI') patch = mock.patch('astara.pez.rpcapi.AstaraPezAPI')
self.rpc_client = mock.Mock() self.rpc_client = mock.Mock()
self.rpc_client_cls = patch.start() self.rpc_client_cls = patch.start()
self.rpc_client_cls.return_value = self.rpc_client self.rpc_client_cls.return_value = self.rpc_client

13
astara/test/unit/api/test_rug_api.py
View File

@ -1,13 +1,12 @@
import unittest import unittest
import mock
import socket import socket
import webob
from cliff import commandmanager from cliff import commandmanager
import mock
from akanda.rug.api import rug
from oslo_log import loggers from oslo_log import loggers
import webob
from astara.api import rug
try: try:
@ -22,7 +21,7 @@ class TestRugAPI(unittest.TestCase):
def setUp(self): def setUp(self):
ctl = mock.Mock() ctl = mock.Mock()
ctl.return_value.command_manager = commandmanager.CommandManager( ctl.return_value.command_manager = commandmanager.CommandManager(
'akanda.rug.cli' 'astara.cli'
) )
self.api = rug.RugAPI(ctl) self.api = rug.RugAPI(ctl)
self.ctl = ctl.return_value self.ctl = ctl.return_value

2
astara/test/unit/base.py
View File

@ -26,7 +26,7 @@ class RugTestBase(testtools.TestCase):
super(RugTestBase, self).setUp() super(RugTestBase, self).setUp()
self.test_config = self.useFixture(config_fixture.Config(cfg.CONF)) self.test_config = self.useFixture(config_fixture.Config(cfg.CONF))
self.argv = [] self.argv = []
cfg.CONF.import_opt('host', 'akanda.rug.main') cfg.CONF.import_opt('host', 'astara.main')
def config(self, **kw): def config(self, **kw):
"""Override config options for a test.""" """Override config options for a test."""

2
astara/test/unit/common/test_agent_linux_utils.py
View File

@ -36,7 +36,7 @@ import fixtures
import mock import mock
import testtools import testtools
from akanda.rug.common.linux import utils from astara.common.linux import utils
class AgentUtilsExecuteTest(testtools.TestCase): class AgentUtilsExecuteTest(testtools.TestCase):

4
astara/test/unit/common/test_config.py
View File

@ -15,8 +15,8 @@
import mock import mock
from akanda.rug.common import config from astara.common import config
from akanda.rug.test.unit import base from astara.test.unit import base
class TestConfig(base.RugTestBase): class TestConfig(base.RugTestBase):

6
astara/test/unit/common/test_hash_ring.py
View File

@ -20,9 +20,9 @@ import mock
from oslo_config import cfg from oslo_config import cfg
from testtools import matchers from testtools import matchers
from akanda.rug.common import hash_ring from astara.common import hash_ring
from akanda.rug.test.unit import base from astara.test.unit import base
# from akanda.rug.tests.unit.db import base as db_base # from astara.tests.unit.db import base as db_base
CONF = cfg.CONF CONF = cfg.CONF

14
astara/test/unit/common/test_linux_interface.py
View File

@ -37,9 +37,9 @@ import unittest
import mock import mock
from oslo_config import cfg from oslo_config import cfg
from akanda.rug.common.linux import interface from astara.common.linux import interface
from akanda.rug.common.linux import ip_lib from astara.common.linux import ip_lib
from akanda.rug.common.linux import utils from astara.common.linux import utils
class BaseChild(interface.LinuxInterfaceDriver): class BaseChild(interface.LinuxInterfaceDriver):
@ -180,7 +180,7 @@ class TestOVSInterfaceDriver(TestBase):
def test_unplug(self, bridge=None): def test_unplug(self, bridge=None):
if not bridge: if not bridge:
bridge = 'br-int' bridge = 'br-int'
with mock.patch('akanda.rug.common.linux.ovs_lib.OVSBridge') as ovs_br: with mock.patch('astara.common.linux.ovs_lib.OVSBridge') as ovs_br:
ovs = interface.OVSInterfaceDriver(self.conf) ovs = interface.OVSInterfaceDriver(self.conf)
ovs.unplug('tap0') ovs.unplug('tap0')
ovs_br.assert_has_calls([mock.call(bridge, 'sudo'), ovs_br.assert_has_calls([mock.call(bridge, 'sudo'),
@ -231,7 +231,7 @@ class TestBridgeInterfaceDriver(TestBase):
def test_plug_dev_exists(self): def test_plug_dev_exists(self):
self.device_exists.return_value = True self.device_exists.return_value = True
with mock.patch( with mock.patch(
'akanda.rug.common.linux.interface.LOG.warning') as log: 'astara.common.linux.interface.LOG.warning') as log:
br = interface.BridgeInterfaceDriver(self.conf) br = interface.BridgeInterfaceDriver(self.conf)
br.plug('01234567-1234-1234-99', br.plug('01234567-1234-1234-99',
'port-1234', 'port-1234',
@ -243,7 +243,7 @@ class TestBridgeInterfaceDriver(TestBase):
def test_unplug_no_device(self): def test_unplug_no_device(self):
self.device_exists.return_value = False self.device_exists.return_value = False
self.ip_dev().link.delete.side_effect = RuntimeError self.ip_dev().link.delete.side_effect = RuntimeError
with mock.patch('akanda.rug.common.linux.interface.LOG') as log: with mock.patch('astara.common.linux.interface.LOG') as log:
br = interface.BridgeInterfaceDriver(self.conf) br = interface.BridgeInterfaceDriver(self.conf)
br.unplug('tap0') br.unplug('tap0')
[mock.call(), mock.call('tap0', 'sudo'), mock.call().link.delete()] [mock.call(), mock.call('tap0', 'sudo'), mock.call().link.delete()]
@ -251,7 +251,7 @@ class TestBridgeInterfaceDriver(TestBase):
def test_unplug(self): def test_unplug(self):
self.device_exists.return_value = True self.device_exists.return_value = True
with mock.patch('akanda.rug.common.linux.interface.LOG.debug') as log: with mock.patch('astara.common.linux.interface.LOG.debug') as log:
br = interface.BridgeInterfaceDriver(self.conf) br = interface.BridgeInterfaceDriver(self.conf)
br.unplug('tap0') br.unplug('tap0')
self.assertEqual(log.call_count, 1) self.assertEqual(log.call_count, 1)

10
astara/test/unit/common/test_linux_ip_lib.py
View File

@ -37,7 +37,7 @@ import unittest
import mock import mock
from akanda.rug.common.linux import ip_lib from astara.common.linux import ip_lib
NETNS_SAMPLE = [ NETNS_SAMPLE = [
@ -120,7 +120,7 @@ SUBNET_SAMPLE2 = ("10.0.0.0/24 dev tap1d7888a7-10 scope link src 10.0.0.2\n"
class TestSubProcessBase(unittest.TestCase): class TestSubProcessBase(unittest.TestCase):
def setUp(self): def setUp(self):
super(TestSubProcessBase, self).setUp() super(TestSubProcessBase, self).setUp()
self.execute_p = mock.patch('akanda.rug.common.linux.utils.execute') self.execute_p = mock.patch('astara.common.linux.utils.execute')
self.execute = self.execute_p.start() self.execute = self.execute_p.start()
self.addCleanup(self.execute_p.stop) self.addCleanup(self.execute_p.stop)
@ -646,7 +646,7 @@ class TestIpNetnsCommand(TestIPCmdBase):
self.assertEqual(ns.namespace, 'ns') self.assertEqual(ns.namespace, 'ns')
def test_delete_namespace(self): def test_delete_namespace(self):
with mock.patch('akanda.rug.common.linux.utils.execute'): with mock.patch('astara.common.linux.utils.execute'):
self.netns_cmd.delete('ns') self.netns_cmd.delete('ns')
self._assert_sudo([], ('delete', 'ns'), force_root_namespace=True) self._assert_sudo([], ('delete', 'ns'), force_root_namespace=True)
@ -666,7 +666,7 @@ class TestIpNetnsCommand(TestIPCmdBase):
def test_execute(self): def test_execute(self):
self.parent.namespace = 'ns' self.parent.namespace = 'ns'
with mock.patch('akanda.rug.common.linux.utils.execute') as execute: with mock.patch('astara.common.linux.utils.execute') as execute:
self.netns_cmd.execute(['ip', 'link', 'list']) self.netns_cmd.execute(['ip', 'link', 'list'])
execute.assert_called_once_with(['ip', 'netns', 'exec', 'ns', 'ip', execute.assert_called_once_with(['ip', 'netns', 'exec', 'ns', 'ip',
'link', 'list'], 'link', 'list'],
@ -675,7 +675,7 @@ class TestIpNetnsCommand(TestIPCmdBase):
def test_execute_env_var_prepend(self): def test_execute_env_var_prepend(self):
self.parent.namespace = 'ns' self.parent.namespace = 'ns'
with mock.patch('akanda.rug.common.linux.utils.execute') as execute: with mock.patch('astara.common.linux.utils.execute') as execute:
env = collections.OrderedDict([('FOO', 1), ('BAR', 2)]) env = collections.OrderedDict([('FOO', 1), ('BAR', 2)])
self.netns_cmd.execute(['ip', 'link', 'list'], env) self.netns_cmd.execute(['ip', 'link', 'list'], env)
execute.assert_called_once_with( execute.assert_called_once_with(

8
astara/test/unit/db/base.py
View File

@ -13,7 +13,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
"""Akanda Rug DB test base class.""" """Astara DB test base class."""
import os import os
import shutil import shutil
@ -22,9 +22,9 @@ import fixtures
from oslo_config import cfg from oslo_config import cfg
from oslo_db.sqlalchemy import enginefacade from oslo_db.sqlalchemy import enginefacade
from akanda.rug.db import api as dbapi from astara.db import api as dbapi
from akanda.rug.db.sqlalchemy import migration from astara.db.sqlalchemy import migration
from akanda.rug.test.unit import base from astara.test.unit import base
CONF = cfg.CONF CONF = cfg.CONF

2
astara/test/unit/db/test_debug_mode.py
View File

@ -16,7 +16,7 @@
import uuid import uuid
from akanda.rug.test.unit.db import base from astara.test.unit.db import base
class TestDBDebugModes(base.DbTestCase): class TestDBDebugModes(base.DbTestCase):

4
astara/test/unit/drivers/test_factory.py
View File

@ -12,9 +12,9 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from akanda.rug.test.unit import base from astara.test.unit import base
from akanda.rug import drivers from astara import drivers
class DriverFactoryTest(base.RugTestBase): class DriverFactoryTest(base.RugTestBase):

46
astara/test/unit/drivers/test_loadbalancer.py
View File

@ -16,11 +16,11 @@ import mock
from neutronclient.common import exceptions as neutron_exceptions from neutronclient.common import exceptions as neutron_exceptions
from akanda.rug import event from astara import event
from akanda.rug.api import neutron from astara.api import neutron
from akanda.rug.drivers import loadbalancer, states from astara.drivers import loadbalancer, states
from akanda.rug.test.unit import base, fakes from astara.test.unit import base, fakes
class LoadBalancerDriverTest(base.RugTestBase): class LoadBalancerDriverTest(base.RugTestBase):
@ -46,7 +46,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
id=self.loadbalancer_id, id=self.loadbalancer_id,
) )
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer.post_init') @mock.patch('astara.drivers.loadbalancer.LoadBalancer.post_init')
def test_init(self, mock_post_init): def test_init(self, mock_post_init):
lb = self._init_driver() lb = self._init_driver()
lb.post_init = mock.Mock() lb.post_init = mock.Mock()
@ -77,8 +77,8 @@ class LoadBalancerDriverTest(base.RugTestBase):
lb = self._init_driver() lb = self._init_driver()
lb.pre_plug(self.ctx) lb.pre_plug(self.ctx)
@mock.patch('akanda.rug.api.config.loadbalancer.build_config') @mock.patch('astara.api.config.loadbalancer.build_config')
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer._ensure_cache') @mock.patch('astara.drivers.loadbalancer.LoadBalancer._ensure_cache')
def test_build_config(self, mock_ensure_cache, mock_build_config): def test_build_config(self, mock_ensure_cache, mock_build_config):
lb = self._init_driver() lb = self._init_driver()
fake_lb = fakes.fake_loadbalancer() fake_lb = fakes.fake_loadbalancer()
@ -93,7 +93,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
self.ctx.neutron, lb._loadbalancer, fake_mgt_port, fake_iface_map) self.ctx.neutron, lb._loadbalancer, fake_mgt_port, fake_iface_map)
self.assertEqual(res, 'fake_config') self.assertEqual(res, 'fake_config')
@mock.patch('akanda.rug.api.akanda_client.update_config') @mock.patch('astara.api.astara_client.update_config')
def test_update_config(self, mock_update_config): def test_update_config(self, mock_update_config):
lb = self._init_driver() lb = self._init_driver()
lb.update_config(management_address='10.0.0.1', config='fake_config') lb.update_config(management_address='10.0.0.1', config='fake_config')
@ -102,7 +102,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
lb.mgt_port, lb.mgt_port,
'fake_config',) 'fake_config',)
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer._ensure_cache') @mock.patch('astara.drivers.loadbalancer.LoadBalancer._ensure_cache')
def test_make_ports(self, mock_ensure_cache): def test_make_ports(self, mock_ensure_cache):
lb = self._init_driver() lb = self._init_driver()
fake_lb = fakes.fake_loadbalancer() fake_lb = fakes.fake_loadbalancer()
@ -115,7 +115,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
res = callback() res = callback()
self.assertEqual(res, ('fake_mgt_port', [fake_lb_port])) self.assertEqual(res, ('fake_mgt_port', [fake_lb_port]))
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_retry_loop(self, mocked_neutron_api): def test_pre_populate_retry_loop(self, mocked_neutron_api):
neutron_client = mock.Mock() neutron_client = mock.Mock()
returned_value = [Exception, []] returned_value = [Exception, []]
@ -148,21 +148,21 @@ class LoadBalancerDriverTest(base.RugTestBase):
mock.ANY mock.ANY
) )
@mock.patch('akanda.rug.drivers.loadbalancer.LOG') @mock.patch('astara.drivers.loadbalancer.LOG')
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_unauthorized(self, mocked_neutron_api, log): def test_pre_populate_unauthorized(self, mocked_neutron_api, log):
exc = neutron_exceptions.Unauthorized exc = neutron_exceptions.Unauthorized
self._exit_loop_bad_auth(mocked_neutron_api, log, exc) self._exit_loop_bad_auth(mocked_neutron_api, log, exc)
@mock.patch('akanda.rug.drivers.loadbalancer.LOG') @mock.patch('astara.drivers.loadbalancer.LOG')
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_forbidden(self, mocked_neutron_api, log): def test_pre_populate_forbidden(self, mocked_neutron_api, log):
exc = neutron_exceptions.Forbidden exc = neutron_exceptions.Forbidden
self._exit_loop_bad_auth(mocked_neutron_api, log, exc) self._exit_loop_bad_auth(mocked_neutron_api, log, exc)
@mock.patch('akanda.rug.drivers.loadbalancer.LOG.warning') @mock.patch('astara.drivers.loadbalancer.LOG.warning')
@mock.patch('akanda.rug.drivers.loadbalancer.LOG.debug') @mock.patch('astara.drivers.loadbalancer.LOG.debug')
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_retry_loop_logging( def test_pre_populate_retry_loop_logging(
self, mocked_neutron_api, log_debug, log_warning): self, mocked_neutron_api, log_debug, log_warning):
neutron_client = mock.Mock() neutron_client = mock.Mock()
@ -300,7 +300,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
def test_process_notification_not_subscribed(self): def test_process_notification_not_subscribed(self):
self._test_notification('whocares.about.this', {}, None) self._test_notification('whocares.about.this', {}, None)
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer._ensure_cache') @mock.patch('astara.drivers.loadbalancer.LoadBalancer._ensure_cache')
def test_get_state_no_lb(self, mock_ensure_cache): def test_get_state_no_lb(self, mock_ensure_cache):
lb = self._init_driver() lb = self._init_driver()
lb._loadbalancer = None lb._loadbalancer = None
@ -310,7 +310,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
) )
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer._ensure_cache') @mock.patch('astara.drivers.loadbalancer.LoadBalancer._ensure_cache')
def test_get_state(self, mock_ensure_cache): def test_get_state(self, mock_ensure_cache):
lb = self._init_driver() lb = self._init_driver()
fake_lb = fakes.fake_loadbalancer() fake_lb = fakes.fake_loadbalancer()
@ -321,7 +321,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
) )
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer._ensure_cache') @mock.patch('astara.drivers.loadbalancer.LoadBalancer._ensure_cache')
def test_synchronize_state_no_router(self, mock_ensure_cache): def test_synchronize_state_no_router(self, mock_ensure_cache):
lb = self._init_driver() lb = self._init_driver()
lb._loadbalancer = None lb._loadbalancer = None
@ -329,7 +329,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
self.assertFalse(self.ctx.neutron.update_loadbalancer_status.called) self.assertFalse(self.ctx.neutron.update_loadbalancer_status.called)
@mock.patch('akanda.rug.drivers.loadbalancer.LoadBalancer._ensure_cache') @mock.patch('astara.drivers.loadbalancer.LoadBalancer._ensure_cache')
def test_synchronize_state(self, mock_ensure_cache): def test_synchronize_state(self, mock_ensure_cache):
lb = self._init_driver() lb = self._init_driver()
fake_lb = fakes.fake_loadbalancer() fake_lb = fakes.fake_loadbalancer()
@ -342,7 +342,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
) )
self.assertEquals(lb._last_synced_status, 'ACTIVE') self.assertEquals(lb._last_synced_status, 'ACTIVE')
@mock.patch('akanda.rug.api.akanda_client.get_interfaces') @mock.patch('astara.api.astara_client.get_interfaces')
def test_get_interfaces(self, mock_get_interfaces): def test_get_interfaces(self, mock_get_interfaces):
mock_get_interfaces.return_value = ['fake_interface'] mock_get_interfaces.return_value = ['fake_interface']
lb = self._init_driver() lb = self._init_driver()
@ -351,7 +351,7 @@ class LoadBalancerDriverTest(base.RugTestBase):
mock_get_interfaces.assert_called_with( mock_get_interfaces.assert_called_with(
'fake_mgt_addr', self.mgt_port) 'fake_mgt_addr', self.mgt_port)
@mock.patch('akanda.rug.api.akanda_client.is_alive') @mock.patch('astara.api.astara_client.is_alive')
def test_is_alive(self, mock_is_alive): def test_is_alive(self, mock_is_alive):
mock_is_alive.return_value = False mock_is_alive.return_value = False
lb = self._init_driver() lb = self._init_driver()

52
astara/test/unit/drivers/test_router.py
View File

@ -16,11 +16,11 @@ import mock
from neutronclient.common import exceptions as neutron_exceptions from neutronclient.common import exceptions as neutron_exceptions
from akanda.rug import event from astara import event
from akanda.rug.api import neutron from astara.api import neutron
from akanda.rug.drivers import router, states from astara.drivers import router, states
from akanda.rug.test.unit import base, fakes from astara.test.unit import base, fakes
class RouterDriverTest(base.RugTestBase): class RouterDriverTest(base.RugTestBase):
@ -46,7 +46,7 @@ class RouterDriverTest(base.RugTestBase):
id=self.router_id, id=self.router_id,
) )
@mock.patch('akanda.rug.drivers.router.Router.post_init') @mock.patch('astara.drivers.router.Router.post_init')
def test_init(self, mock_post_init): def test_init(self, mock_post_init):
rtr = self._init_driver() rtr = self._init_driver()
rtr.post_init = mock.Mock() rtr.post_init = mock.Mock()
@ -55,7 +55,7 @@ class RouterDriverTest(base.RugTestBase):
'ak-%s-%s' % (rtr.RESOURCE_NAME, self.router_id)) 'ak-%s-%s' % (rtr.RESOURCE_NAME, self.router_id))
mock_post_init.assert_called_with(self.ctx) mock_post_init.assert_called_with(self.ctx)
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_post_init(self, mock_ensure_cache): def test_post_init(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
rtr.post_init(self.ctx) rtr.post_init(self.ctx)
@ -85,14 +85,14 @@ class RouterDriverTest(base.RugTestBase):
rtr._router = fake_router_obj rtr._router = fake_router_obj
self.assertEqual(set(rtr.ports), set(fake_router_obj.ports)) self.assertEqual(set(rtr.ports), set(fake_router_obj.ports))
@mock.patch('akanda.rug.drivers.router.Router.pre_plug') @mock.patch('astara.drivers.router.Router.pre_plug')
def test_pre_boot(self, mock_pre_plug): def test_pre_boot(self, mock_pre_plug):
rtr = self._init_driver() rtr = self._init_driver()
rtr.pre_boot(self.ctx) rtr.pre_boot(self.ctx)
mock_pre_plug.assert_called_with(self.ctx) mock_pre_plug.assert_called_with(self.ctx)
@mock.patch('akanda.rug.api.config.router.build_config') @mock.patch('astara.api.config.router.build_config')
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_build_config(self, mock_ensure_cache, mock_build_config): def test_build_config(self, mock_ensure_cache, mock_build_config):
rtr = self._init_driver() rtr = self._init_driver()
fake_router_obj = fakes.fake_router() fake_router_obj = fakes.fake_router()
@ -107,7 +107,7 @@ class RouterDriverTest(base.RugTestBase):
self.ctx.neutron, rtr._router, fake_mgt_port, fake_iface_map) self.ctx.neutron, rtr._router, fake_mgt_port, fake_iface_map)
self.assertEqual(res, 'fake_config') self.assertEqual(res, 'fake_config')
@mock.patch('akanda.rug.api.akanda_client.update_config') @mock.patch('astara.api.astara_client.update_config')
def test_update_config(self, mock_update_config): def test_update_config(self, mock_update_config):
rtr = self._init_driver() rtr = self._init_driver()
rtr.update_config(management_address='10.0.0.1', config='fake_config') rtr.update_config(management_address='10.0.0.1', config='fake_config')
@ -135,7 +135,7 @@ class RouterDriverTest(base.RugTestBase):
rtr.pre_plug(self.ctx) rtr.pre_plug(self.ctx)
self.assertFalse(self.ctx.neutron.create_router_external_port.called) self.assertFalse(self.ctx.neutron.create_router_external_port.called)
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_make_ports(self, mock_ensure_cache): def test_make_ports(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
fake_router_obj = fakes.fake_router() fake_router_obj = fakes.fake_router()
@ -160,7 +160,7 @@ class RouterDriverTest(base.RugTestBase):
mock.call(rtr.id, label='MGT')] mock.call(rtr.id, label='MGT')]
self.ctx.neutron.delete_vrrp_port.assert_has_calls(expected_ports) self.ctx.neutron.delete_vrrp_port.assert_has_calls(expected_ports)
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_retry_loop(self, mocked_neutron_api): def test_pre_populate_retry_loop(self, mocked_neutron_api):
neutron_client = mock.Mock() neutron_client = mock.Mock()
returned_value = [Exception, []] returned_value = [Exception, []]
@ -193,21 +193,21 @@ class RouterDriverTest(base.RugTestBase):
mock.ANY mock.ANY
) )
@mock.patch('akanda.rug.drivers.router.LOG') @mock.patch('astara.drivers.router.LOG')
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_unauthorized(self, mocked_neutron_api, log): def test_pre_populate_unauthorized(self, mocked_neutron_api, log):
exc = neutron_exceptions.Unauthorized exc = neutron_exceptions.Unauthorized
self._exit_loop_bad_auth(mocked_neutron_api, log, exc) self._exit_loop_bad_auth(mocked_neutron_api, log, exc)
@mock.patch('akanda.rug.drivers.router.LOG') @mock.patch('astara.drivers.router.LOG')
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_forbidden(self, mocked_neutron_api, log): def test_pre_populate_forbidden(self, mocked_neutron_api, log):
exc = neutron_exceptions.Forbidden exc = neutron_exceptions.Forbidden
self._exit_loop_bad_auth(mocked_neutron_api, log, exc) self._exit_loop_bad_auth(mocked_neutron_api, log, exc)
@mock.patch('akanda.rug.drivers.router.LOG.warning') @mock.patch('astara.drivers.router.LOG.warning')
@mock.patch('akanda.rug.drivers.router.LOG.debug') @mock.patch('astara.drivers.router.LOG.debug')
@mock.patch('akanda.rug.api.neutron.Neutron') @mock.patch('astara.api.neutron.Neutron')
def test_pre_populate_retry_loop_logging( def test_pre_populate_retry_loop_logging(
self, mocked_neutron_api, log_debug, log_warning): self, mocked_neutron_api, log_debug, log_warning):
neutron_client = mock.Mock() neutron_client = mock.Mock()
@ -329,7 +329,7 @@ class RouterDriverTest(base.RugTestBase):
payload = {'router': {'id': 'fake_router_id'}} payload = {'router': {'id': 'fake_router_id'}}
self._test_notification('whocares.about.this', payload, None) self._test_notification('whocares.about.this', payload, None)
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_get_state_no_router(self, mock_ensure_cache): def test_get_state_no_router(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
rtr._router = None rtr._router = None
@ -339,7 +339,7 @@ class RouterDriverTest(base.RugTestBase):
) )
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_get_state(self, mock_ensure_cache): def test_get_state(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
fake_router = fakes.fake_router() fake_router = fakes.fake_router()
@ -350,7 +350,7 @@ class RouterDriverTest(base.RugTestBase):
) )
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_synchronize_state_no_router(self, mock_ensure_cache): def test_synchronize_state_no_router(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
rtr._router = None rtr._router = None
@ -358,7 +358,7 @@ class RouterDriverTest(base.RugTestBase):
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
self.assertFalse(self.ctx.neutron.update_router_status.called) self.assertFalse(self.ctx.neutron.update_router_status.called)
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_synchronize_state(self, mock_ensure_cache): def test_synchronize_state(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
fake_router_obj = fakes.fake_router() fake_router_obj = fakes.fake_router()
@ -371,7 +371,7 @@ class RouterDriverTest(base.RugTestBase):
) )
self.assertEquals(rtr._last_synced_status, 'ACTIVE') self.assertEquals(rtr._last_synced_status, 'ACTIVE')
@mock.patch('akanda.rug.drivers.router.Router._ensure_cache') @mock.patch('astara.drivers.router.Router._ensure_cache')
def test_synchronize_state_no_change(self, mock_ensure_cache): def test_synchronize_state_no_change(self, mock_ensure_cache):
rtr = self._init_driver() rtr = self._init_driver()
fake_router_obj = fakes.fake_router() fake_router_obj = fakes.fake_router()
@ -381,7 +381,7 @@ class RouterDriverTest(base.RugTestBase):
mock_ensure_cache.assert_called_with(self.ctx) mock_ensure_cache.assert_called_with(self.ctx)
self.assertFalse(self.ctx.neutron.update_router_status.called) self.assertFalse(self.ctx.neutron.update_router_status.called)
@mock.patch('akanda.rug.api.akanda_client.get_interfaces') @mock.patch('astara.api.astara_client.get_interfaces')
def test_get_interfaces(self, mock_get_interfaces): def test_get_interfaces(self, mock_get_interfaces):
mock_get_interfaces.return_value = ['fake_interface'] mock_get_interfaces.return_value = ['fake_interface']
rtr = self._init_driver() rtr = self._init_driver()
@ -390,7 +390,7 @@ class RouterDriverTest(base.RugTestBase):
mock_get_interfaces.assert_called_with( mock_get_interfaces.assert_called_with(
'fake_mgt_addr', self.mgt_port) 'fake_mgt_addr', self.mgt_port)
@mock.patch('akanda.rug.api.akanda_client.is_alive') @mock.patch('astara.api.astara_client.is_alive')
def test_is_alive(self, mock_is_alive): def test_is_alive(self, mock_is_alive):
mock_is_alive.return_value = False mock_is_alive.return_value = False
rtr = self._init_driver() rtr = self._init_driver()

6
astara/test/unit/fakes.py
View File

@ -14,9 +14,9 @@
import mock import mock
from akanda.rug.drivers import base from astara.drivers import base
from akanda.rug.api import neutron, nova from astara.api import neutron, nova
from akanda.rug import worker from astara import worker
def fake_loadbalancer(): def fake_loadbalancer():

2
astara/test/unit/openvswitch/test_ovs_lib.py
View File

@ -36,7 +36,7 @@ import unittest
import uuid import uuid
import mox import mox
from akanda.rug.common.linux import ovs_lib, utils from astara.common.linux import ovs_lib, utils
def generate_uuid(): def generate_uuid():

6
astara/test/unit/pez/test_pool_manager.py
View File

@ -18,8 +18,8 @@ import copy
import mock import mock
import time import time
from akanda.rug.pez import pool as ak_pool from astara.pez import pool as ak_pool
from akanda.rug.test.unit import base from astara.test.unit import base
class MockInstance(object): class MockInstance(object):
@ -47,7 +47,7 @@ class PoolManagerTest(base.RugTestBase):
[setattr(p, 'status', status) for p in pool] [setattr(p, 'status', status) for p in pool]
return pool return pool
@mock.patch('akanda.rug.pez.pool.PezPoolManager.delete_instance') @mock.patch('astara.pez.pool.PezPoolManager.delete_instance')
def test__check_err_instances(self, mock_delete): def test__check_err_instances(self, mock_delete):
pool = self._create_pool() pool = self._create_pool()
pool[1].id = 'errored_instance_id' pool[1].id = 'errored_instance_id'

20
astara/test/unit/test_coordination.py
View File

@ -4,9 +4,9 @@ from Queue import Queue
from tooz import coordination as tz_coordination from tooz import coordination as tz_coordination
from akanda.rug import coordination from astara import coordination
from akanda.rug import event from astara import event
from akanda.rug.test.unit import base from astara.test.unit import base
class TestRugCoordinator(base.RugTestBase): class TestRugCoordinator(base.RugTestBase):
@ -38,7 +38,7 @@ class TestRugCoordinator(base.RugTestBase):
self.addCleanup(mock.patch.stopall) self.addCleanup(mock.patch.stopall)
self.queue = Queue() self.queue = Queue()
@mock.patch('akanda.rug.coordination.RugCoordinator.start') @mock.patch('astara.coordination.RugCoordinator.start')
def test_setup(self, fake_start): def test_setup(self, fake_start):
self.coordinator = coordination.RugCoordinator(self.queue) self.coordinator = coordination.RugCoordinator(self.queue)
self.assertEqual('memcache://foo_cache', self.coordinator.url) self.assertEqual('memcache://foo_cache', self.coordinator.url)
@ -47,7 +47,7 @@ class TestRugCoordinator(base.RugTestBase):
self.assertEqual('foo_host', self.coordinator.host) self.assertEqual('foo_host', self.coordinator.host)
self.assertTrue(fake_start.called) self.assertTrue(fake_start.called)
@mock.patch('akanda.rug.coordination.RugCoordinator.cluster_changed') @mock.patch('astara.coordination.RugCoordinator.cluster_changed')
def test_start(self, fake_cluster_changed): def test_start(self, fake_cluster_changed):
self.coordinator = coordination.RugCoordinator(self.queue) self.coordinator = coordination.RugCoordinator(self.queue)
self.assertTrue(self.fake_coord.start.called) self.assertTrue(self.fake_coord.start.called)
@ -73,7 +73,7 @@ class TestRugCoordinator(base.RugTestBase):
return self.test_start() return self.test_start()
@mock.patch('time.sleep') @mock.patch('time.sleep')
@mock.patch('akanda.rug.coordination.RugCoordinator.stop') @mock.patch('astara.coordination.RugCoordinator.stop')
def test_run(self, fake_stop, fake_sleep): def test_run(self, fake_stop, fake_sleep):
fake_sleep.side_effect = coordination.CoordinatorDone() fake_sleep.side_effect = coordination.CoordinatorDone()
self.coordinator = coordination.RugCoordinator(self.queue) self.coordinator = coordination.RugCoordinator(self.queue)
@ -81,7 +81,7 @@ class TestRugCoordinator(base.RugTestBase):
self.assertTrue(self.fake_coord.heartbeat.called) self.assertTrue(self.fake_coord.heartbeat.called)
self.assertTrue(self.fake_coord.run_watchers.called) self.assertTrue(self.fake_coord.run_watchers.called)
@mock.patch('akanda.rug.coordination.RugCoordinator.is_leader') @mock.patch('astara.coordination.RugCoordinator.is_leader')
def test_stop_not_leader(self, fake_is_leader): def test_stop_not_leader(self, fake_is_leader):
fake_is_leader.__get__ = mock.Mock(return_value=False) fake_is_leader.__get__ = mock.Mock(return_value=False)
self.coordinator = coordination.RugCoordinator(self.queue) self.coordinator = coordination.RugCoordinator(self.queue)
@ -89,7 +89,7 @@ class TestRugCoordinator(base.RugTestBase):
self.fake_coord.leave_group.assert_called_with(self.coordinator.group) self.fake_coord.leave_group.assert_called_with(self.coordinator.group)
self.assertFalse(self.fake_coord.stand_down_group_leader.called) self.assertFalse(self.fake_coord.stand_down_group_leader.called)
@mock.patch('akanda.rug.coordination.RugCoordinator.is_leader') @mock.patch('astara.coordination.RugCoordinator.is_leader')
def test_stop_leader(self, fake_is_leader): def test_stop_leader(self, fake_is_leader):
fake_is_leader.__get__ = mock.Mock(return_value=True) fake_is_leader.__get__ = mock.Mock(return_value=True)
self.coordinator = coordination.RugCoordinator(self.queue) self.coordinator = coordination.RugCoordinator(self.queue)
@ -116,8 +116,8 @@ class TestRugCoordinator(base.RugTestBase):
self.assertEqual(self.coordinator.is_leader, True) self.assertEqual(self.coordinator.is_leader, True)
self.fake_coord.get_leader.assert_called_with(self.coordinator.group) self.fake_coord.get_leader.assert_called_with(self.coordinator.group)
@mock.patch('akanda.rug.coordination.RugCoordinator.start') @mock.patch('astara.coordination.RugCoordinator.start')
@mock.patch('akanda.rug.coordination.RugCoordinator.members') @mock.patch('astara.coordination.RugCoordinator.members')
def test_cluster_changed(self, fake_members, fake_start): def test_cluster_changed(self, fake_members, fake_start):
fake_members.__get__ = mock.Mock(return_value=['foo', 'bar']) fake_members.__get__ = mock.Mock(return_value=['foo', 'bar'])
self.coordinator = coordination.RugCoordinator(self.queue) self.coordinator = coordination.RugCoordinator(self.queue)

8
astara/test/unit/test_debug.py
View File

@ -19,8 +19,8 @@ import mock
from oslo_config import cfg from oslo_config import cfg
from akanda.rug import debug from astara import debug
from akanda.rug.test.unit import base from astara.test.unit import base
class TestDebug(base.RugTestBase): class TestDebug(base.RugTestBase):
@ -31,8 +31,8 @@ class TestDebug(base.RugTestBase):
cfg.CONF.unregister_opts(debug.DEBUG_OPTS) cfg.CONF.unregister_opts(debug.DEBUG_OPTS)
super(TestDebug, self).tearDown() super(TestDebug, self).tearDown()
@mock.patch('akanda.rug.worker.WorkerContext') @mock.patch('astara.worker.WorkerContext')
@mock.patch('akanda.rug.state.Automaton') @mock.patch('astara.state.Automaton')
@mock.patch('pdb.set_trace') @mock.patch('pdb.set_trace')
def test_debug_one_router(self, set_trace, automaton, ctx): def test_debug_one_router(self, set_trace, automaton, ctx):
ctx.return_value.neutron.get_router_detail.return_value = mock.Mock( ctx.return_value.neutron.get_router_detail.return_value = mock.Mock(

6
astara/test/unit/test_health.py
View File

@ -14,9 +14,9 @@
import mock import mock
from akanda.rug import event from astara import event
from akanda.rug import health from astara import health
from akanda.rug.test.unit import base from astara.test.unit import base
class BreakLoop(Exception): class BreakLoop(Exception):

12
astara/test/unit/test_instance_manager.py
View File

@ -21,11 +21,11 @@ import mock
import unittest2 as unittest import unittest2 as unittest
from datetime import datetime, timedelta from datetime import datetime, timedelta
from akanda.rug import instance_manager from astara import instance_manager
from akanda.rug.api import nova from astara.api import nova
from akanda.rug.drivers import states from astara.drivers import states
from akanda.rug.test.unit import base from astara.test.unit import base
from akanda.rug.test.unit import fakes from astara.test.unit import fakes
from oslo_config import cfg from oslo_config import cfg
@ -75,7 +75,7 @@ class TestInstanceManager(base.RugTestBase):
self.ctx = mock.Mock() self.ctx = mock.Mock()
self.neutron = self.ctx.neutron self.neutron = self.ctx.neutron
self.config(boot_timeout=30) self.config(boot_timeout=30)
self.config(akanda_mgt_service_port=5000) self.config(astara_mgt_service_port=5000)
self.config(max_retries=3) self.config(max_retries=3)
self.addCleanup(mock.patch.stopall) self.addCleanup(mock.patch.stopall)

48
astara/test/unit/test_main.py
View File

@ -20,17 +20,17 @@ import socket
import mock import mock
import testtools import testtools
from akanda.rug import main from astara import main
from akanda.rug import notifications as ak_notifications from astara import notifications as ak_notifications
from akanda.rug.test.unit import base from astara.test.unit import base
@mock.patch('akanda.rug.main.neutron_api') @mock.patch('astara.main.neutron_api')
@mock.patch('akanda.rug.main.multiprocessing') @mock.patch('astara.main.multiprocessing')
@mock.patch('akanda.rug.main.notifications') @mock.patch('astara.main.notifications')
@mock.patch('akanda.rug.main.scheduler') @mock.patch('astara.main.scheduler')
@mock.patch('akanda.rug.main.populate') @mock.patch('astara.main.populate')
@mock.patch('akanda.rug.main.health') @mock.patch('astara.main.health')
class TestMainPippo(base.RugTestBase): class TestMainPippo(base.RugTestBase):
def test_shuffle_notifications(self, health, populate, scheduler, def test_shuffle_notifications(self, health, populate, scheduler,
notifications, multiprocessing, notifications, multiprocessing,
@ -62,7 +62,7 @@ class TestMainPippo(base.RugTestBase):
'9306bbd8-f3cc-11e2-bd68-080027e60b25', 'message' '9306bbd8-f3cc-11e2-bd68-080027e60b25', 'message'
) )
@mock.patch('akanda.rug.main.shuffle_notifications') @mock.patch('astara.main.shuffle_notifications')
def test_ensure_local_service_port(self, shuffle_notifications, health, def test_ensure_local_service_port(self, shuffle_notifications, health,
populate, scheduler, notifications, populate, scheduler, notifications,
multiprocessing, neutron_api): multiprocessing, neutron_api):
@ -70,7 +70,7 @@ class TestMainPippo(base.RugTestBase):
neutron = neutron_api.Neutron.return_value neutron = neutron_api.Neutron.return_value
neutron.ensure_local_service_port.assert_called_once_with() neutron.ensure_local_service_port.assert_called_once_with()
@mock.patch('akanda.rug.main.shuffle_notifications') @mock.patch('astara.main.shuffle_notifications')
def test_ceilometer_disabled(self, shuffle_notifications, health, def test_ceilometer_disabled(self, shuffle_notifications, health,
populate, scheduler, notifications, populate, scheduler, notifications,
multiprocessing, neutron_api): multiprocessing, neutron_api):
@ -82,7 +82,7 @@ class TestMainPippo(base.RugTestBase):
self.assertEqual(len(notifications.Publisher.mock_calls), 0) self.assertEqual(len(notifications.Publisher.mock_calls), 0)
self.assertEqual(len(notifications.NoopPublisher.mock_calls), 2) self.assertEqual(len(notifications.NoopPublisher.mock_calls), 2)
@mock.patch('akanda.rug.main.shuffle_notifications') @mock.patch('astara.main.shuffle_notifications')
def test_ceilometer_enabled(self, shuffle_notifications, health, def test_ceilometer_enabled(self, shuffle_notifications, health,
populate, scheduler, notifications, populate, scheduler, notifications,
multiprocessing, neutron_api): multiprocessing, neutron_api):
@ -95,15 +95,15 @@ class TestMainPippo(base.RugTestBase):
self.assertEqual(len(notifications.NoopPublisher.mock_calls), 0) self.assertEqual(len(notifications.NoopPublisher.mock_calls), 0)
@mock.patch('akanda.rug.api.neutron.importutils') @mock.patch('astara.api.neutron.importutils')
@mock.patch('akanda.rug.api.neutron.AkandaExtClientWrapper') @mock.patch('astara.api.neutron.AstaraExtClientWrapper')
@mock.patch('akanda.rug.main.multiprocessing') @mock.patch('astara.main.multiprocessing')
@mock.patch('akanda.rug.main.notifications') @mock.patch('astara.main.notifications')
@mock.patch('akanda.rug.main.scheduler') @mock.patch('astara.main.scheduler')
@mock.patch('akanda.rug.main.populate') @mock.patch('astara.main.populate')
@mock.patch('akanda.rug.main.health') @mock.patch('astara.main.health')
@mock.patch('akanda.rug.main.shuffle_notifications') @mock.patch('astara.main.shuffle_notifications')
@mock.patch('akanda.rug.api.neutron.get_local_service_ip') @mock.patch('astara.api.neutron.get_local_service_ip')
class TestMainExtPortBinding(base.RugTestBase): class TestMainExtPortBinding(base.RugTestBase):
@testtools.skipIf( @testtools.skipIf(
@ -113,17 +113,17 @@ class TestMainExtPortBinding(base.RugTestBase):
def test_ensure_local_port_host_binding( def test_ensure_local_port_host_binding(
self, get_local_service_ip, shuffle_notifications, health, self, get_local_service_ip, shuffle_notifications, health,
populate, scheduler, notifications, multiprocessing, populate, scheduler, notifications, multiprocessing,
akanda_wrapper, importutils): astara_wrapper, importutils):
self.test_config.config(plug_external_port=False) self.test_config.config(plug_external_port=False)
def side_effect(**kwarg): def side_effect(**kwarg):
return {'ports': {}} return {'ports': {}}
akanda_wrapper.return_value.list_ports.side_effect = side_effect astara_wrapper.return_value.list_ports.side_effect = side_effect
main.main(argv=self.argv) main.main(argv=self.argv)
args, kwargs = akanda_wrapper.return_value.create_port.call_args args, kwargs = astara_wrapper.return_value.create_port.call_args
port = args[0]['port'] port = args[0]['port']
self.assertIn('binding:host_id', port) self.assertIn('binding:host_id', port)
self.assertEqual(port['binding:host_id'], socket.gethostname()) self.assertEqual(port['binding:host_id'], socket.gethostname())

Some files were not shown because too many files have changed in this diff Show More