The Composed Attribute Plugin may be used to generate one or more values for a specified attribute from a combination of static text and the values of other attributes in the same entry. Values may be generated during an LDIF import or as entries are added or updated in the server.
The Composed Attribute Plugin component inherits from the Plugin
The properties supported by this managed object are as follows:
| Description | A description for this Plugin |
| Default Value | None |
| Allowed Values | A string |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
| Description | Indicates whether the plug-in is enabled for use. |
| Default Value | None |
| Allowed Values | true false |
| Multi-Valued | No |
| Required | Yes |
| Admin Action Required | None. Modification requires no further action |
| Description | The name or OID of the attribute type for which values are to be generated. |
| Default Value | None |
| Allowed Values | The name or OID of an attribute type defined in the server schema. |
| Multi-Valued | No |
| Required | Yes |
| Admin Action Required | None. Modification requires no further action |
| Description | Specifies a pattern for constructing the values to use for the target attribute type. By default, any text provided in the value-pattern is copied verbatim into the target value with the exception of attribute names embedded in '{}'s. Attributes are substituted using their value, e.g. {uid} will select the uid attribute from the entry and use that value in place of {uid} in the value-pattern. At most one attribute may be multivalued. If one attribute is multivalued then the target value will be multivalued with the same number of values minus any duplicates. For example a mapping of '{givenName} {sn}' would produce values ['Jim Smith', 'James Smith'] if givenName had values of ['Jim', 'James'] and sn had a value of 'Smith'. If the source entry has no value or if there are multiple multivalued attributes, the attribute value construction will fail. To include a '{' in the constructed value use '{{' in the value-pattern. Likewise, '}}' will result in '}' in the value pattern. Furthermore, a regular expression with a substitution pattern can be used to further manipulate an individual attribute value. The java.util.regex.Pattern and java.util.regex.Matcher classes are used to perform the substitution. The regular expression with replacement value uses this syntax '{attr-name:/regex/replacement/flags}'. 'attr-name' is an attribute name such as 'cn'. 'regex' is a regular expression using the syntax described in the java.util.regex.Pattern javadoc. The optional flags value can also be used to change how this regular expression is interpreted. 'replacement' is a replacement value that is passed to the java.util.regex.Matcher#replaceFirst or java.util.regex.Matcher#replaceAll method to perform the replacement. The 'g' (global) flag controls whether replaceFirst or replaceAll is called. 'flags' is an optional set of single character flags that control how the regular expression is interpreted and how the replacement is performed. The flags are:
Pattern pattern = Pattern.compile(regex, flagsMask); To extract JSON fields within JSON attributes append '.' and then the JSON field to extract to the attribute name. For example, if 'ubidEmailJSON' is a JSON attribute and the 'value' field is to be extracted then 'ubidEmailJSON.value' could be specified for the attribute name resulting in '{ubidEmailJSON.value}' or '{ubidEmailJSON.value:/regex/replacement/flags}' if a regular expression is to be used. In addition, a JSON object filter may be provided in parentheses after the JSON field name to indicate that the field value will only be extracted if the attribute value matches the provided filter. For example, if 'ubidEmailJSON' is a JSON attribute and the 'value' field is to be extracted only for values where the 'type' field is equal to 'work', then the value pattern that would specify this would be '{ubidEmailJSON.value({{"filterType":"equals","field":"type","value":"work"}})}' or '{ubidEmailJSON.value({{"filterType":"equals","field":"type","value":"work"}})}:/regex/replacement/flags' if a regular expression is to be used. Note that all instances of '{' and '}' need to be escaped as '{{' and '}}' within the constructed value including those in the JSON object filter. To apply modifiers to the values extracted append ':' and then the name of the modifier to apply. For example, if attribute 'mail' is to be included in a constructed JSON value then modifier 'jsonEscape' could be specified resulting in '{{ "userMail":"{mail:jsonEscape}" }}' or '{{ "userMail":"{mail:/regex/replacement/flags:jsonEscape}" }}' if a regular expression is to be used. Note that '{{' expands to '{' and '}}' to '}'. The modifiers are:
|
| Default Value | None |
| Allowed Values | The pattern to use to construct the attribute value. |
| Multi-Valued | Yes |
| Required | Yes |
| Admin Action Required | None. Modification requires no further action |
multiple-value-pattern-behavior
| Description | The behavior to exhibit if the plugin is configured with multiple value patterns. In many cases, you may only want to have a single value pattern defined. However, there may be cases in which multiple value patterns could be desirable. For example, let's say that you want to automatically generate values for the cn (full name) attribute for user entries from the values of the givenName (first name) and sn (last name) attributes. The person object class declares both the cn and sn attributes as mandatory, but the givenName attribute is considered optional, so there is no way to guarantee that a person entry will include the givenName attribute. Because the value pattern "{givenName} {sn}" will not generate any values for an entry that does not contain the givenName attribute, it may be desirable to configure the plugin with a second value pattern of just "{sn}" that will be used as a fallback for entries that don't contain givenName. In this case, you would configure the plugin to only use the first value pattern that is able to successfully generate values so that you don't end up with cn values that are generated from both value patterns. Alternatively, there may be cases in which you wish to have values for a single attribute composed from multiple combinations of source attributes, and you want each of those value patterns to be used. In that case, you would configure the plugin to use all values generated by all value patterns. |
| Default Value | use-first-non-rejected-value-pattern-with-non-empty-values-but-may-reject |
| Allowed Values | use-first-non-rejected-value-pattern-with-non-empty-values-but-may-reject - Use only the values generated from the first value pattern that can be used to successfully construct a non-empty set of values. If none of the values can successfully generate a non-empty set of values, and if at least one of the attempts was rejected (e.g., because the entry has multiple source attributes with multiple values), then the first rejection will be used as the reason when rejecting the LDIF entry or the requested operation. If none of the value patterns can be used to generate a non-empty set of values but none of the attempts is rejected (e.g., because the entry is missing at least one source attribute for each of the value patterns), then no composed values will be generated for that entry. use-first-non-rejected-value-pattern-with-non-empty-values-and-never-reject - Use only the values generated from the first value pattern that can be used to successfully construct a non-empty set of values. If none of the values can successfully generate a non-empty set of values, then no composed values will be generated for that entry, even if one or more of the attempts was rejected. use-first-rejection-or-first-value-pattern-with-non-empty-values - Use only the values generated from the first value pattern that can be used to successfully construct a non-empty set of values. However, if any attempt to use a value pattern to generate composed values is rejected (e.g., because the entry has multiple source attributes with multiple values) before a non-empty set of values can be generated, then the LDIF entry or the requested operation will be rejected without attempting any of the subsequent value patterns. If none of the value patterns can be used to generate a non-empty set of values but none of them is rejected, then no composed values will be generated for that entry. use-all-non-rejected-value-patterns-with-non-empty-values-but-may-reject - Use all of the values generated from all of the value patterns that can be used to successfully construct a non-empty set of values. As long as at least one value pattern can be used to generate a non-empty set of values, any value patterns that generate an empty set of values (e.g., because the entry is missing at least one of the source attributes) or that are rejected (e.g., because the entry has multiple source attributes with multiple values), then the successfully generated values will be used. If none of the value patterns can be used to generate a non-empty set of values, and if at least one value pattern was rejected, then the first rejection will be used as the reason when rejecting the LDIF entry or the requested operation. If none of the value patterns can be used to generate a non-empty set of values but none of them is rejected, then no composed values will be generated for that entry. use-all-non-rejected-value-patterns-with-non-empty-values-and-never-reject - Use all of the values generated from all of the value patterns that can be used to successfully construct a non-empty set of values. As long as at least one value pattern can be used to generate a non-empty set of values, any value patterns that generate an empty set of values (e.g., because the entry is missing at least one of the source attributes) or that are rejected (e.g., because the entry has multiple source attributes with multiple values), then the successfully generated values will be used. If none of the value patterns can be used to generate a non-empty set of values, then no composed values will be generated for that entry, even if one or more of the attempts was rejected. use-first-rejection-or-all-value-patterns-with-non-empty-values - Use all of the values generated from all of the value patterns that can be used to successfully construct a non-empty set of values. However, if any attempt to use a value pattern to generate composed values is rejected (e.g., because the entry has multiple source attributes with multiple values), then the LDIF entry or the requested operation will be rejected. If none of the value patterns can be used to generate a non-empty set of values but none of them is rejected, then no composed values will be generated for that entry. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
multi-valued-attribute-behavior
| Description | The behavior to exhibit for source attributes that have multiple values. Note that the logic the server uses to generate composed values only supports entries in which at most one of the source attributes has multiple values. If this plugin is configured to attempt to generate multiple values, the server may either silently ignore all but the first value for each of the source attributes or it may reject attempts to use entries with multiple values for multiple source attributes. |
| Default Value | use-all-values-if-possible-but-reject-if-not |
| Allowed Values | use-first-value - Use only the first value in each of the referenced source attributes when attempting to generate composed attribute values. If any of the source attributes has multiple values, those additional values will be silently ignored. reject-entries-with-any-multivalued-source-attribute - Reject any attempt to use an entry in which any of the source attributes used in any value pattern has multiple values. use-all-values-if-possible-but-reject-if-not - Attempt to use all values for each of the source attributes as long as at most one of them has multiple values. If multiple source attributes have multiple values, then reject the entry (if processing an LDIF import) or the operation (if processing an add, modify, or modify DN operation). use-all-values-if-possible-but-only-first-value-if-not - Attempt to use all values for each of the source attributes as long as at most one of them has multiple values. If multiple source attributes have multiple values, then silently ignore all but the first value for each of the source attributes rather than reject the entry or operation. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
target-attribute-exists-during-initial-population-behavior
| Description | The behavior to exhibit if the target attribute exists when initially populating the entry with composed values (whether during an LDIF import, an add operation, or an invocation of the populate composed attribute values task). Note that the server will not perform any composed attribute processing for an entry that includes the target attribute in its RDN, regardless of the value of this configuration property. Also note that while it is possible to reject attempts to add entries that already contain the target attribute, it is not possible reject entries containing that attribute in an LDIF import, as that would prevent a data set containing composed values from being exported to LDIF and re-imported into the server. It is also not possible to reject entries that already exist when using the populate composed attribute values task. |
| Default Value | preserve-existing-values |
| Allowed Values | preserve-existing-values - Use the existing values and do not generate any new values. overwrite-existing-values - Remove the existing values and use only the generated values. merge-existing-and-composed-values - Keep the existing values, but also generate any additional values that should be created from the configured value patterns. reject-existing-values-in-add-but-preserve-in-ldif-import - Reject any add operation that attempts to provide values for the target attribute, but preserve any existing values contained in entries imported from LDIF. reject-existing-values-in-add-but-overwrite-in-ldif-import - Reject any add operation that attempts to provide values for the target attribute, but replace any existing values imported from LDIF with the composed values for that attribute. reject-existing-values-in-add-but-merge-in-ldif-import - Reject any add operation that attempts to provide values for the target attribute, but merge any existing values imported from LDIF with the composed values for that attribute. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
update-source-attribute-behavior
| Description | The behavior to exhibit for modify and modify DN operations that update one or more of the source attributes used in any of the value patterns. |
| Default Value | replace-composed-values |
| Allowed Values | replace-composed-values - Replace any values that would have been composed from the configured value patterns with updated versions based on the new source attribute values, but preserve any values that would not have been generated from the source attributes. replace-all-values - Replace all values for the target attribute, even if they would not have been generated from the configured value patterns. preserve-existing-values - Preserve the existing values for the target attribute, regardless of whether they were generated by this plugin. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
source-attribute-removal-behavior
| Description | The behavior to exhibit for modify and modify DN operations that update an entry to remove source attributes in such a way that this plugin would no longer generate any composed values for that entry. |
| Default Value | preserve-non-composed-values |
| Allowed Values | preserve-non-composed-values - Remove values that would have been composed for the entry before it was udpated, but preserve any other values that the target attribute may contain. Note that even if this option is selected, composed values may be retained in the entry if there aren't any non-composed values and the target attribute type is required by at least one of the entry's object classes. preserve-all-values - Preserve all values for the target attribute, regardless of whether some or all of them would have been composed for the entry before it was updated. remove-all-values-but-preserve-all-if-required - Remvoe all values for the target attribute, regardless of whether some or all of them would not have been composed for the entry before it was updated, as long as the attribute is not required by any of the entry's object classes. If the target attribute is requried by at least one of the entry's object classes, then the plugin will behave as if the preserve-all-values option had been selected. remove-all-values-but-preserve-non-composed-if-required - Remvoe all values for the target attribute, regardless of whether some or all of them would not have been composed for the entry before it was updated, as long as the attribute is not required by any of the entry's object classes. If the target attribute is requried by at least one of the entry's object classes, then the plugin will behave as if the preserve-non-composed-values option had been selected. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
update-target-attribute-behavior
| Description | The behavior to exhibit for modify and modify DN operations that attempt to update the set of values for the target attribute. Note that if any operation attempts to directly alter the set of values for the target attribute, and if that modification is permitted, then no composed attribute processing will be performed. That is, if an operation alters both the target attribute and one or more source attributes used by one or more of the value patterns, updated composed values will not be generated for the target attribute. Also note that the server will not perform any composed attribute processing for an entry that includes the target attribute in its RDN, regardless of the value of this configuration property. |
| Default Value | always-allow |
| Allowed Values | always-allow - Always allow updates to the target attribute by authorized clients. allow-only-for-non-composed-values - Allow authorized clients to alter values for the target attribute that would not have been generated by this plugin, but do not allow altering any of the generated values. never-allow - Reject any attempt to alter values of the target attribute, regardless of whether the update would alter composed values. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
| Description | The set of base DNs below which composed values may be generated. If the plugin is configured with one or more include-base-dn values but no exclude-base-dn values, then composed values will only be generated for entries that reside at or below one of those include base DNs. If the plugin is configured with one or more exclude-base-dn values but no include-base-dn values, then composed values will be generated for all entries in all public backends that are not at or below one of those exclude base DNs. If the plugin is configured with both include-base-dn and exclude-base-dn values, then composed values will be generated for entries that reside at or below one of those include base DNs that are outside the scope of all of the exclude base DNs. If there is overlap between any of the include-base-dn and exclude-base-dn values, the exclude-base-dn values will take precedence. If the plugin is not configured with any values for either the include-base-dn or exclude-base-dn properties, then composed values will be generated for all entries in all public backends. |
| Default Value | None |
| Allowed Values | A valid DN. |
| Multi-Valued | Yes |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
| Description | The set of base DNs below which composed values will not be generated. If the plugin is configured with one or more include-base-dn values but no exclude-base-dn values, then composed values will only be generated for entries that reside at or below one of those include base DNs. If the plugin is configured with one or more exclude-base-dn values but no include-base-dn values, then composed values will be generated for all entries in all public backends that are not at or below one of those exclude base DNs. If the plugin is configured with both include-base-dn and exclude-base-dn values, then composed values will be generated for entries that reside at or below one of those include base DNs that are outside the scope of all of the exclude base DNs. If there is overlap between any of the include-base-dn and exclude-base-dn values, the exclude-base-dn values will take precedence. If the plugin is not configured with any values for either the include-base-dn or exclude-base-dn properties, then composed values will be generated for all entries in all public backends. |
| Default Value | None |
| Allowed Values | A valid DN. |
| Multi-Valued | Yes |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
| Description | The set of search filters that identify entries for which composed values may be generated. If the plugin is configured with one or more include-filter values but no exclude-filter values, then composed values will only be generated for entries that match at least one of those include filters. If the plugin is configured with one or more exclude-filter values but no include-filter values, then composed values will be generated for all entries that do not match any of those exclude filters. If the plugin is configured with both include-filter and exclude-filter values, then composed values will be generated for entries match at least one of the include filters but do not match any of the exclude filters. If the plugin is not configured with any values for either the include-filter or exclude-filter properties, then composed values will be generated for all entries. |
| Default Value | None |
| Allowed Values | A valid LDAP search filter |
| Multi-Valued | Yes |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
| Description | The set of search filters that identify entries for which composed values will not be generated. If the plugin is configured with one or more include-filter values but no exclude-filter values, then composed values will only be generated for entries that match at least one of those include filters. If the plugin is configured with one or more exclude-filter values but no include-filter values, then composed values will be generated for all entries that do not match any of those exclude filters. If the plugin is configured with both include-filter and exclude-filter values, then composed values will be generated for entries match at least one of the include filters but do not match any of the exclude filters. If the plugin is not configured with any values for either the include-filter or exclude-filter properties, then composed values will be generated for all entries. |
| Default Value | None |
| Allowed Values | A valid LDAP search filter |
| Multi-Valued | Yes |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
updated-entry-newly-matches-criteria-behavior
| Description | The behavior to exhibit for modify or modify DN operations that update an entry that previously did not satisfy either the base DN or filter criteria, but now do satisfy that criteria. |
| Default Value | preserve-existing-values-and-compose-new-values |
| Allowed Values | preserve-existing-values-without-composing-new-values - If the target attribute already exists in the entry, then preserve the values for that attribute and do not add any new composed values. If the target attribute does not already exist in the entry, then no composed values will be generated for it. preserve-existing-values-or-compose-new-values - If the target attribute already exists in the entry, then preserve the values for that attribute and do not add any new composed values. However, if the target attribute does not already exist in the entry, then add any composed values that should be generated for it. preserve-existing-values-and-compose-new-values - If the target attribute already exists in the entry, then preserve the values for that attribute, but also add in any additional values that should be generated for it. If the target attribute does not already exist in the entry, then add any composed values that should be generated for it. compose-new-values-without-preserving-existing-values - If the target attribute already exists in the entry, then any existing values will be removed and replaced with an appropriate set of composed values. If the target attribute does not already exist in the entry, then add any composed values that should be generated for it. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
updated-entry-no-longer-matches-criteria-behavior
| Description | The behavior to exhibit for modify or modify DN operations that update an entry that previously satisfied the base DN and filter criteria, but now no longer satisfies that criteria. |
| Default Value | preserve-all-values |
| Allowed Values | preserve-all-values - Preserve all values for the target attribute, regardless of whether some or all of them would have been composed for the entry before it was updated. preserve-non-composed-values - Remove values that would have been composed for the entry before it was updated, but preserve any other values that the target attribute may contain. Note that even if this option is selected, composed values may be retained in the entry if there aren't any non-composed values and the target attribute type is required by at least one of the entry's object classes. remove-all-values-but-preserve-all-if-required - Remvoe all values for the target attribute, regardless of whether some or all of them would not have been composed for the entry before it was updated, as long as the attribute is not required by any of the entry's object classes. If the target attribute is requried by at least one of the entry's object classes, then the plugin will behave as if the preserve-all-values option had been selected. remove-all-values-but-preserve-non-composed-if-required - Remvoe all values for the target attribute, regardless of whether some or all of them would not have been composed for the entry before it was updated, as long as the attribute is not required by any of the entry's object classes. If the target attribute is requried by at least one of the entry's object classes, then the plugin will behave as if the preserve-non-composed-values option had been selected. |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
plugin-type (Advanced Property)
| Description | Specifies the set of plug-in types for the plug-in, which specifies the times at which the plug-in is invoked. |
| Default Value | ldifimport preoperationadd preoperationmodify preoperationmodifydn |
| Allowed Values | startup - Invoked during the Directory Server startup process. shutdown - Invoked during a graceful Directory Server shutdown. postconnect - Invoked whenever a new connection is established to the server. postdisconnect - Invoked whenever an existing connection is terminated (by either the client or the server). ldifimport - Invoked for each entry read during an LDIF import. ldifexport - Invoked for each operation to be written during an LDIF export. preparseabandon - Invoked prior to parsing an abandon request. preparseadd - Invoked prior to parsing an add request. preparsebind - Invoked prior to parsing a bind request. preparsecompare - Invoked prior to parsing a compare request. preparsedelete - Invoked prior to parsing a delete request. preparseextended - Invoked prior to parsing an extended request. preparsemodify - Invoked prior to parsing a modify request. preparsemodifydn - Invoked prior to parsing a modify DN request. preparsesearch - Invoked prior to parsing a search request. preparseunbind - Invoked prior to parsing an unbind request. preoperationadd - Invoked prior to performing the core add processing. preoperationbind - Invoked prior to performing the core bind processing. preoperationcompare - Invoked prior to performing the core compare processing. preoperationdelete - Invoked prior to performing the core delete processing. preoperationextended - Invoked prior to performing the core extended processing. preoperationmodify - Invoked prior to performing the core modify processing. preoperationmodifydn - Invoked prior to performing the core modify DN processing. preoperationsearch - Invoked prior to performing the core search processing. postoperationabandon - Invoked after completing the abandon processing. postoperationadd - Invoked after completing the core add processing but before sending the response to the client. postoperationbind - Invoked after completing the core bind processing but before sending the response to the client. postoperationcompare - Invoked after completing the core compare processing but before sending the response to the client. postoperationdelete - Invoked after completing the core delete processing but before sending the response to the client. postoperationextended - Invoked after completing the core extended processing but before sending the response to the client. postoperationmodify - Invoked after completing the core modify processing but before sending the response to the client. postoperationmodifydn - Invoked after completing the core modify DN processing but before sending the response to the client. postoperationsearch - Invoked after completing the core search processing but before sending the response to the client. postoperationunbind - Invoked after completing the unbind processing. preresponseadd - Invoked just before sending the add response to the client. preresponsebind - Invoked just before sending the bind response to the client. preresponsecompare - Invoked just before sending the compare response to the client. preresponsedelete - Invoked just before sending the delete response to the client. preresponseextended - Invoked just before sending the extended response to the client. preresponsemodify - Invoked just before sending the modify response to the client. preresponsemodifydn - Invoked just before sending the modify DN response to the client. preresponsesearch - Invoked just before sending the search result done response to the client. postresponseadd - Invoked after sending the add response to the client. postresponsebind - Invoked after sending the bind response to the client. postresponsecompare - Invoked after sending the compare response to the client. postresponsedelete - Invoked after sending the delete response to the client. postresponseextended - Invoked after sending the extended response to the client. postresponsemodify - Invoked after sending the modify response to the client. postresponsemodifydn - Invoked after sending the modify DN response to the client. postresponsesearch - Invoked after sending the search result done message to the client. postsynchronizationadd - Invoked after completing post-synchronization processing for an add operation. postsynchronizationdelete - Invoked after completing post-synchronization processing for a delete operation. postsynchronizationmodify - Invoked after completing post-synchronization processing for a modify operation. postsynchronizationmodifydn - Invoked after completing post-synchronization processing for a modify DN operation. searchresultentry - Invoked before sending a search result entry to the client. searchresultreference - Invoked before sending a search result reference to the client. subordinatemodifydn - Invoked in the course of moving or renaming an entry subordinate to the target of a modify DN operation. intermediateresponse - Invoked before sending an intermediate response message to the client. |
| Multi-Valued | Yes |
| Required | Yes |
| Admin Action Required | The Composed Attribute Plugin must be disabled and re-enabled for changes to this setting to take effect. In order for this modification to take effect, the component must be restarted, either by disabling and re-enabling it, or by restarting the server |
invoke-for-internal-operations (Advanced Property)
| Description | Indicates whether the plug-in should be invoked for internal operations. Any plug-in that can be invoked for internal operations must ensure that it does not create any new internal operations that can cause the same plug-in to be re-invoked. |
| Default Value | true |
| Allowed Values | true false |
| Multi-Valued | No |
| Required | No |
| Admin Action Required | None. Modification requires no further action |
To list the configured Plugins:
dsconfig list-plugins
[--property {propertyName}] ...
To view the configuration for an existing Plugin:
dsconfig get-plugin-prop
--plugin-name {name}
[--tab-delimited]
[--script-friendly]
[--property {propertyName}] ...
To update the configuration for an existing Plugin:
dsconfig set-plugin-prop
--plugin-name {name}
(--set|--add|--remove) {propertyName}:{propertyValue}
[(--set|--add|--remove) {propertyName}:{propertyValue}] ...
To create a new Composed Attribute Plugin:
dsconfig create-plugin
--plugin-name {name}
--type composed-attribute
--set enabled:{propertyValue}
--set attribute-type:{propertyValue}
--set value-pattern:{propertyValue}
[--set {propertyName}:{propertyValue}] ...
To delete an existing Plugin:
dsconfig delete-plugin
--plugin-name {name}