def _get_init_replication_param(replicate_from=None):
params = Object()
params._classname = 'SetReplicationParam' # pylint: disable=protected-access
if replicate_from:
params.enabledReplicationParam = Object()
params.enabledReplicationParam._classname = 'EnabledReplicationParam' # pylint: disable=protected-access
params.enabledReplicationParam.replicationOf = replicate_from
params.enabledReplicationParam.restartDB = True
return params
def _get_services_connection_status(self):
param = Object()
param.connection = Object()
param.connected = True
param.ipaddr = self._ip_address
param.user = self._user_display_name
param.server_version = self._portal_version
param.server_address = self._server_address
param.last_connected_at = self._last_connnected_at
return param
def _get_create_folder_response(rc,
shared_secret=None,
passphrase_salt=None):
task = Object()
task.result = Object()
task.result.createFolderRC = rc
if shared_secret:
task.result.sharedSecret = shared_secret
if passphrase_salt:
task.result.passPhraseSalt = passphrase_salt
return task
def _get_services_status_response(self):
status = Object()
status.CTERAPortal = Object()
status.CTERAPortal.connectionState = ServicesConnectionState.Connected
status.CTERAPortal.connectedAddress = self._ip_address
status.userDisplayName = self._user_display_name
status.portalVersion = self._portal_version
server = Object()
server.name = self._server_address
status.CTERAPortal.serverList = [server]
status.CTERAPortal.establishedTime = self._last_connnected_at
return status
def _get_mail_server_config(self, port=25, username=None, password=None, use_tls=True):
mail_param = Object()
mail_param.useCustomServer = True
mail_param.SMTPServer = self._smtp_server
mail_param.port = port
if username is not None and password is not None:
mail_param.useAuth = True
mail_param.auth = Object()
mail_param.auth.username = username
mail_param.auth.password = password
mail_param.useTLS = use_tls
return mail_param
def _create_action_resource_param(self, sources, destinations=None):
action_resource_param = Object()
action_resource_param._classname = 'ActionResourcesParam' # pylint: disable=protected-access
action_resource_param.urls = []
for idx, source in enumerate(sources):
param = Object()
param._classname = 'SrcDstParam' # pylint: disable=protected-access
param.src = self._services.file_browser_base_path + '/' + source
if destinations:
param.dest = self._services.file_browser_base_path + '/' + destinations[idx]
else:
param.dest = None
action_resource_param.urls.append(param)
return action_resource_param
def default_settings():
settings = Object()
settings._classname = 'SystemSettings' # pylint: disable=protected-access
settings.smtpSettings = Object()
settings.smtpSettings._classname = 'SMTPSettings' # pylint: disable=protected-access
settings.smtpSettings.smtpHost = 'your.mail.server'
settings.smtpSettings.smtpPort = 25
settings.smtpSettings.enableTls = False
settings.defaultPortalSettings = Object()
settings.defaultPortalSettings._classname = 'PortalSettings' # pylint: disable=protected-access
settings.defaultPortalSettings.mailSettings = Object()
settings.defaultPortalSettings.mailSettings._classname = 'MailSettings' # pylint: disable=protected-access
settings.defaultPortalSettings.mailSettings.sender = '*****@*****.**'
return settings
def _get_init_portal_param(self):
params = Object()
params._classname = 'InitParams' # pylint: disable=protected-access
params.admin = Object()
params.admin._classname = 'PortalAdmin' # pylint: disable=protected-access
params.admin.name = self._admin_username
params.admin.email = self._admin_email
params.admin.firstName = self._admin_first_name
params.admin.lastName = self._admin_last_name
params.admin.password = self._admin_password
params.settings = TestCoreSetup.default_settings()
params.settings.dnsSuffix = self._domain
return params
def _create_public_link_param(self, access_mode, expire_in):
param = Object()
param._classname = 'CreateShareParam' # pylint: disable=protected-access
param.url = self._services.file_browser_base_path + '/' + self._path
param.share = Object()
param.share._classname = 'ShareConfig' # pylint: disable=protected-access
param.share.accessMode = access_mode
param.share.protectionLevel = 'publicLink'
param.share.expiration = (
datetime.date.today() +
datetime.timedelta(days=expire_in)).strftime('%Y-%m-%d')
param.share.invitee = Object()
param.share.invitee._classname = 'Collaborator' # pylint: disable=protected-access
param.share.invitee.type = 'external'
return param
def _get_pending_mount_task(mount_id=None, name=None):
param = Object()
if mount_id:
param.id = mount_id
if name:
param.name = name
return param
def _get_query_portals_response(execute_path, execute_name, execute_param):
# pylint: disable=unused-argument
query_response = Object()
tenants = None
if execute_param.startFrom == 0:
query_response.hasMore = True
tenants = TestCorePortals._tenants_first_page
else:
query_response.hasMore = False
tenants = TestCorePortals._tenants_second_page
query_response.objects = []
for tenant in tenants:
tenant_param = Object()
tenant_param.name = tenant
query_response.objects.append(tenant_param)
return query_response
def test_modify_smb_disabled_raise(self):
param = Object()
param.mode = Mode.Disabled
self._init_filer(get_response=param)
with self.assertRaises(exception.CTERAException) as error:
smb.SMB(self._filer).modify(CIFSPacketSigning.Required)
self.assertEqual('SMB must be enabled in order to modify its configuration', error.exception.message)
def test_modify_raise(self):
param = Object()
param.mode = Mode.Disabled
self._init_filer(get_response=param)
with self.assertRaises(exception.CTERAException) as error:
ftp.FTP(self._filer).modify()
self.assertEqual('FTP must be enabled in order to modify its configuration', error.exception.message)
def _get_mkdir_object(self, winacls=True):
mkdir_param_object = Object()
mkdir_param_object.name = self._name
mkdir_param_object.owner = self._owner
mkdir_param_object.group = self._group
mkdir_param_object.enableSyncWinNtExtendedAttributes = winacls
return mkdir_param_object
def _create_filter(filter_type, field, restriction, value):
query_filter = Object()
query_filter._classname = filter_type # pylint: disable=protected-access
query_filter.field = field
query_filter.restriction = restriction
query_filter.value = value
return query_filter
def _get_cifs_object(self, enable_aio):
robust_mutexes, aio_read_threshold, aio_write_threshold = self._enable_aio if enable_aio else self._disable_aio
cifs_param = Object()
cifs_param.robustMutexes = robust_mutexes
cifs_param.aioReadThreshold = aio_read_threshold
cifs_param.aioWriteThreshold = aio_write_threshold
return cifs_param
def _get_share_object(
self,
directory=None,
volume=None,
acl=None, # pylint: disable=too-many-arguments
access=None,
csc=None,
dir_permissions=None,
comment=None,
export_to_afp=False,
export_to_ftp=False,
export_to_nfs=False,
export_to_pc_agent=False,
export_to_rsync=False,
indexed=False):
share_param = Object()
share_param.name = self._share_name
share_param.directory = self._share_directory if directory is None else directory
share_param.volume = self._share_volume if volume is None else volume
share_param.acl = None if acl is None else acl
share_param.access = Acl.WindowsNT if access is None else access
share_param.csc = ClientSideCaching.Manual if csc is None else csc
share_param.dirPermissions = 777 if dir_permissions is None else dir_permissions
share_param.comment = None if comment is None else comment
share_param.exportToAFP = False if export_to_afp is None else export_to_afp
share_param.exportToFTP = False if export_to_ftp is None else export_to_ftp
share_param.exportToNFS = False if export_to_nfs is None else export_to_nfs
share_param.exportToPCAgent = False if export_to_pc_agent is None else export_to_pc_agent
share_param.exportToRSync = False if export_to_rsync is None else export_to_rsync
share_param.indexed = False if indexed is None else indexed
return share_param
def test_device_notfound(self):
o = Object()
o.name = None
self._init_global_admin(get_multi_response=o)
with self.assertRaises(exception.CTERAException) as error:
devices.Devices(self._global_admin).device(o.name)
self.assertEqual('Device not found', error.exception.message)
def _find_cloud_folder(folder_name, folder_owner, include):
# pylint: disable=unused-argument
folder_info = TestCoreZones._cloud_folders[folder_owner][folder_name]
param = Object()
param.uid = folder_info['uid']
param.owner = folder_info['owner']
return param
def _get_nfs_configuration_response(async_write=True,
aggregate_writes=True):
obj = Object()
obj.mode = Mode.Enabled
setattr(obj, 'async', Mode.Enabled if async_write else Mode.Disabled)
obj.aggregateWrites = Mode.Enabled if aggregate_writes else Mode.Disabled
return obj
def _get_volumes_response_param(self):
storage_volumes = []
for volume_name in self._volumes:
param = Object()
param.name = volume_name
storage_volumes.append(param)
return storage_volumes
def _get_device_objects(self):
devices = []
for device_id in self._device_ids:
param = Object()
param.uid = device_id
devices.append(param)
return devices
def _get_domain_join_param(self, ou=None):
o = Object()
o.username = self._username
o.password = self._password
if ou is not None:
o.ouPath = ou
return o
def _get_default_backup_settings(encryption_mode=None,
shared_secret=None,
passphrase_salt=None):
param = Object()
param.encryptionMode = encryption_mode
param.sharedSecret = shared_secret
param.passPhraseSalt = passphrase_salt
return param
def _get_user_object(self, full_name=None, email=None, uid=None):
o = Object()
o.username = self._username
o.password = self._password
o.fullName = full_name
o.email = email
o.uid = uid
return o
def _get_create_folder_param(passphrase=None):
param = Object()
if passphrase:
param.encryptionMode = backup.EncryptionMode.Secret
param.sharedSecret = passphrase
else:
param.encryptionMode = backup.EncryptionMode.Recoverable
return param
def _get_attach_response(rc,
encryption_mode=None,
shared_secret=None,
passphrase_salt=None,
encrypted_folder_key=None):
task = Object()
task.result = Object()
task.result.attachFolderRC = rc
if encryption_mode:
task.result.encryptionMode = encryption_mode
if shared_secret:
task.result.sharedSecret = shared_secret
if passphrase_salt:
task.result.passPhraseSalt = passphrase_salt
if encrypted_folder_key:
task.result.encryptedFolderKey = encrypted_folder_key
return task
def _fetch_resources_param(root, start):
param = Object()
param._classname = 'FetchResourcesParam' # pylint: disable=protected-access
param.root = BaseCoreServicesFilesList.basepath + '/' + root
param.depth = 1
param.start = start
param.limit = 100
return param
def _get_dir_entry(self, name, include):
param = Object()
param._classname = 'DirEntry' # pylint: disable=protected-access
param.name = name
param.children = None
param.displayName = self._display_name
param.isIncluded = include
return param
def _get_init_server_params(mode,
authentication_method=None,
master_ipaddr=None,
master_secret=None):
params = Object()
params._classname = 'InitServerParams' # pylint: disable=protected-access
params.serverMode = mode
if mode == ServerMode.Slave:
params.slaveSettings = Object()
params.slaveSettings._classname = 'SlaveServerSettings' # pylint: disable=protected-access
if master_ipaddr:
params.slaveSettings.masterIpAddr = master_ipaddr
if authentication_method == SlaveAuthenticaionMethod.Password:
params.slaveSettings.masterPassword = master_secret
elif authentication_method == SlaveAuthenticaionMethod.PrivateKey:
params.slaveSettings.masterKey = master_secret
return params