def setUp(self):
super(self.__class__, self).setUp()
CONF.set_default("default_share_type", None)
self.flags(rpc_backend='manila.openstack.common.rpc.impl_fake')
self.share_api = share_api.API()
self.admin_context = context.RequestContext('admin', 'fake', True)
self.member_context = context.RequestContext('fake', 'fake')
def setUp(self):
super(ShareAdminActionsAPITest, self).setUp()
CONF.set_default("default_share_type", None)
self.flags(transport_url='rabbit://*****:*****@mqhost:5672')
self.share_api = share_api.API()
self.admin_context = context.RequestContext('admin', 'fake', True)
self.member_context = context.RequestContext('fake', 'fake')
def deny_rules_and_wait(self, context, share, saved_rules):
api = share_api.API()
# Deny each one.
for instance in share.instances:
for access in saved_rules:
api.deny_access_to_instance(context, instance, access)
# Wait for all rules to be cleared.
starttime = time.time()
deadline = starttime + self.migration_wait_access_rules_timeout
tries = 0
rules = self.db.share_access_get_all_for_share(context, share['id'])
while len(rules) > 0:
tries += 1
now = time.time()
if now > deadline:
msg = _("Timeout removing access rules from share "
"%(share_id)s. Timeout was %(timeout)s seconds.") % {
'share_id': share['id'],
'timeout': self.migration_wait_access_rules_timeout
}
raise exception.ShareMigrationFailed(reason=msg)
else:
time.sleep(tries**2)
rules = self.db.share_access_get_all_for_share(
context, share['id'])
def setUp(self):
super(AdminActionsTest, self).setUp()
self.tempdir = tempfile.mkdtemp()
self.flags(rpc_backend='manila.openstack.common.rpc.impl_fake')
self.flags(lock_path=self.tempdir)
self.share_api = share_api.API()
self.admin_context = context.RequestContext('admin', 'fake', True)
self.member_context = context.RequestContext('fake', 'fake')
def __init__(self, context, db, create_delete_timeout, access_rule_timeout,
share):
self.db = db
self.share = share
self.context = context
self.api = share_api.API()
self.migration_create_delete_share_timeout = create_delete_timeout
self.migration_wait_access_rules_timeout = access_rule_timeout
def translate_transitional_statuses(self, context, access_dict, access):
"""In 2.28, the per access rule status was (re)introduced."""
api = share_api.API()
share = api.get(context, access['share_id'])
if (share['access_rules_status'] ==
constants.SHARE_INSTANCE_RULES_SYNCING):
access_dict['state'] = constants.STATUS_NEW
else:
access_dict['state'] = share['access_rules_status']
def __init__(self, context, db, access_helper):
self.db = db
self.context = context
self.access_helper = access_helper
self.api = share_api.API()
self.access_helper = access_helper
self.migration_create_delete_share_timeout = (
CONF.migration_create_delete_share_timeout)
self.migration_wait_access_rules_timeout = (
CONF.migration_wait_access_rules_timeout)
def __init__(self, *args, **kwargs):
super(MapRFSNativeShareDriver, self).__init__(False, *args, **kwargs)
self.configuration.append_config_values(maprfs_native_share_opts)
self.backend_name = self.configuration.safe_get(
'share_backend_name') or 'MapR-FS-Native'
self._base_volume_dir = self.configuration.safe_get(
'maprfs_base_volume_dir') or '/'
self._maprfs_util = None
self._maprfs_base_path = "maprfs://"
self.cldb_ip = self.configuration.maprfs_cldb_ip or []
self.zookeeper_ip = self.configuration.maprfs_zookeeper_ip or []
self.rename_volume = self.configuration.maprfs_rename_managed_volume
self.api = api.API()
def setUp(self):
super(ShareMetaDataTest, self).setUp()
self.share_api = api.API()
self.share_controller = shares.ShareController()
self.controller = share_metadata.ShareMetadataController()
self.ctxt = context.RequestContext('admin', 'fake', True)
self.origin_metadata = {
"key1": "value1",
"key2": "value2",
"key3": "value3",
}
self.share = db.share_create(self.ctxt, {})
self.share_id = self.share['id']
self.url = '/shares/%s/metadata' % self.share_id
db.share_metadata_update(
self.ctxt, self.share_id, self.origin_metadata, delete=False)
def __init__(self, *args, **kwargs):
"""Do initialization."""
super(ZadaraVPSAShareDriver, self).__init__(False, *args, **kwargs)
self.vpsa = None
self.configuration.append_config_values(common.zadara_opts)
self.configuration.append_config_values(manila_opts)
self.api = api.API()
# The valid list of share options that can be specified
# as the metadata while creating manila share
self.share_options = [
'smbguest', 'smbonly', 'smbwindowsacl', 'smbfilecreatemask',
'smbbrowseable', 'smbhiddenfiles', 'smbhideunreadable',
'smbhideunwriteable', 'smbhidedotfiles', 'smbstoredosattributes',
'smbdircreatemask', 'smbmaparchive', 'smbencryptionmode',
'smbenableoplocks', 'smbaiosize', 'nfsrootsquash', 'nfsallsquash',
'nfsanongid', 'nfsanonuid', 'atimeupdate', 'readaheadkb', 'crypt',
'compress', 'dedupe', 'attachpolicies'
]
def __init__(self, *args, **kwargs):
super(EosDriver, self).__init__(False,
*args,
config_opts=[eos_opts],
**kwargs)
self.api = api.API()
self.backend_name = self.configuration.safe_get(
'share_backend_name') or 'EOS'
self.configuration.append_config_values(eos_opts)
channel = grpc.insecure_channel('ajp.cern.ch:50051')
#channel = grpc.insecure_channel('localhost:50051')
self.grpc_client = eos_pb2_grpc.EosStub(channel)
self.conn = openstack.connect(
auth_url='http://188.185.71.204/identity/v3',
username='******',
password='******',
project_name='admin',
project_domain_id='default',
user_domain_id='default')
def create_instance_and_wait(self, context, share, share_instance, host):
api = share_api.API()
new_share_instance = api.create_instance(
context, share, share_instance['share_network_id'], host['host'])
# Wait for new_share_instance to become ready
starttime = time.time()
deadline = starttime + self.migration_create_delete_share_timeout
new_share_instance = self.db.share_instance_get(
context, new_share_instance['id'], with_share_data=True)
tries = 0
while new_share_instance['status'] != constants.STATUS_AVAILABLE:
tries += 1
now = time.time()
if new_share_instance['status'] == constants.STATUS_ERROR:
msg = _("Failed to create new share instance"
" (from %(share_id)s) on "
"destination host %(host_name)s") % {
'share_id': share['id'],
'host_name': host['host']
}
raise exception.ShareMigrationFailed(reason=msg)
elif now > deadline:
msg = _("Timeout creating new share instance "
"(from %(share_id)s) on "
"destination host %(host_name)s") % {
'share_id': share['id'],
'host_name': host['host']
}
raise exception.ShareMigrationFailed(reason=msg)
else:
time.sleep(tries**2)
new_share_instance = self.db.share_instance_get(
context, new_share_instance['id'], with_share_data=True)
return new_share_instance
def __init__(self):
self.share_api = api.API()
def deny_rules_and_wait(self, context, share, saved_rules):
api = share_api.API()
api.deny_access_to_instance(context, share.instance, saved_rules)
self.wait_for_access_update(share.instance)
class ZaqarNotification(hook.HookBase):
share_api = api.API()
def _access_changed_trigger(self, context, func_name, access_rules_ids,
share_instance_id):
access = [
self.db.share_access_get(context, rule_id)
for rule_id in access_rules_ids
]
share_instance = self.db.share_instance_get(context, share_instance_id)
share = self.share_api.get(context, share_id=share_instance.share_id)
def rules_view(rules):
result = []
for rule in rules:
access_instance = None
for ins in rule.instance_mappings:
if ins.share_instance_id == share_instance_id:
access_instance = ins
break
else:
raise exception.InstanceNotFound(
instance_id=share_instance_id)
result.append({
'access_id': rule.id,
'access_instance_id': access_instance.id,
'access_type': rule.access_type,
'access_to': rule.access_to,
'access_level': rule.access_level,
})
return result
is_allow_operation = 'allow' in func_name
results = {
'share_id': share.share_id,
'share_instance_id': share_instance_id,
'export_locations':
[el.path for el in share_instance.export_locations],
'share_proto': share.share_proto,
'access_rules': rules_view(access),
'is_allow_operation': is_allow_operation,
'availability_zone': share_instance.availability_zone,
}
LOG.debug(results)
return results
def _execute_pre_hook(self, context, func_name, *args, **kwargs):
LOG.debug("\n PRE zaqar notification has been called for "
"method '%s'.\n" % func_name)
if func_name == "deny_access":
LOG.debug("\nSending notification about denied access.\n")
data = self._access_changed_trigger(
context,
func_name,
kwargs.get('access_rules'),
kwargs.get('share_instance_id'),
)
self._send_notification(data)
def _execute_post_hook(self, context, func_name, pre_hook_data,
driver_action_results, *args, **kwargs):
LOG.debug("\n POST zaqar notification has been called for "
"method '%s'.\n" % func_name)
if func_name == "allow_access":
LOG.debug("\nSending notification about allowed access.\n")
data = self._access_changed_trigger(
context,
func_name,
kwargs.get('access_rules'),
kwargs.get('share_instance_id'),
)
self._send_notification(data)
def _send_notification(self, data):
for queue_name in CONF.zaqar.zaqar_queues:
ZAQARCLIENT.queue_name = queue_name
message = {
"body": {
"example_message":
("message generated at '%s'" % timeutils.utcnow()),
"data":
data,
}
}
LOG.debug(
"\n Sending message %(m)s to '%(q)s' queue using '%(u)s' user "
"and '%(p)s' project." % {
'm': message,
'q': queue_name,
'u': CONF.zaqar.zaqar_username,
'p': CONF.zaqar.zaqar_project_name,
})
queue = ZAQARCLIENT.queue(queue_name)
queue.post(message)
def _execute_periodic_hook(self, context, periodic_hook_data, *args,
**kwargs):
LOG.debug("Periodic zaqar notification has been called. (Placeholder)")
