def __init__(self, root, guid, name=None, mode=None, inline_data_writes=True, auto_flush_values=True,
bricking_scheme=None, brick_dispatcher=None, value_caching=True, coverage_type=None,
alignment_parameter=AxisTypeEnum.TIME.lower(), storage_name=None, **kwargs):
"""
Constructor for PersistenceLayer
@param root The <root> component of the filesystem path for the coverage (/<root>/<guid>)
@param guid The <guid> component of the filesystem path for the coverage (/<root>/<guid>)
@param name CoverageModel's name persisted to the metadata attribute in the master HDF5 file
@param auto_flush_values True = Values flushed to HDF5 files automatically, False = Manual
@param value_caching if True (default), value requests should be cached for rapid duplicate retrieval
@param kwargs
@return None
"""
log.debug('Persistence GUID: %s', guid)
root = '.' if root is ('' or None) else root
self.brick_dispatcher=brick_dispatcher
self.bricking_scheme=bricking_scheme
self.master_manager = MetadataManagerFactory.buildMetadataManager(root, guid, name=name, parameter_bounds=None, coverage_type=coverage_type, **kwargs)
self.mode = mode
if not hasattr(self.master_manager, 'auto_flush_values'):
self.master_manager.auto_flush_values = auto_flush_values
if not hasattr(self.master_manager, 'inline_data_writes'):
self.master_manager.inline_data_writes = inline_data_writes
if not hasattr(self.master_manager, 'value_caching'):
self.master_manager.value_caching = value_caching
if not hasattr(self.master_manager, 'coverage_type'):
self.master_manager.coverage_type = coverage_type
if not hasattr(self.master_manager, 'parameter_metadata'):
self.master_manager.parameter_metadata = {}
self.value_list = {}
self.spans = {}
self.span_list = []
self.storage_name = storage_name
for pname in self.param_groups:
log.debug('parameter group: %s', pname)
if pname not in self.master_manager.parameter_metadata:
self.master_manager.parameter_metadata[pname] = MetadataManagerFactory.buildParameterManager(os.path.join(self.root_dir, self.guid, pname), pname)
if self.mode != 'r':
if self.master_manager.is_dirty():
self.master_manager.flush()
self._closed = False
if isinstance(alignment_parameter, basestring):
self.alignment_parameter = alignment_parameter
else:
raise TypeError("alignment_parameter arg must implement %s. Found %s", (basestring.__name__, type(alignment_parameter).__name__))
log.debug('Persistence Layer Successfully Initialized')
def init_parameter(self, parameter_context, bricking_scheme):
"""
Initializes a parameter using a ParameterContext object and a bricking
scheme for that parameter
@param parameter_context ParameterContext object describing the parameter to initialize
@param bricking_scheme A dictionary containing the brick and chunk sizes
@return A PersistedStorage object
"""
if self.mode == 'r':
raise IOError('PersistenceLayer not open for writing: mode == \'{0}\''.format(self.mode))
parameter_name = parameter_context.name
pm = MetadataManagerFactory.buildParameterManager(self.guid, parameter_name, read_only=False)
self.master_manager.parameter_metadata[parameter_name] = pm
pm.parameter_context = parameter_context
log.debug('Initialize %s', parameter_name)
self.master_manager.create_group(parameter_name)
v = PostgresPersistedStorage(pm, metadata_manager=self.master_manager,
parameter_context=parameter_context,
dtype=parameter_context.param_type.storage_encoding,
fill_value=parameter_context.param_type.fill_value,
mode=self.mode)
self.value_list[parameter_name] = v
# CBM TODO: Consider making this optional and bulk-flushing from the coverage after all parameters have been initialized
# No need to check if they're dirty, we know they are!
pm.flush()
# Put the pm into read_only mode
pm.read_only = True
self.master_manager.flush()
return v
