def merge_model_and_existing_properties(model_props, existing_props, string_props_separator_char=','): """ Merge the two properties objects so that the resulting properties contains all of the elements in both properties. :param model_props: the model properties :param existing_props: the existing properties :param string_props_separator_char: the property delimiter :return: the merged properties object as a java.util.Properties or a string, depending on the type of the model_props :raises: DeployException: if either properties is not either a string or a java.util.Properties object """ _method_name = 'merge_model_and_existing_lists' _logger.entering(model_props, existing_props, string_props_separator_char, class_name=_class_name, method_name=_method_name) if existing_props is None or len(existing_props) == 0: result = model_props elif model_props is None or len(model_props) == 0: result = existing_props if isinstance(model_props, basestring) and isinstance(existing_props, basestring): result = _properties_to_string(existing_props, string_props_separator_char) else: model_props_is_string = False if type(model_props) is str: model_props_is_string = True model_properties = _string_to_properties(model_props, string_props_separator_char) elif TypeUtils.isInstanceOfClass(Properties().getClass(), model_props): model_properties = model_props else: ex = exception_helper.create_deploy_exception('WLSDPLY-08002', str(type(model_props))) _logger.throwing(ex, class_name=_class_name, method_name=_method_name) raise ex if type(existing_props) is str: existing_properties = _string_to_properties(existing_props, string_props_separator_char) elif TypeUtils.isInstanceOfClass(Properties().getClass(), existing_props): existing_properties = existing_props else: ex = exception_helper.create_deploy_exception('WLSDPLY-08003', str(type(existing_props))) _logger.throwing(ex, class_name=_class_name, method_name=_method_name) raise ex for entry_set in model_properties.entrySet(): key = entry_set.getKey() value = entry_set.getValue() existing_properties.setProperty(key, value) if model_props_is_string: result = _properties_to_string(existing_properties, string_props_separator_char) else: result = existing_properties _logger.exiting(class_name=_class_name, method_name=_method_name, result=result) return result
def set_wldf_action_mbeans(self, location, key, value, wlst_value): """ Set the WLDF Action/Notification MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the WLDF Action/Notification is not found """ watch_location = self.__get_parent_location(location, WATCH_NOTIFICATION) action_names = TypeUtils.convertToType(List, value) # type: list of str action_names = self.__merge_existing_items(action_names, wlst_value) action_mbeans = [] for action_name in action_names: action_mbean = self.__find_wldf_action(watch_location, action_name) action_mbeans.append(action_mbean) if self.__wlst_mode == WlstModes.ONLINE: # for online, call the current location's add method for each action mbean location_mbean = self.__wlst_helper.cd(self.__wlst_helper.get_pwd()) for action_mbean in action_mbeans: location_mbean.addNotification(action_mbean) else: self.set_attribute(location, key, action_mbeans, wlst_merge_value=wlst_value, use_raw_value=True) return
def convert_to_type(data_type, value, subtype=None, delimiter=None): """ Convert the value to the specified type. :param data_type: the type :param value: the value :param subtype: optional subtype for jarray type :param delimiter: optional delimiter to use for parsing :return: the value converted to the specified type """ _method_name = 'convert_to_type' # # TypeUtils.convertToType doesn't work for passwords... # if value is not None and data_type == 'password': # The password is an array of bytes coming back from the WLST get() method and only # java.lang.String() is able to properly convert it to the cipher text string. However, # we don't really want to return a java.lang.String to the caller so convert that Java # String back to a Python string...ugly but effective. new_value = str(String(value)) else: try: new_value = TypeUtils.convertToType(data_type, value, delimiter) except NumberFormatException, nfe: ex = exception_helper.create_alias_exception('WLSDPLY-08021', value, data_type, delimiter, nfe.getLocalizedMessage(), error=nfe) _logger.throwing(ex, class_name=_class_name, method_name=_method_name) raise ex if new_value is not None: try: if data_type == LONG: new_value = Long(new_value) elif data_type == JAVA_LANG_BOOLEAN: new_value = Boolean(new_value) elif data_type == JARRAY: if subtype is None or subtype == 'java.lang.String': new_value = _create_string_jarray(new_value) else: new_value = _create_mbean_array(new_value, subtype) elif data_type == LIST: new_value = list(new_value) elif data_type in ALIAS_DELIMITED_TYPES: # # This code intentionally ignores the delimiter value passed in and computes it from the data type. # This is required to handle the special case where the value we read from WLST might have a # different delimiter than the model value. In this use case, the value passed into the method # is the WLST value delimiter and the data_type is the preferred_model_type, so we compute the # model delimiter from the data_type directly. # delimiter = compute_delimiter_from_data_type(data_type, new_value) new_value = delimiter.join(new_value) except TypeError, te: ex = exception_helper.create_alias_exception('WLSDPLY-08021', value, data_type, delimiter, te) _logger.throwing(ex, class_name=_class_name, method_name=_method_name) raise ex
def _get_local_users(self, mapping_type, mapping_name, mapping): """ Get the local users list, based on the mapping element from the model. :param mapping_type: the type of the mapping, such as 'CrossDomain' :param mapping_name: the mapping name from the model, such as 'map1' :param mapping: the mapping element from the model :return: a list of local users """ if mapping_type == CROSS_DOMAIN: return [CROSS_DOMAIN_USER] local_user_value = self._get_required_attribute( mapping, USER, mapping_type, mapping_name) return TypeUtils.convertToType(list, local_user_value)
def _convert_value_to_model_type(data_type, value, delimiter): """ Convert WLST value to model representation type. Assumes that empty values and password data types have been converted elsewhere. :param data_type: the target data type for the model :param value: value to be converted :param delimiter: the delimiter for parsing the WLST representation of the data value (optional) :return: converted value """ _method_name = '_convert_value_to_model_type' try: converted = TypeUtils.convertToType(data_type, value, delimiter) except NumberFormatException, nfe: ex = exception_helper.create_alias_exception('WLSDPLY-08021', value, data_type, delimiter, nfe.getLocalizedMessage(), error=nfe) _logger.throwing(ex, class_name=_class_name, method_name=_method_name) raise ex
def __build_server_mbean_list(self, value, wlst_value): """ Construct the server MBean list. :param value: the value :param wlst_value: the existing value from WLST :return: the Java array of MBeans ObjectNames :raises BundleAwareException of the specified type: if an error occurs """ server_names = TypeUtils.convertToType(List, value) # type: list of str server_names = self.__merge_existing_items(server_names, wlst_value) name_list = [] for server_name in server_names: mbean = self.__find_in_location(LocationContext(), SERVER, server_name, required=True) name_list.append(mbean.getObjectName()) return jarray.array(name_list, ObjectName)
def __merge_existing_items(self, items, existing_value): """ Merge the specified items with the items represented by existing value, and return the result. :param items: the attribute name :param existing_value: the value representing the existing items (may be a string or list) :return: the merged list of items :raises BundleAwareException of the specified type: if the WLDF Action/Notification is not found """ _method_name = '__merge_existing_items' self.__logger.entering(str(items), str(existing_value), class_name=self._class_name, method_name=_method_name) existing_items = TypeUtils.convertToType(List, existing_value) # type: list of str no_existing_items = (existing_items is None) or (len(existing_items) == 0) if no_existing_items: result = items else: result = list(Set(items).union(Set(existing_items))) return result
def __build_target_mbean_list(self, target_value, wlst_value, location, include_jms=False): """ Construct the target MBean list. :param target_value: the target value :param wlst_value: the existing value from WLST :param include_jms: whether or not to include JMS targets, the default is False :return: the Java array of MBeans ObjectNames :raises BundleAwareException of the specified type: if an error occurs """ target_names = TypeUtils.convertToType(List, target_value) # type: list of str target_names = self.__merge_existing_items(target_names, wlst_value) name_list = [] for target_name in target_names: target_mbean = self.__find_target(target_name, location, include_jms=include_jms) name_list.append(target_mbean.getObjectName()) return jarray.array(name_list, ObjectName)
def __build_virtual_target_mbean_list(self, target_value, wlst_value): """ Construct the virtual target MBean list. :param target_value: the target value :param wlst_value: the existing value from WLST :return: for offline, a list of MBeans; for online, a jarray of MBean ObjectNames :raises BundleAwareException of the specified type: if an error occurs """ target_names = TypeUtils.convertToType(List, target_value) # type: list of str target_names = self.__merge_existing_items(target_names, wlst_value) if self.__wlst_mode == WlstModes.ONLINE: name_list = [] for target_name in target_names: target_mbean = self.__find_in_location(LocationContext(), VIRTUAL_TARGET, target_name, required=True) name_list.append(target_mbean.getObjectName()) return jarray.array(name_list, ObjectName) else: mbean_list = [] for target_name in target_names: target_mbean = self.__find_in_location(LocationContext(), VIRTUAL_TARGET, target_name, required=True) mbean_list.append(target_mbean) return mbean_list