Content Platform Tenant Management Help

Version: 9.6.x
Audience: anonymous
Part Number: MK-95HCPH002-18

Managing a Tenant and Its Namespaces
Introduction to Hitachi Content Platform
About Hitachi Content Platform
Object-based storage
Namespaces and tenants
Namespace access
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
Object representation
Tenant and namespace properties
Namespace quota
Storage quotas
Data protection level
Cryptographic hash algorithm
HCP Retention mode
Namespace owner
Namespace tags
Default retention setting
Default shred setting
Default index setting
Default POSIX UID, GID, and permissions
HCP Retention-related properties
Ownership and permission changes for objects under retention
Custom metadata operations for objects under retention
Protocol optimization and directory usage
XML checking for custom metadata
Versioning
Compatibility property
Disposition
Automatic abort of multipart uploads
Data access permission masks
Minimum data access permissions
Access control lists
Replication
Replication benefits
Replication implementation
Replication collision handling
Object content collisions
System metadata collisions
Custom metadata collisions
Access control list collisions
Configuration collisions
Retention class collisions
Service plans
System-level administrative access
General administrative information
Tenant Management Console
About the Console
Tenant Management Console URL
Logging in
Using the Tenant Management Console
Refreshing pages
Submitting changes
Viewing HCP documentation
Changing your password
Logging out
Administrative responsibilities
Managing accounts
User and group accounts
User accounts
Group accounts
Administrative roles and permissions
Available roles
Permissions granted by roles
Data access permissions
User authentication
Starter account
Working with user accounts
About the Users page
Understanding the user account list
Managing the user account list
Paging
Sorting
Filtering
Creating a user account
Modifying a user account and its roles
Deleting a user account
Working with group accounts
Groups page
Paging
Sorting
Filtering
Creating group accounts
Modifying a group account
Deleting a group account
Changing the allow namespace management property for a user or group account
Changing the data access permissions for a user or group account
Specifying permissions for any number of namespaces
Changing the permissions for an individual namespace
Dissociating a namespace from a user or group account
User account and login settings
Change one or more login settings
Managing the current tenant
Tenant Overview page
Tenant statistics
Major tenant events
Tenant alerts
Tenant features
Tenant contact information
Tenant permission mask
Tenant description
Configuring the tenant
Changing the tenant contact information
Changing the tenant permission mask
Changing the tenant description
Enabling or disabling system-level administrative access
Controlling access to the Tenant Management Console
Controlling access to HCP through the management API
Controlling access to the Search Console
Monitoring the tenant
Viewing the complete tenant event log
Viewing the tenant security log
Viewing the tenant compliance log
Understanding log messages
Managing the message list
Viewing the Active Directory log
Enabling syslog logging
Enabling SNMP logging
Configuring email notification
Enabling email notification
Testing email notification
Constructing the email message template
Modify the email notification template
Restoring the default template
Specifying email recipients
Understanding the recipients list
Modifying rows in the recipients list
Monitoring and managing replication
Tenant-level view of replication
Managing the namespace list
Paging
Sorting
Filtering
Namespace-level view of replication
Up-to-date-as-of time
Data transmission rate
Operation rate
Selecting or deselecting namespaces for replication
Generating chargeback reports
About chargeback reports
Generating a chargeback report
Chargeback statistics collection
Chargeback report content
Sample chargeback report
Chargeback page graphs
Managing namespaces
About the Namespaces page
Understanding the namespace list
Managing the namespace list
Paging
Sorting
Filter using filter fields
Filter using tag control
Namespace Overview panel
Display the namespace Overview panel
Namespace URL
Namespace owner
Objects section
Usage section
Major namespace events
Namespace alerts
Namespace features
Namespace permission mask
Namespace description
Creating a namespace
Configuring a namespace
Changing the namespace name
Changing the namespace permission mask
Changing the namespace description
Changing the namespace storage quotas
Changing the namespace owner
Changing the namespace tags
Changing the default HCP retention settings
Changing the default shred setting
Allowing object overwrites
Changing the default index setting
Changing minimum data access permissions
Enabling the use of ACLs
Changing the option to enforce ACLs
Changing HCP retention-related settings
Enabling or disabling XML checking for custom metadata
Configuring object versioning
Changing the compatibility setting
Changing disposition settings
Changing the automatic abort time for multipart uploads
Changing replication options
Changing the service plan
Changing the HCP retention mode
Configuring S3 Object Lock
Namespace-level CORS rules configuration
Request elements (CORS rules)
CORS configuration template
Configuring CORS rules for a namespace
Configuring namespace access protocols
Namespace access protocol configuration
Display the Protocols panel
Changing the protocol optimization for a namespace
IP addresses for namespace access
Add entries in Allow and Deny lists
Remove entries in Allow and Deny lists
Valid Allow and Deny list entries
Allow and Deny list handling
User authentication options
Configuring the REST, S3 compatible, and WebDAV APIs
REST, S3 compatible, and WebDav API configuration
Considerations for the S3 compatible API
Enabling REST, S3 compatible, and WebDAV access to a namespace
Set the IP addresses to be allowed or denied access
Configuring the CIFS protocol
CIFS protocol configuration
CIFS case sensitivity
Enabling CIFS access to a namespace
Settings section
Allow/Deny section
CIFS case sensitivity
Configuring the NFS protocol
NFS protocol configuration
Enabling NFS access to a namespace
Settings section
Allowed IP Addresses section
Configuring the SMTP protocol
SMTP protocol configuration
Enabling SMTP access to a namespace
Settings section
Allow/Deny section
Emails section
Changing the default settings for namespace creation
Setting the maximum number of namespaces per user
Monitoring a namespace
Viewing the complete namespace event log
Viewing the namespace compliance log
Working with unavailable objects
Working with irreparable objects
Displaying irreparable objects
About irreparable objects
Acknowledge irreparable objects
Working with nonreplicating objects
Displaying nonreplicating objects
About nonreplicating objects
Deleting a namespace
Configuring namespace access protocols
Namespace access protocol configuration
Display the Protocols panel
Changing the protocol optimization for a namespace
IP addresses for namespace access
Add entries in Allow and Deny lists
Remove entries in Allow and Deny lists
Valid Allow and Deny list entries
Allow and Deny list handling
User authentication options
Configuring the REST, S3 compatible, and WebDAV APIs
REST, S3 compatible, and WebDav API configuration
Considerations for the S3 compatible API
Enabling REST, S3 compatible, and WebDAV access to a namespace
Set the IP addresses to be allowed or denied access
Configuring the CIFS protocol
CIFS protocol configuration
CIFS case sensitivity
Enabling CIFS access to a namespace
Settings section
Allow/Deny section
Case Sensitivity section
Configuring the NFS protocol
NFS protocol configuration
Enabling NFS access to a namespace
Settings section
Allowed IP Addresses section
Configuring the SMTP protocol
SMTP protocol configuration
Enabling SMTP access to a namespace
Settings section
Allow/Deny section
Emails section
Configuring Microsoft Exchange for email archiving through SMTP
Configuring Microsoft Exchange 2003
Configuring Microsoft Exchange 2007
Configuring Microsoft Exchange 2010
Managing search and indexing
Search and indexing
Content classes and content properties
Metadata query engine indexing of custom metadata
Content class and content property workflow
Content property definitions
Content property names
Content property expressions
Content property data types
Format for the integer and float data types
Datetime data type formats
Multivalued content properties
Content properties extracted from sample XML
Content property files
About the Search page
Managing the content class list
Paging
Sorting
Filtering
Understanding the content property list for a content class
Creating a content class
Managing content properties for a content class
Workflow for adding, modifying, and deleting content properties
Adding content properties individually
Extracting content properties from sample XML
Importing content properties from a content property file
Testing content properties
Exporting content properties
Changing the namespaces associated with a content class
Reindexing namespaces associated with a content class
Renaming a content class
Deleting a content class
Managing search and indexing for an individual namespace
Displaying the namespace Search panel
Setting search and indexing options
Reindexing an individual namespace
Working with retention classes
About retention classes
Display the Retention Classes panel
Understanding the retention class list
Creating a retention class
Modifying a retention class
Deleting a retention class
Using privileged delete
About privileged delete
Object specification
Performing a privileged delete
Downloading the HCP Data Migrator installation file
Tenant Management Console alerts
Tenant Overview page alerts
Namespaces page alerts
Namespaces Overview panel alerts
Search page alert
Users page alert
Tenant log messages
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on
HCP Management API Reference
Introduction to the HCP management API
What you can do with the management API
Who can use the management API
Resources and properties
Supported methods
Input and output formats
Query parameters
HCP product-specific response headers
Security-related response headers
Enabling the management API in the Consoles
Support for the Amazon S3 API
Access and authentication
URL for HCP access through the management API
Using an IP address in URL
Using a hosts file
URL considerations
Authentication
HCP authentication through the management API
Authentication token
Authorization header
Active Directory user authentication through the HCP management API
Active Directory authentication token
Active Directory authorization header
Resources
Content class resources
Example: Creating a content class
Example: Retrieving a list of content classes
Erasure coding topology resources
Example: Retrieving a list of eligible replication links
Example: Creating an erasure coding topology
Example: Retrieving a list of eligible tenants
Example: Adding a tenant to an erasure coding topology
Example: Retrieving an erasure coding topology
Example: Retiring an erasure coding topology
Health check report resources
Example: Preparing health check reports for download
Example: Downloading the health check reports
Example: Retrieving the health check reports download status
Example: Canceling the health check reports
License resources
Example: Retrieving a premium storage license list
Example: Uploading a new license
Log resources
Example: Start log packaging
Example: Download the logs
Example: Retrieving the log download status
Example: Canceling a log download
Example: Marking the download log
Namespace resources
Example: Creating an HCP namespace
Example Changing the compliance settings for an HCP namespace
Example Configuring the REST API for an HCP namespace
Network resources
Example: Enabling advanced downstream DNS configuration
Example: Checking the advanced DNS configuration
Node statistics resource
Example: Retrieving node statistics
Paging, sorting, and filtering
Paging through resource lists
Sorting resource lists
Filtering resource lists
Replication resources
Example: Creating a replication link
Example: Retrieving a replication certificate
Example: Adding a replication certificate
Example: Retrieving a list of eligible local candidates
Example: Adding an HCP tenant to a replication link
Example: Setting the schedule for a replication link
Example: Failing over a replication link
Retention class resources
Example: Creating a retention class
Example: Retrieving a list of retention classes
Service statistics resource
Example: Retrieving service statistics
Support access credentials resource
System-level group account resources
Example: Retrieving system-level group accounts
Example: Retrieving system-level group account information
System-level user account resources
Example: Retrieving system-level user accounts
Example: Retrieving system-level user account information
Example: Changing a user account password with a query parameter
Example: Changing a user account password in the request body
Tenant resources
Example: Creating an HCP tenant
Example: Setting Tenant Management Console security for a tenant
Example: Generating a chargeback report for a tenant
Tenant-level group account resources
Example: Creating a group account
Example Retrieving group accounts
Tenant-level user account resources
Example: Creating a user account
Example: Changing the roles associated with a user account
Example: Changing the data access permissions associated with a user account
Example: Changing a user account password in the request body
Example: Resetting the security user passwords for a tenant
Data types
Common property values
availableServicePlan
certificate
certificates
chargebackData
chargebackReport
cifsProtocol
complianceSettings
connection
consoleSecurity
contactInfo
content
contentClass
contentProperty
contentProperties
cors data type
customMetadataIndexingSettings
dataAccessPermissions
ecTopology
emailNotification
emailTemplate
failoverSettings
groupAccount
healthCheckDownload
healthCheckDownloadStatus
healthCheckPrepare
httpProtocol
ipSettings
license
licenses
link
local (data type for replication link failoverSettings local property)
local (data type for replication link schedule local property)
logDownload
logDownloadPrepare
logDownloadStatus
namespace
namespaceDefaults
namespacePermission
networkSettings
nfsProtocol
node ()
node
nodes
nodeStatistics
protocols
recipient
recipients
remote (data type for replication link failoverSettings remote property)
remote (data type for replication link schedule remote property)
replicationCollisionSettings
replicationLink
replicationLinks
replicationService
retentionClass
schedule
searchSecurity
service
services
serviceStatistics
smtpProtocol
Specifying retention values
statistics (data type for replication link statistics property)
statistics (data type for tenant and namespace statistics resources)
Support access credentials data type
tenant (data type for replication link content tenant resource)
tenant (data type for tenant resource)
tenantCandidate
tenantCandidates
transition
updatePasswordRequest
userAccount (tenant level)
versioningSettings
Usage considerations
Choosing an access method
Generating templates for resource creation
Modifying resources
Session cookie encoding
HTTP status codes for the HCP management API
Sample Java application
What the application does
Assumptions
Required libraries
Input JSON files
JSON file for creating the HCP tenant
JSON file for modifying the initial user account
JSON file for creating the user account with the compliance and monitor roles
JSON file for configuring the Tenant Management Console
JSON file for modifying the tenant
JSON files for creating the namespaces
JSON file for modifying a namespace
JSON file for configuring the REST API
JSON file for creating the user account with no roles
JSON file for granting data access permissions to the user account
JSON file for creating the retention class
JSON file for creating the replication link
JAVA application
Management API XML schema
Using the Hitachi API for Amazon S3
Introduction to Hitachi Content Platform
About Hitachi Content Platform
About the Hitachi API for Amazon S3
Other bucket access methods
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
User accounts
S3 Object Lock Permissions
Data access permissions
Examples in this help
Bucket and object properties
Bucket names
Object names
Forward slashes in object names
Object naming considerations
Retention
Retention terms
Object retention settings
Deleting an object under retention
Holding an object
Holding an object using labeled holds
Retention classes
Retention-related request headers
Retention-related response headers
Specifying retention settings
Specifying a date and time
Specifying an offset
Custom metadata
Storing custom metadata with the S3 compatible API
Retrieving custom metadata with the S3 compatible API
Custom metadata usage considerations
Bucket owners
Object owners
Access control lists
ACL permissions
ACL grantees
Canned ACLs
Specifying ACLs
Specifying an ACL with headers
Specifying an ACL in the request body
Removing an ACL
Versioning
Allocated space
Search
Data access permission masks
Replication collisions
Object content collisions
Custom metadata collisions
Access control list collisions
Access and authentication
URLs for access to HCP
Targeting a tenant
Targeting a bucket
Targeting an object
Using SSL security
Using an IP address in a URL
Using a hosts file
URL considerations
Authentication
AWS authentication
Active Directory authentication
Presigned URLs
Signatures
Anonymous access
Invalid credentials
Changing your password
Requests and responses
Request line
Common request headers
Response status line
Common response headers
Error response body
Error codes
Working with buckets
Creating a bucket
Listing the buckets you own
Checking the existence of a bucket
Adding an ACL to a bucket
Retrieving the ACL for a bucket
Enabling or disabling versioning for a bucket
Checking the versioning status of a bucket
Listing bucket contents (version 1)
Listing bucket contents (version 2)
Listing the in-progress multipart uploads in a bucket
Deleting a bucket
Working with objects
Storing an object
Creating a folder
Checking the existence of an object or folder
Adding an ACL to an object
Retrieving the ACL for an object
Copying an object
Conditionally copying an object
Retrieving an object
Conditionally retrieving an object
Overriding response headers
Deleting an object or folder
Deleting multiple objects
Working with multipart uploads
About multipart uploads
Creating an object by multipart upload
Considerations for working with multipart uploads
Support for multipart uploads
Part size and count
Automatic abort of multipart uploads
Client timeouts
Creation date and time for multipart objects
Retention setting for multipart objects
Multipart uploads and versioning
Multiple multipart uploads for objects with the same name
Multipart uploads for objects under retention or on hold
Multipart uploads and replicated buckets
Initiating a multipart upload
Uploading a part of a multipart upload
Uploading a part of a multipart object by copying
Listing the parts of a multipart upload
Completing a multipart upload
Aborting a multipart upload
Working with POST object uploads
About POST object uploads
POST object upload authentication
Security policies
Executing a POST object upload
Using CORS to process cross-domain requests
CORS use cases
CORS limits
CORS rules configuration
HCP permissions for CORS configuration
Request header and elements
Example: PUT bucket request
Example: GET bucket request
Example: DELETE bucket request
CORS request validation
Usage considerations
Hostname and IP address considerations
Folder structures
Concurrent writes of the same object
Failed PUT requests to store objects
Empty objects
Deleting objects under repair
Multithreading
Persistent connections
Connection failure handling
Session cookie encoding
Quick reference
Alternative authentication method
URLs with HCP authentication
HCP authentication
Using third-party tools with the Hitachi API for Amazon S3
General setup information for third-party tools
s3curl setup
Specifying an access key and secret key
Specifying a tenant
Sample Java application
Assumptions
What the application does
Required libraries
Java application
Hitachi API for Amazon S3 XML schema
Using a Namespace
Overview
Introduction to Hitachi Content Platform
About Hitachi Content Platform
Object-based storage
Namespaces and tenants
Namespace access
Namespace access protocols
HCP Namespace Browser
HCP metadata query API
HCP Search Console
HCP nodes
Permissions
S3 Object Lock Permissions
Replication
Operations
Operation restrictions
Supported operations
Prohibited operations
Object representation
Object representation with the REST API
Object representation with WebDAV, CIFS, and NFS
Root directories
Sample data structure
Metadirectories
Metafiles
Complete metadata structure
Object properties
Data protection level
Cryptographic hash value
Object ingest time and change time
Retention
Object retention settings
Deleting object and versions under retention
Holding an object
Holding an object using labeled holds
Retention classes
Viewing retention settings
Specifying retention settings
Retention setting values
Specifying a date and time
Specifying an offset
atime synchronization with retention
Triggering atime synchronization for existing objects
Removing the association
How atime synchronization works
atime synchronization example
S3 Object Lock
Considerations when using Object Lock
Shredding
Indexing
Ownership
POSIX metadata
POSIX time attributes
POSIX ownership and permissions
Viewing POSIX permissions
Octal permission values
POSIX ownership and permissions for new items
Changing POSIX ownership and permissions for existing items
Versioning
Creating versions
Retrieving and listing versions
Deleting objects with versioning enabled
Purging objects
Custom metadata
Access control lists
ACL permissions
ACL body
ACL examples
ETags
Replication collision handling
Object content collisions
System metadata collisions
Custom metadata collisions
Access control list collisions
REST API
Accessing a namespace with the REST API
URLs for namespace access using the REST API
URL formats
Using an IP address in a URL
URL considerations
Authenticating namespace access
HCP authentication through the REST API
Authentication token
Authorization header
Active Directory user authentication through the REST API
Active Directory authentication token
Active Directory authorization header
Transmitting data in compressed format
Responding system
Working with objects and versions
Storing an object or version of an object
Copying an object or version of an object
Checking the existence of an object or multiple versions of an object
Listing object versions
Retrieving an object or multiple versions of an object
Deleting an object or object versions and using privileged delete
Purging an object and using privileged purge
Conditional operations
Working with directories
Creating an empty directory
Checking the existence of a directory
Listing directory contents
Deleting an empty directory
Working with system metadata
Specifying metadata on object creation
Modifying object metadata
Working with annotations
Storing an annotation
Checking the existence of an annotation
Listing annotations for an object or version
Retrieving annotations for objects and versions
Deleting annotations
Working with ACLs
Storing an ACL
Checking the existence of an ACL
Retrieving ACLs for objects and versions
Deleting an ACL
Retrieving namespace information
Listing accessible namespaces
Retrieving settings for an individual namespace
Listing retention classes
Listing namespace and user permissions
Listing namespace statistics
REST API usage considerations
Data chunking with write operations
Using the REST API with objects open for write
Failed REST API write operations
Storing zero-sized files with the REST API
Persistent connections with the REST API
Connection failure handling
Multithreading with the REST API
HTTP 500 and 503 status code considerations
Session cookie encoding
WebDAV
Using WebDAV
WebDAV methods
URLs for WebDAV access to a namespace
URL formats
URL considerations
WebDAV properties
Live and dead properties
HCP-specific metadata properties for WebDAV
Storing dead properties as custom metadata
WebDAV status codes
WebDAV examples
Example: Storing an object
Example: Retrieving the index setting for an object
Example: Changing the retention setting for an object
Example: Storing a dead property as custom metadata
WebDAV usage considerations
Basic authentication with WebDAV
WebDAV object locking
Failed WebDAV write operations
Storing zero-sized files with WebDAV
WebDAV client timeouts with long-running requests
Persistent connections with WebDAV
Multithreading with WebDAV
CIFS
Using CIFS
Namespace access with CIFS
CIFS return codes
CIFS examples
Example: Storing an object
Example: Changing a retention setting
Example: Retrieving an object
CIFS usage considerations
CIFS case sensitivity
CIFS permission translations
Creating an empty directory with atime synchronization in effect
CIFS lazy close
Using CIFS with objects open for write
Failed CIFS write operations
Storing zero-sized files with CIFS
Out-of-order writes with CIFS
Temporary files created by Windows clients
Multithreading with CIFS
NFS
Using NFS
Namespace access with NFS
NFS return codes
NFS examples
Example: Storing an object
Example: Changing a retention setting
Example: Using atime to set retention
Example: Creating a symbolic link
Example Retrieving an object
NFS usage considerations
NFS lazy close
Using NFS with objects open for write
Failed NFS write operations
Storing zero-sized files with NFS
Out-of-order writes with NFS
NFS reads of large objects
Walking large directory trees
NFS delete operations
NFS mounts on a failed node
Multithreading with NFS
Namespace Browser
Introduction to the Namespace Browser
About the Namespace Browser
Namespace Browser sessions
Accessing the Namespace Browser
Logging into the Namespace Browser as an authenticated user
Logging into the Namespace Browser anonymously
Common elements
Changing your password
Working with namespace contents
Listing directory contents
Directory listing
Showing and hiding deleted objects and directories
Listing object versions
Listing versions of deleted objects and directories with the same name
Accessing objects
Accessing old versions of an object
Storing objects and versions
Deleting objects and symbolic links
Creating directories
Viewing namespace information
Viewing accessible namespaces
Namespace information
Managing the namespace list
Paging
Sorting
Filter using filter fields
Filter using tag control
Viewing namespace statistics and description
Namespace statistics
Viewing permissions
Namespace permissions
Viewing retention classes
General usage considerations
Choosing an access protocol
Hostname and IP address considerations
Using a hosts file
Object naming considerations
Naming conventions for email objects
Directory structures
Shredding considerations
Non-WORM objects
Moving or renaming objects
Deleting objects under repair
Deleting directories
Multithreading
Status code considerations
REST API reference
HTTP methods supported by the REST API
DELETE
GET, except for namespace information requests
GET of namespace information
HEAD
POST
PUT
HTTP status codes with the REST API
REST API non-HTTP response headers
Standard HTTP response headers for the REST API
Java classes for examples
GZIPCompressedInputStream class
WholeIOOutputStream class
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on
HCP Metadata Query API Reference
Introduction to the HCP metadata query API
About the metadata query API
Types of queries
Query results
Object-based query results
Operation-based query results
Paged queries
Object index
Access and authentication
Request URL
Connecting using a hostname
Connecting using an IP address
Connecting using a hosts file
Authentication
HCP authentication through the metadata query management API
Authentication token
Authorization header
Active Directory user authentication through the metadata query management API
Active Directory authentication token
Active Directory authorization header
Query requests
Request format
Object-based query requests
XML request body for object-based queries
JSON request body for operation-based queries
Request object body contents
Top-level entry
object entry
sort entry
facets entry
Query expressions
Text-based criteria
Property-based criteria
Query expression considerations
customMetadataContent property
aclGrant property
Query expression examples
Paged queries with object-based requests
Paged queries with 100,000 or fewer matching objects
Paged queries with more than 100,000 matching objects
Operation-based query requests
XML request body for operation-based queries
JSON request body for operation-based queries
Request operation body contents
Top-level entry
operation entry
lastResult entry
systemMetadata entry
Paged queries with operation-based requests
Object properties
Query responses
XML response bodies
XML reponse body for object-based queries
XML response body for operation-based queries
JSON response bodies
JSON response body for object-based queries
JSON response body for operation-based queries
Response body contents
query entry
resultSet entry
object entry
status entry
contentProperties entry
facets entry
HTTP status codes
HTTP response headers
Examples
Object-based query examples
Example: Querying for custom metadata content
Example: Using a paged query to retrieve a list of all objects in a namespace
Example Using a faceted query to retrieve object information
Example: Querying for replication collisions in a namespace
Example: Listing content properties
Operation-based query examples
Example: Retrieving all operation records for all existing and deleted objects in a directory
Example: Retrieving metadata for changed objects
Example: Using a paged query to retrieve a large number of records
Example: Checking for replication collisions
Usage considerations
Searching namespaces
Introduction to searching in HCP
About Hitachi Content Platform
Object based storage
Namespaces and tenants
Object metadata
Retention settings
Retention mode
About searching namespaces
Search Console
Search facilities
Indexes
Content properties
Index settings
Searchable namespaces
Using the Search Console
Search Console URL
Search Console sessions
Logging into the Search Console
Logging out of the Search Console
Search Console pages and navigation
Viewing search documentation
Changing your password
Working with simple searches
About simple searches
Search terms
Metadata query engine search terms
Directory paths and object names
Multiple exact phrases
Wildcards
Boolean criteria
Examples of simple searches
Performing a simple search
Working with search results
About search results
Initial search results for individual objects
Initial results with the metadata query engine
Viewing returned objects
Showing results details
Understanding returned metadata
POSIX permissions
Octal permission values
Paging through search results
Sorting search results
Showing or hiding the query
Filtering search results
Search results page
Filtering by retention setting
Filtering by retention class
Filtering by hold status
Filtering by namespace
Performing operations on returned objects
Placing all the objects in the current search results on hold
Releasing all held objects in the current search results
Deleting all objects in the current search results except those that are under retention or on hold
Deleting all objects in the current search results, including those that are under retention but excluding those that are on hold
Purging all versions of all the objects in the current search results except those that are under retention or on hold
Purging all versions of all the objects in the current search results, including those that are under retention but excluding those that are on hold
Changing the ownership of all objects in the current search results
Setting an ACL on each object in the current search results
Updating the existing ACLs for all objects in the current search results
Access control lists
ACL permissions
XML format
Exporting search results
Working with structured searches
About structured searches
Properties for structured searches
Properties for structured queries with the metadata query engine
Content classes
Specifying an owner
Specifying an ACL grant
Query for objects with ACLs that grant permissions to a specified user
Query for objects with ACLs that grant permissions to the user account you’re using to access the Console
Query for objects with ACLs that grant permissions to an AD group
Query for objects with ACLs that grant permissions to all users, including those that access the namespace anonymously
Query for objects with ACLs that grant permissions to all authenticated users
Specifying dates
Selecting a calendar date
Typing a date
Selecting the current date and time
Performing a structured search
Examples of structured searches
Working with advanced searches
About advanced searches
Criteria for advanced queries with the metadata query engine
Query expressions
Criterion format
Boolean operators
Text-based property values
Multiple values for a single property
Value ranges
Wildcard characters
Query expression considerations
Properties for advanced queries
Criteria for advanced queries with the metadata query engine
customMetadataContent property
aclGrant property
Content properties
Performing an advanced search
Working with saved queries
Saving a query
Viewing saved queries
Running a saved query
Editing a saved query
Publishing a feed for a saved query
Deleting a saved query
Browser configuration for single sign-on with Active Directory
Configuring Windows Internet Explorer for single sign-on
Configuring Mozilla Firefox for single sign-on

Back to home page