def test_constructor_with_default(self):
d = Datafile('/path/to/dbf', '0.5K')
self.assertEqual('/path/to/dbf', d.path)
self.assertEqual(512, d.size.size)
self.assertFalse(d.autoextend)
self.assertIsNone(d.nextsize)
self.assertIsNone(d.maxsize)
def get_existing_datafiles(tablespace):
"""Search for all existing datafiles for a specific tablespace"""
sql = "select df.file_name, df.bytes, df.autoextensible, df.increment_by * ts.block_size, df.maxbytes," \
" ts.bigfile, ts.block_size" \
" from dba_tablespaces ts, dba_data_files df" \
" where ts.tablespace_name = :tn" \
" and ts.tablespace_name = df.tablespace_name" \
" union all " \
"select df.file_name, df.bytes, df.autoextensible, df.increment_by * ts.block_size, df.maxbytes," \
" ts.bigfile, ts.block_size" \
" from dba_tablespaces ts, dba_temp_files df" \
" where ts.tablespace_name = :tn" \
" and ts.tablespace_name = df.tablespace_name"
params = {'tn': tablespace}
rows = ora_db.execute_select(sql, params)
datafiles = []
for row in rows:
datafiles.append(
Datafile(path=row[0],
size=row[1],
autoextend=row[2] == 'YES',
nextsize=row[3],
maxsize=row[4],
bigfile=row[5] == 'YES',
block_size=row[6]))
diff['before']['datafiles'] = [datafile.asdict() for datafile in datafiles]
return datafiles
def test_constructor_with_value(self):
d = Datafile('/path/to/dbf', '0.5K', True, '1M', 'unlimited', False, 16384)
self.assertEqual('/path/to/dbf', d.path)
self.assertEqual('512', str(d.size))
self.assertTrue(d.autoextend)
self.assertEqual('1M', str(d.nextsize))
self.assertEqual('unlimited', str(d.maxsize))
self.assertEqual(16384, d.block_size)
def test_as_dict(self):
d = Datafile('/path/to/dbf', 512, False)
self.assertDictEqual({'path': '/path/to/dbf', 'size': '512', 'autoextend': False}, d.asdict())
d = Datafile('/path/to/dbf', 512, True)
self.assertDictEqual({'path': '/path/to/dbf', 'size': '512', 'autoextend': True}, d.asdict())
d = Datafile('/path/to/dbf', 512, True, '1M', '10M')
self.assertDictEqual(
{'path': '/path/to/dbf', 'size': '512', 'autoextend': True, 'nextsize': '1M', 'maxsize': '10M'},
d.asdict())
def main():
global module
global ora_db
global diff
module = AnsibleModule(
argument_spec=dict(
autoextend=dict(type='bool', default=False),
bigfile=dict(type='bool', default=False),
content=dict(type='str',
default='permanent',
choices=['permanent', 'temp', 'undo']),
datafiles=dict(type='list',
elements='str',
default=[],
aliases=['datafile', 'df']),
default=dict(type='bool', default=False),
hostname=dict(type='str', default='localhost'),
maxsize=dict(type='str', required=False, aliases=['max']),
mode=dict(type='str',
default='normal',
choices=['normal', 'sysdba']),
oracle_home=dict(type='str', required=False),
nextsize=dict(type='str', required=False, aliases=['next']),
password=dict(type='str', required=False, no_log=True),
port=dict(type='int', default=1521),
read_only=dict(type='bool', default=False),
service_name=dict(type='str', required=True),
size=dict(type='str', required=False),
state=dict(type='str',
default='present',
choices=['present', 'online', 'offline', 'absent']),
tablespace=dict(type='str', required=True, aliases=['name', 'ts']),
username=dict(type='str', required=False, aliases=['user']),
),
required_together=[['username', 'password']],
required_if=[['state', 'present', ['size']],
['state', 'online', ['size']],
['state', 'offline', ['size']]],
supports_check_mode=True,
)
autoextend = module.params['autoextend']
bigfile = module.params['bigfile']
content = module.params['content']
datafile_names = module.params['datafiles']
default = module.params['default']
maxsize = module.params['maxsize']
nextsize = module.params['nextsize']
read_only = module.params['read_only']
size = module.params['size']
state = module.params['state']
tablespace = module.params['tablespace']
# Transforming parameters
tablespace = tablespace.upper()
if state == 'present': # Present is synonymous for online.
state = 'online'
datafiles = []
for datafile_name in datafile_names:
datafile = Datafile(datafile_name, size, autoextend, nextsize, maxsize,
bigfile)
datafiles.append(datafile)
file_type = FileType(bigfile)
content_type = ContentType(content)
ora_db = OraDB(module)
# Initializing diff
diff = {
'before': {
'tablespace': tablespace
},
'after': {
'tablespace': tablespace,
'state': state,
'read_only': read_only,
'bigfile': file_type.is_bigfile(),
'content': content_type.content,
'default': default,
}
}
# Doing actions
if state in ('online', 'offline'):
ensure_present(tablespace, state, read_only, datafiles, file_type,
content_type, default)
elif state == 'absent':
ensure_absent(tablespace)
def test_needs_change_autoextend(self):
new = Datafile('/path/to/dbf', 1024, True)
prev = Datafile('/path/to/dbf', 512, False)
self.assertTrue(new.needs_change_autoextend(prev), 'from autoextend off to autoextend on')
new = Datafile('/path/to/dbf', 1024, False, '2M', '20M')
prev = Datafile('/path/to/dbf', 512, False, '1M', '10M')
self.assertFalse(new.needs_change_autoextend(prev), 'autoextend off, even if nextsize and maxsize change')
new = Datafile('/path/to/dbf', 512, False)
prev = Datafile('/path/to/dbf', 1024, True)
self.assertTrue(new.needs_change_autoextend(prev), 'from autoextend on to autoextend off')
new = Datafile('/path/to/dbf', 512, True, '1M', '20M')
prev = Datafile('/path/to/dbf', 1024, True, '1M', '10M')
self.assertTrue(new.needs_change_autoextend(prev), 'sizes change')
new = Datafile('/path/to/dbf', 512, True, '1M', '20M')
prev = Datafile('/path/to/dbf', 1024, True, '1M', '20M')
self.assertFalse(new.needs_change_autoextend(prev), 'same values')
new = Datafile('/path/to/dbf', 512, True, '1M', '34359721984', False)
prev = Datafile('/path/to/dbf', 1024, True, '1M', 'unlimited', False)
self.assertFalse(new.needs_change_autoextend(prev), '32G and unlimited are same value for small files')
new = Datafile('/path/to/dbf', 512, True, '1M', '34359721984', True)
prev = Datafile('/path/to/dbf', 1024, True, '1M', 'unlimited', True)
self.assertTrue(new.needs_change_autoextend(prev), '32G and unlimited are different values for big files')
def test_needs_resize(self):
new = Datafile('/path/to/dbf', 1024, True)
prev = Datafile('/path/to/dbf', 512)
self.assertFalse(new.needs_resize(prev), 'no need to resize because of autoextend')
new = Datafile('/path/to/dbf', 1024)
prev = Datafile('/path/to/dbf', 512)
self.assertTrue(new.needs_resize(prev), 'need to resize because new is bigger')
new = Datafile('/path/to/dbf', 512)
prev = Datafile('/path/to/dbf', 1024)
self.assertFalse(new.needs_resize(prev), 'no resize because new is smaller')
def test_data_file_clause(self):
d = Datafile('/path/to/dbf', 512, False)
self.assertEqual("'/path/to/dbf' size 512 reuse autoextend off", d.data_file_clause())
def test_file_specification_clause(self):
d = Datafile('/path/to/dbf', 512, False)
self.assertEqual('size 512 reuse autoextend off', d.file_specification_clause())
d = Datafile('/path/to/dbf', 1024, True)
self.assertEqual('size 1K reuse autoextend on', d.file_specification_clause())
def test_autoextend_clause(self):
d = Datafile('/path/to/dbf', 512, False)
self.assertEqual(' autoextend off', d.autoextend_clause())
d = Datafile('/path/to/dbf', 1024, False, '2M', '20M')
self.assertEqual(' autoextend off', d.autoextend_clause())
d = Datafile('/path/to/dbf', 1024, True)
self.assertEqual(' autoextend on', d.autoextend_clause())
d = Datafile('/path/to/dbf', 512, True, '1M', '20M')
self.assertEqual(' autoextend on next 1M maxsize 20M', d.autoextend_clause())