in modules/backend/app/schemas.js [33:1323]
module.exports.factory = function() {
const Schema = mongoose.Schema;
const ObjectId = mongoose.Schema.Types.ObjectId;
// Define Account schema.
const Account = new Schema({
firstName: String,
lastName: String,
email: {type: String, unique: true},
phone: String,
company: String,
country: String,
registered: Date,
lastLogin: Date,
lastActivity: Date,
admin: Boolean,
token: String,
resetPasswordToken: String,
activated: {type: Boolean, default: false},
activationSentAt: Date,
activationToken: String
});
// Install passport plugin.
Account.plugin(passportMongo, {
usernameField: 'email', limitAttempts: true, lastLoginField: 'lastLogin',
usernameLowerCase: true,
errorMessages: {
UserExistsError: 'A user with the given email is already registered'
}
});
const transform = (doc, ret) => {
return {
_id: ret._id,
email: ret.email,
phone: ret.phone,
firstName: ret.firstName,
lastName: ret.lastName,
company: ret.company,
country: ret.country,
admin: ret.admin,
token: ret.token,
registered: ret.registered,
lastLogin: ret.lastLogin,
lastActivity: ret.lastActivity
};
};
// Configure transformation to JSON.
Account.set('toJSON', {transform});
// Configure transformation to JSON.
Account.set('toObject', {transform});
// Define Space schema.
const Space = new Schema({
name: String,
owner: {type: ObjectId, ref: 'Account'},
demo: {type: Boolean, default: false},
usedBy: [{
permission: {type: String, enum: ['VIEW', 'FULL']},
account: {type: ObjectId, ref: 'Account'}
}]
});
// Define Domain model schema.
const DomainModel = new Schema({
space: {type: ObjectId, ref: 'Space', index: true, required: true},
clusters: [{type: ObjectId, ref: 'Cluster'}],
caches: [{type: ObjectId, ref: 'Cache'}],
queryMetadata: {type: String, enum: ['Annotations', 'Configuration']},
kind: {type: String, enum: ['query', 'store', 'both']},
tableName: String,
keyFieldName: String,
valueFieldName: String,
databaseSchema: String,
databaseTable: String,
keyType: String,
valueType: {type: String},
keyFields: [{
databaseFieldName: String,
databaseFieldType: String,
javaFieldName: String,
javaFieldType: String
}],
valueFields: [{
databaseFieldName: String,
databaseFieldType: String,
javaFieldName: String,
javaFieldType: String
}],
queryKeyFields: [String],
fields: [{
name: String,
className: String,
notNull: Boolean,
defaultValue: String,
precision: Number,
scale: Number
}],
aliases: [{field: String, alias: String}],
indexes: [{
name: String,
indexType: {type: String, enum: ['SORTED', 'FULLTEXT', 'GEOSPATIAL']},
fields: [{name: String, direction: Boolean}],
inlineSizeType: Number,
inlineSize: Number
}],
generatePojo: Boolean
});
DomainModel.index({valueType: 1, space: 1, clusters: 1}, {unique: true});
// Define Cache schema.
const Cache = new Schema({
space: {type: ObjectId, ref: 'Space', index: true, required: true},
name: {type: String},
groupName: {type: String},
clusters: [{type: ObjectId, ref: 'Cluster'}],
domains: [{type: ObjectId, ref: 'DomainModel'}],
cacheMode: {type: String, enum: ['PARTITIONED', 'REPLICATED', 'LOCAL']},
atomicityMode: {type: String, enum: ['ATOMIC', 'TRANSACTIONAL', 'TRANSACTIONAL_SNAPSHOT']},
partitionLossPolicy: {
type: String,
enum: ['READ_ONLY_SAFE', 'READ_ONLY_ALL', 'READ_WRITE_SAFE', 'READ_WRITE_ALL', 'IGNORE']
},
affinity: {
kind: {type: String, enum: ['Default', 'Rendezvous', 'Fair', 'Custom']},
Rendezvous: {
affinityBackupFilter: String,
partitions: Number,
excludeNeighbors: Boolean
},
Fair: {
affinityBackupFilter: String,
partitions: Number,
excludeNeighbors: Boolean
},
Custom: {
className: String
}
},
affinityMapper: String,
nodeFilter: {
kind: {type: String, enum: ['Default', 'Exclude', 'IGFS', 'OnNodes', 'Custom']},
Exclude: {
nodeId: String
},
IGFS: {
igfs: {type: ObjectId, ref: 'Igfs'}
},
Custom: {
className: String
}
},
backups: Number,
memoryMode: {type: String, enum: ['ONHEAP_TIERED', 'OFFHEAP_TIERED', 'OFFHEAP_VALUES']},
offHeapMode: Number,
offHeapMaxMemory: Number,
startSize: Number,
swapEnabled: Boolean,
cacheWriterFactory: String,
cacheLoaderFactory: String,
expiryPolicyFactory: String,
interceptor: String,
storeByValue: Boolean,
eagerTtl: {type: Boolean, default: true},
encryptionEnabled: Boolean,
eventsDisabled: Boolean,
keyConfiguration: [{
typeName: String,
affinityKeyFieldName: String
}],
cacheStoreSessionListenerFactories: [String],
onheapCacheEnabled: Boolean,
evictionPolicy: {
kind: {type: String, enum: ['LRU', 'FIFO', 'SORTED']},
LRU: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
},
FIFO: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
},
SORTED: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
}
},
rebalanceMode: {type: String, enum: ['SYNC', 'ASYNC', 'NONE']},
rebalanceBatchSize: Number,
rebalanceBatchesPrefetchCount: Number,
rebalanceOrder: Number,
rebalanceDelay: Number,
rebalanceTimeout: Number,
rebalanceThrottle: Number,
cacheStoreFactory: {
kind: {
type: String,
enum: ['CacheJdbcPojoStoreFactory', 'CacheJdbcBlobStoreFactory', 'CacheHibernateBlobStoreFactory']
},
CacheJdbcPojoStoreFactory: {
dataSourceBean: String,
dialect: {
type: String,
enum: ['Generic', 'Oracle', 'DB2', 'SQLServer', 'MySQL', 'PostgreSQL', 'H2']
},
implementationVersion: String,
batchSize: Number,
maximumPoolSize: Number,
maximumWriteAttempts: Number,
parallelLoadCacheMinimumThreshold: Number,
hasher: String,
transformer: String,
sqlEscapeAll: Boolean
},
CacheJdbcBlobStoreFactory: {
connectVia: {type: String, enum: ['URL', 'DataSource']},
connectionUrl: String,
user: String,
dataSourceBean: String,
dialect: {
type: String,
enum: ['Generic', 'Oracle', 'DB2', 'SQLServer', 'MySQL', 'PostgreSQL', 'H2']
},
initSchema: Boolean,
createTableQuery: String,
loadQuery: String,
insertQuery: String,
updateQuery: String,
deleteQuery: String
},
CacheHibernateBlobStoreFactory: {
hibernateProperties: [{name: String, value: String}]
}
},
storeConcurrentLoadAllThreshold: Number,
maxQueryIteratorsCount: Number,
storeKeepBinary: Boolean,
loadPreviousValue: Boolean,
readThrough: Boolean,
writeThrough: Boolean,
writeBehindEnabled: Boolean,
writeBehindBatchSize: Number,
writeBehindFlushSize: Number,
writeBehindFlushFrequency: Number,
writeBehindFlushThreadCount: Number,
writeBehindCoalescing: {type: Boolean, default: true},
isInvalidate: Boolean,
defaultLockTimeout: Number,
atomicWriteOrderMode: {type: String, enum: ['CLOCK', 'PRIMARY']},
writeSynchronizationMode: {type: String, enum: ['FULL_SYNC', 'FULL_ASYNC', 'PRIMARY_SYNC']},
sqlEscapeAll: Boolean,
sqlSchema: String,
sqlOnheapRowCacheSize: Number,
longQueryWarningTimeout: Number,
sqlFunctionClasses: [String],
snapshotableIndex: Boolean,
queryDetailMetricsSize: Number,
queryParallelism: Number,
statisticsEnabled: Boolean,
managementEnabled: Boolean,
readFromBackup: Boolean,
copyOnRead: Boolean,
maxConcurrentAsyncOperations: Number,
nearConfiguration: {
enabled: Boolean,
nearStartSize: Number,
nearEvictionPolicy: {
kind: {type: String, enum: ['LRU', 'FIFO', 'SORTED']},
LRU: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
},
FIFO: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
},
SORTED: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
}
}
},
clientNearConfiguration: {
enabled: Boolean,
nearStartSize: Number,
nearEvictionPolicy: {
kind: {type: String, enum: ['LRU', 'FIFO', 'SORTED']},
LRU: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
},
FIFO: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
},
SORTED: {
batchSize: Number,
maxMemorySize: Number,
maxSize: Number
}
}
},
evictionFilter: String,
memoryPolicyName: String,
dataRegionName: String,
sqlIndexMaxInlineSize: Number,
topologyValidator: String,
diskPageCompression: {type: String, enum: ['SKIP_GARBAGE', 'ZSTD', 'LZ4', 'SNAPPY']},
diskPageCompressionLevel: Number
});
Cache.index({name: 1, space: 1, clusters: 1}, {unique: true});
const Igfs = new Schema({
space: {type: ObjectId, ref: 'Space', index: true, required: true},
name: {type: String},
clusters: [{type: ObjectId, ref: 'Cluster'}],
affinnityGroupSize: Number,
blockSize: Number,
streamBufferSize: Number,
dataCacheName: String,
metaCacheName: String,
defaultMode: {type: String, enum: ['PRIMARY', 'PROXY', 'DUAL_SYNC', 'DUAL_ASYNC']},
dualModeMaxPendingPutsSize: Number,
dualModePutExecutorService: String,
dualModePutExecutorServiceShutdown: Boolean,
fragmentizerConcurrentFiles: Number,
fragmentizerEnabled: Boolean,
fragmentizerThrottlingBlockLength: Number,
fragmentizerThrottlingDelay: Number,
ipcEndpointConfiguration: {
type: {type: String, enum: ['SHMEM', 'TCP']},
host: String,
port: Number,
memorySize: Number,
tokenDirectoryPath: String,
threadCount: Number
},
ipcEndpointEnabled: Boolean,
maxSpaceSize: Number,
maximumTaskRangeLength: Number,
managementPort: Number,
pathModes: [{path: String, mode: {type: String, enum: ['PRIMARY', 'PROXY', 'DUAL_SYNC', 'DUAL_ASYNC']}}],
perNodeBatchSize: Number,
perNodeParallelBatchCount: Number,
prefetchBlocks: Number,
sequentialReadsBeforePrefetch: Number,
trashPurgeTimeout: Number,
secondaryFileSystemEnabled: Boolean,
secondaryFileSystem: {
userName: String,
kind: {type: String, enum: ['Caching', 'Kerberos', 'Custom'], default: 'Caching'},
uri: String,
cfgPath: String,
cfgPaths: [String],
userNameMapper: {
kind: {type: String, enum: ['Chained', 'Basic', 'Kerberos', 'Custom']},
Chained: {
mappers: [{
kind: {type: String, enum: ['Basic', 'Kerberos', 'Custom']},
Basic: {
defaultUserName: String,
useDefaultUserName: Boolean,
mappings: [{
name: String,
value: String
}]
},
Kerberos: {
instance: String,
realm: String
},
Custom: {
className: String,
}
}]
},
Basic: {
defaultUserName: String,
useDefaultUserName: Boolean,
mappings: [{
name: String,
value: String
}]
},
Kerberos: {
instance: String,
realm: String
},
Custom: {
className: String,
}
},
Kerberos: {
keyTab: String,
keyTabPrincipal: String,
reloginInterval: Number
},
Custom: {
className: String
}
},
colocateMetadata: Boolean,
relaxedConsistency: Boolean,
updateFileLengthOnFlush: Boolean
});
Igfs.index({name: 1, space: 1, clusters: 1}, {unique: true});
// Define Cluster schema.
const Cluster = new Schema({
space: {type: ObjectId, ref: 'Space', index: true, required: true},
name: {type: String},
activeOnStart: {type: Boolean, default: true},
localHost: String,
discovery: {
localAddress: String,
localPort: Number,
localPortRange: Number,
addressResolver: String,
socketTimeout: Number,
ackTimeout: Number,
maxAckTimeout: Number,
networkTimeout: Number,
joinTimeout: Number,
threadPriority: Number,
heartbeatFrequency: Number,
maxMissedHeartbeats: Number,
maxMissedClientHeartbeats: Number,
topHistorySize: Number,
listener: String,
dataExchange: String,
metricsProvider: String,
reconnectCount: Number,
statisticsPrintFrequency: Number,
ipFinderCleanFrequency: Number,
authenticator: String,
forceServerMode: Boolean,
clientReconnectDisabled: Boolean,
connectionRecoveryTimeout: Number,
reconnectDelay: Number,
soLinger: Number,
kind: {
type: String,
enum: ['Vm', 'Multicast', 'S3', 'Cloud', 'GoogleStorage', 'Jdbc', 'SharedFs', 'ZooKeeper', 'Kubernetes']
},
Vm: {
addresses: [String]
},
Multicast: {
multicastGroup: String,
multicastPort: Number,
responseWaitTime: Number,
addressRequestAttempts: Number,
localAddress: String,
addresses: [String]
},
S3: {
bucketName: String,
bucketEndpoint: String,
SSEAlgorithm: String,
clientConfiguration: {
protocol: {type: String, enum: ['HTTP', 'HTTPS']},
maxConnections: Number,
userAgentPrefix: String,
userAgentSuffix: String,
localAddress: String,
proxyHost: String,
proxyPort: Number,
proxyUsername: String,
proxyDomain: String,
proxyWorkstation: String,
retryPolicy: {
kind: {
type: String,
enum: ['Default', 'DefaultMaxRetries', 'DynamoDB', 'DynamoDBMaxRetries', 'Custom', 'CustomClass']
},
DefaultMaxRetries: {
maxErrorRetry: Number
},
DynamoDBMaxRetries: {
maxErrorRetry: Number
},
Custom: {
retryCondition: String,
backoffStrategy: String,
maxErrorRetry: Number,
honorMaxErrorRetryInClientConfig: Boolean
},
CustomClass: {
className: String
}
},
maxErrorRetry: Number,
socketTimeout: Number,
connectionTimeout: Number,
requestTimeout: Number,
useReaper: Boolean,
useGzip: Boolean,
signerOverride: String,
preemptiveBasicProxyAuth: Boolean,
connectionTTL: Number,
connectionMaxIdleMillis: Number,
useTcpKeepAlive: Boolean,
dnsResolver: String,
responseMetadataCacheSize: Number,
secureRandom: String,
cacheResponseMetadata: {type: Boolean, default: true},
clientExecutionTimeout: Number,
nonProxyHosts: String,
socketSendBufferSizeHint: Number,
socketReceiveBufferSizeHint: Number,
useExpectContinue: {type: Boolean, default: true},
useThrottleRetries: {type: Boolean, default: true}
}
},
Cloud: {
credential: String,
credentialPath: String,
identity: String,
provider: String,
regions: [String],
zones: [String]
},
GoogleStorage: {
projectName: String,
bucketName: String,
serviceAccountP12FilePath: String,
serviceAccountId: String,
addrReqAttempts: String
},
Jdbc: {
initSchema: Boolean,
dataSourceBean: String,
dialect: {
type: String,
enum: ['Generic', 'Oracle', 'DB2', 'SQLServer', 'MySQL', 'PostgreSQL', 'H2']
}
},
SharedFs: {
path: String
},
ZooKeeper: {
curator: String,
zkConnectionString: String,
retryPolicy: {
kind: {
type: String, enum: ['ExponentialBackoff', 'BoundedExponentialBackoff', 'UntilElapsed',
'NTimes', 'OneTime', 'Forever', 'Custom']
},
ExponentialBackoff: {
baseSleepTimeMs: Number,
maxRetries: Number,
maxSleepMs: Number
},
BoundedExponentialBackoff: {
baseSleepTimeMs: Number,
maxSleepTimeMs: Number,
maxRetries: Number
},
UntilElapsed: {
maxElapsedTimeMs: Number,
sleepMsBetweenRetries: Number
},
NTimes: {
n: Number,
sleepMsBetweenRetries: Number
},
OneTime: {
sleepMsBetweenRetry: Number
},
Forever: {
retryIntervalMs: Number
},
Custom: {
className: String
}
},
basePath: String,
serviceName: String,
allowDuplicateRegistrations: Boolean
},
Kubernetes: {
serviceName: String,
namespace: String,
masterUrl: String,
accountToken: String
}
},
atomicConfiguration: {
backups: Number,
cacheMode: {type: String, enum: ['LOCAL', 'REPLICATED', 'PARTITIONED']},
atomicSequenceReserveSize: Number,
affinity: {
kind: {type: String, enum: ['Default', 'Rendezvous', 'Custom']},
Rendezvous: {
affinityBackupFilter: String,
partitions: Number,
excludeNeighbors: Boolean
},
Custom: {
className: String
}
},
groupName: String
},
binaryConfiguration: {
idMapper: String,
nameMapper: String,
serializer: String,
typeConfigurations: [{
typeName: String,
idMapper: String,
nameMapper: String,
serializer: String,
enum: Boolean,
enumValues: [String]
}],
compactFooter: Boolean
},
caches: [{type: ObjectId, ref: 'Cache'}],
models: [{type: ObjectId, ref: 'DomainModel'}],
clockSyncSamples: Number,
clockSyncFrequency: Number,
deploymentMode: {type: String, enum: ['PRIVATE', 'ISOLATED', 'SHARED', 'CONTINUOUS']},
discoveryStartupDelay: Number,
igfsThreadPoolSize: Number,
igfss: [{type: ObjectId, ref: 'Igfs'}],
includeEventTypes: [String],
eventStorage: {
kind: {type: String, enum: ['Memory', 'Custom']},
Memory: {
expireAgeMs: Number,
expireCount: Number,
filter: String
},
Custom: {
className: String
}
},
managementThreadPoolSize: Number,
marshaller: {
kind: {type: String, enum: ['OptimizedMarshaller', 'JdkMarshaller']},
OptimizedMarshaller: {
poolSize: Number,
requireSerializable: Boolean
}
},
marshalLocalJobs: Boolean,
marshallerCacheKeepAliveTime: Number,
marshallerCacheThreadPoolSize: Number,
metricsExpireTime: Number,
metricsHistorySize: Number,
metricsLogFrequency: Number,
metricsUpdateFrequency: Number,
networkTimeout: Number,
networkSendRetryDelay: Number,
networkSendRetryCount: Number,
communication: {
listener: String,
localAddress: String,
localPort: Number,
localPortRange: Number,
sharedMemoryPort: Number,
directBuffer: Boolean,
directSendBuffer: Boolean,
idleConnectionTimeout: Number,
connectTimeout: Number,
maxConnectTimeout: Number,
reconnectCount: Number,
socketSendBuffer: Number,
socketReceiveBuffer: Number,
messageQueueLimit: Number,
slowClientQueueLimit: Number,
tcpNoDelay: Boolean,
ackSendThreshold: Number,
unacknowledgedMessagesBufferSize: Number,
socketWriteTimeout: Number,
selectorsCount: Number,
addressResolver: String,
selectorSpins: Number,
connectionsPerNode: Number,
usePairedConnections: Boolean,
filterReachableAddresses: Boolean
},
connector: {
enabled: Boolean,
jettyPath: String,
host: String,
port: Number,
portRange: Number,
idleTimeout: Number,
idleQueryCursorTimeout: Number,
idleQueryCursorCheckFrequency: Number,
receiveBufferSize: Number,
sendBufferSize: Number,
sendQueueLimit: Number,
directBuffer: Boolean,
noDelay: Boolean,
selectorCount: Number,
threadPoolSize: Number,
messageInterceptor: String,
secretKey: String,
sslEnabled: Boolean,
sslClientAuth: Boolean,
sslFactory: String
},
peerClassLoadingEnabled: Boolean,
peerClassLoadingLocalClassPathExclude: [String],
peerClassLoadingMissedResourcesCacheSize: Number,
peerClassLoadingThreadPoolSize: Number,
publicThreadPoolSize: Number,
swapSpaceSpi: {
kind: {type: String, enum: ['FileSwapSpaceSpi']},
FileSwapSpaceSpi: {
baseDirectory: String,
readStripesNumber: Number,
maximumSparsity: Number,
maxWriteQueueSize: Number,
writeBufferSize: Number
}
},
systemThreadPoolSize: Number,
timeServerPortBase: Number,
timeServerPortRange: Number,
transactionConfiguration: {
defaultTxConcurrency: {type: String, enum: ['OPTIMISTIC', 'PESSIMISTIC']},
defaultTxIsolation: {type: String, enum: ['READ_COMMITTED', 'REPEATABLE_READ', 'SERIALIZABLE']},
defaultTxTimeout: Number,
pessimisticTxLogLinger: Number,
pessimisticTxLogSize: Number,
txSerializableEnabled: Boolean,
txManagerFactory: String,
useJtaSynchronization: Boolean,
txTimeoutOnPartitionMapExchange: Number, // 2.5
deadlockTimeout: Number // 2.8
},
sslEnabled: Boolean,
sslContextFactory: {
keyAlgorithm: String,
keyStoreFilePath: String,
keyStoreType: String,
protocol: String,
trustStoreFilePath: String,
trustStoreType: String,
trustManagers: [String],
cipherSuites: [String],
protocols: [String]
},
rebalanceThreadPoolSize: Number,
odbc: {
odbcEnabled: Boolean,
endpointAddress: String,
socketSendBufferSize: Number,
socketReceiveBufferSize: Number,
maxOpenCursors: Number,
threadPoolSize: Number
},
attributes: [{name: String, value: String}],
collision: {
kind: {type: String, enum: ['Noop', 'PriorityQueue', 'FifoQueue', 'JobStealing', 'Custom']},
PriorityQueue: {
parallelJobsNumber: Number,
waitingJobsNumber: Number,
priorityAttributeKey: String,
jobPriorityAttributeKey: String,
defaultPriority: Number,
starvationIncrement: Number,
starvationPreventionEnabled: Boolean
},
FifoQueue: {
parallelJobsNumber: Number,
waitingJobsNumber: Number
},
JobStealing: {
activeJobsThreshold: Number,
waitJobsThreshold: Number,
messageExpireTime: Number,
maximumStealingAttempts: Number,
stealingEnabled: Boolean,
stealingAttributes: [{name: String, value: String}],
externalCollisionListener: String
},
Custom: {
class: String
}
},
failoverSpi: [{
kind: {type: String, enum: ['JobStealing', 'Never', 'Always', 'Custom']},
JobStealing: {
maximumFailoverAttempts: Number
},
Always: {
maximumFailoverAttempts: Number
},
Custom: {
class: String
}
}],
logger: {
kind: {type: 'String', enum: ['Log4j2', 'Null', 'Java', 'JCL', 'SLF4J', 'Log4j', 'Custom']},
Log4j2: {
level: {type: String, enum: ['OFF', 'FATAL', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE', 'ALL']},
path: String
},
Log4j: {
mode: {type: String, enum: ['Default', 'Path']},
level: {type: String, enum: ['OFF', 'FATAL', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE', 'ALL']},
path: String
},
Custom: {
class: String
}
},
cacheKeyConfiguration: [{
typeName: String,
affinityKeyFieldName: String
}],
checkpointSpi: [{
kind: {type: String, enum: ['FS', 'Cache', 'S3', 'JDBC', 'Custom']},
FS: {
directoryPaths: [String],
checkpointListener: String
},
Cache: {
cache: {type: ObjectId, ref: 'Cache'},
checkpointListener: String
},
S3: {
awsCredentials: {
kind: {type: String, enum: ['Basic', 'Properties', 'Anonymous', 'BasicSession', 'Custom']},
Properties: {
path: String
},
Custom: {
className: String
}
},
bucketNameSuffix: String,
bucketEndpoint: String,
SSEAlgorithm: String,
clientConfiguration: {
protocol: {type: String, enum: ['HTTP', 'HTTPS']},
maxConnections: Number,
userAgentPrefix: String,
userAgentSuffix: String,
localAddress: String,
proxyHost: String,
proxyPort: Number,
proxyUsername: String,
proxyDomain: String,
proxyWorkstation: String,
retryPolicy: {
kind: {
type: String,
enum: ['Default', 'DefaultMaxRetries', 'DynamoDB', 'DynamoDBMaxRetries', 'Custom']
},
DefaultMaxRetries: {
maxErrorRetry: Number
},
DynamoDBMaxRetries: {
maxErrorRetry: Number
},
Custom: {
retryCondition: String,
backoffStrategy: String,
maxErrorRetry: Number,
honorMaxErrorRetryInClientConfig: Boolean
}
},
maxErrorRetry: Number,
socketTimeout: Number,
connectionTimeout: Number,
requestTimeout: Number,
useReaper: Boolean,
useGzip: Boolean,
signerOverride: String,
preemptiveBasicProxyAuth: Boolean,
connectionTTL: Number,
connectionMaxIdleMillis: Number,
useTcpKeepAlive: Boolean,
dnsResolver: String,
responseMetadataCacheSize: Number,
secureRandom: String,
cacheResponseMetadata: {type: Boolean, default: true},
clientExecutionTimeout: Number,
nonProxyHosts: String,
socketSendBufferSizeHint: Number,
socketReceiveBufferSizeHint: Number,
useExpectContinue: {type: Boolean, default: true},
useThrottleRetries: {type: Boolean, default: true}
},
checkpointListener: String
},
JDBC: {
dataSourceBean: String,
dialect: {
type: String,
enum: ['Generic', 'Oracle', 'DB2', 'SQLServer', 'MySQL', 'PostgreSQL', 'H2']
},
user: String,
checkpointTableName: String,
keyFieldName: String,
keyFieldType: String,
valueFieldName: String,
valueFieldType: String,
expireDateFieldName: String,
expireDateFieldType: String,
numberOfRetries: Number,
checkpointListener: String
},
Custom: {
className: String
}
}],
clientConnectorConfiguration: {
enabled: Boolean,
host: String,
port: Number,
portRange: Number,
socketSendBufferSize: Number,
socketReceiveBufferSize: Number,
tcpNoDelay: {type: Boolean, default: true},
maxOpenCursorsPerConnection: Number,
threadPoolSize: Number,
idleTimeout: Number,
jdbcEnabled: {type: Boolean, default: true},
odbcEnabled: {type: Boolean, default: true},
thinClientEnabled: {type: Boolean, default: true},
sslEnabled: Boolean,
useIgniteSslContextFactory: {type: Boolean, default: true},
sslClientAuth: Boolean,
sslContextFactory: String
},
loadBalancingSpi: [{
kind: {type: String, enum: ['RoundRobin', 'Adaptive', 'WeightedRandom', 'Custom']},
RoundRobin: {
perTask: Boolean
},
Adaptive: {
loadProbe: {
kind: {type: String, enum: ['Job', 'CPU', 'ProcessingTime', 'Custom']},
Job: {
useAverage: Boolean
},
CPU: {
useAverage: Boolean,
useProcessors: Boolean,
processorCoefficient: Number
},
ProcessingTime: {
useAverage: Boolean
},
Custom: {
className: String
}
}
},
WeightedRandom: {
nodeWeight: Number,
useWeights: Boolean
},
Custom: {
className: String
}
}],
deploymentSpi: {
kind: {type: String, enum: ['URI', 'Local', 'Custom']},
URI: {
uriList: [String],
temporaryDirectoryPath: String,
scanners: [String],
listener: String,
checkMd5: Boolean,
encodeUri: Boolean
},
Local: {
listener: String
},
Custom: {
className: String
}
},
warmupClosure: String,
hadoopConfiguration: {
mapReducePlanner: {
kind: {type: String, enum: ['Weighted', 'Custom']},
Weighted: {
localMapperWeight: Number,
remoteMapperWeight: Number,
localReducerWeight: Number,
remoteReducerWeight: Number,
preferLocalReducerThresholdWeight: Number
},
Custom: {
className: String
}
},
finishedJobInfoTtl: Number,
maxParallelTasks: Number,
maxTaskQueueSize: Number,
nativeLibraryNames: [String]
},
serviceConfigurations: [{
name: String,
service: String,
maxPerNodeCount: Number,
totalCount: Number,
nodeFilter: {
kind: {type: String, enum: ['Default', 'Exclude', 'IGFS', 'OnNodes', 'Custom']},
Exclude: {
nodeId: String
},
IGFS: {
igfs: {type: ObjectId, ref: 'Igfs'}
},
Custom: {
className: String
}
},
cache: {type: ObjectId, ref: 'Cache'},
affinityKey: String
}],
cacheSanityCheckEnabled: {type: Boolean, default: true},
classLoader: String,
consistentId: String,
failureDetectionTimeout: Number,
clientFailureDetectionTimeout: Number,
systemWorkerBlockedTimeout: Number,
workDirectory: String,
igniteHome: String,
lateAffinityAssignment: Boolean,
utilityCacheKeepAliveTime: Number,
asyncCallbackPoolSize: Number,
dataStreamerThreadPoolSize: Number,
queryThreadPoolSize: Number,
stripedPoolSize: Number,
serviceThreadPoolSize: Number,
utilityCacheThreadPoolSize: Number,
executorConfiguration: [{
name: String,
size: Number
}],
dataStorageConfiguration: {
systemRegionInitialSize: Number,
systemRegionMaxSize: Number,
pageSize: Number,
concurrencyLevel: Number,
defaultDataRegionConfiguration: {
name: String,
initialSize: Number,
maxSize: Number,
swapPath: String,
pageEvictionMode: {type: String, enum: ['DISABLED', 'RANDOM_LRU', 'RANDOM_2_LRU']},
evictionThreshold: Number,
emptyPagesPoolSize: Number,
metricsEnabled: Boolean,
metricsSubIntervalCount: Number,
metricsRateTimeInterval: Number,
persistenceEnabled: Boolean,
checkpointPageBufferSize: Number
},
dataRegionConfigurations: [{
name: String,
initialSize: Number,
maxSize: Number,
swapPath: String,
pageEvictionMode: {type: String, enum: ['DISABLED', 'RANDOM_LRU', 'RANDOM_2_LRU']},
evictionThreshold: Number,
emptyPagesPoolSize: Number,
metricsEnabled: Boolean,
metricsSubIntervalCount: Number,
metricsRateTimeInterval: Number,
persistenceEnabled: Boolean,
checkpointPageBufferSize: Number
}],
storagePath: String,
metricsEnabled: Boolean,
alwaysWriteFullPages: Boolean,
checkpointFrequency: Number,
checkpointThreads: Number,
checkpointWriteOrder: {type: String, enum: ['RANDOM', 'SEQUENTIAL']},
walPath: String,
walArchivePath: String,
walMode: {type: String, enum: ['DEFAULT', 'LOG_ONLY', 'BACKGROUND', 'NONE']},
walSegments: Number,
walSegmentSize: Number,
walHistorySize: Number,
walFlushFrequency: Number,
walFsyncDelayNanos: Number,
walRecordIteratorBufferSize: Number,
lockWaitTime: Number,
walBufferSize: Number,
walThreadLocalBufferSize: Number,
metricsSubIntervalCount: Number,
metricsRateTimeInterval: Number,
fileIOFactory: {type: String, enum: ['RANDOM', 'ASYNC']},
walAutoArchiveAfterInactivity: Number,
writeThrottlingEnabled: Boolean,
walCompactionEnabled: Boolean,
checkpointReadLockTimeout: Number,
maxWalArchiveSize: Number,
walCompactionLevel: Number
},
memoryConfiguration: {
systemCacheInitialSize: Number,
systemCacheMaxSize: Number,
pageSize: Number,
concurrencyLevel: Number,
defaultMemoryPolicyName: String,
defaultMemoryPolicySize: Number,
memoryPolicies: [{
name: String,
initialSize: Number,
maxSize: Number,
swapFilePath: String,
pageEvictionMode: {type: String, enum: ['DISABLED', 'RANDOM_LRU', 'RANDOM_2_LRU']},
evictionThreshold: Number,
emptyPagesPoolSize: Number,
metricsEnabled: Boolean,
subIntervals: Number,
rateTimeInterval: Number
}]
},
longQueryWarningTimeout: Number,
sqlConnectorConfiguration: {
enabled: Boolean,
host: String,
port: Number,
portRange: Number,
socketSendBufferSize: Number,
socketReceiveBufferSize: Number,
tcpNoDelay: {type: Boolean, default: true},
maxOpenCursorsPerConnection: Number,
threadPoolSize: Number
},
persistenceStoreConfiguration: {
enabled: Boolean,
persistentStorePath: String,
metricsEnabled: Boolean,
alwaysWriteFullPages: Boolean,
checkpointingFrequency: Number,
checkpointingPageBufferSize: Number,
checkpointingThreads: Number,
walStorePath: String,
walArchivePath: String,
walMode: {type: String, enum: ['DEFAULT', 'LOG_ONLY', 'BACKGROUND', 'NONE']},
walSegments: Number,
walSegmentSize: Number,
walHistorySize: Number,
walFlushFrequency: Number,
walFsyncDelayNanos: Number,
walRecordIteratorBufferSize: Number,
lockWaitTime: Number,
rateTimeInterval: Number,
tlbSize: Number,
subIntervals: Number,
walAutoArchiveAfterInactivity: Number
},
encryptionSpi: {
kind: {type: String, enum: ['Noop', 'Keystore', 'Custom']},
Keystore: {
keySize: Number,
masterKeyName: String,
keyStorePath: String
},
Custom: {
className: String
}
},
failureHandler: {
kind: {type: String, enum: ['RestartProcess', 'StopNodeOnHalt', 'StopNode', 'Noop', 'Custom']},
ignoredFailureTypes: [{type: String, enum: ['SEGMENTATION', 'SYSTEM_WORKER_TERMINATION',
'SYSTEM_WORKER_BLOCKED', 'CRITICAL_ERROR', 'SYSTEM_CRITICAL_OPERATION_TIMEOUT']}],
StopNodeOnHalt: {
tryStop: Boolean,
timeout: Number
},
Custom: {
className: String
}
},
localEventListeners: [{
className: String,
eventTypes: [String]
}],
mvccVacuumThreadCount: Number,
mvccVacuumFrequency: Number,
authenticationEnabled: Boolean,
sqlQueryHistorySize: Number,
lifecycleBeans: [String],
addressResolver: String,
mBeanServer: String,
networkCompressionLevel: Number,
includeProperties: [String],
cacheStoreSessionListenerFactories: [String],
autoActivationEnabled: {type: Boolean, default: true},
sqlSchemas: [String],
communicationFailureResolver: String
});
Cluster.index({name: 1, space: 1}, {unique: true});
// Define Notebook schema.
const Notebook = new Schema({
space: {type: ObjectId, ref: 'Space', index: true, required: true},
name: String,
expandedParagraphs: [Number],
paragraphs: [{
name: String,
query: String,
editor: Boolean,
result: {type: String, enum: ['none', 'table', 'bar', 'pie', 'line', 'area']},
pageSize: Number,
timeLineSpan: String,
maxPages: Number,
hideSystemColumns: Boolean,
cacheName: String,
useAsDefaultSchema: Boolean,
chartsOptions: {barChart: {stacked: Boolean}, areaChart: {style: String}},
rate: {
value: Number,
unit: Number
},
qryType: String,
nonCollocatedJoins: {type: Boolean, default: false},
enforceJoinOrder: {type: Boolean, default: false},
lazy: {type: Boolean, default: false},
collocated: Boolean
}]
});
Notebook.index({name: 1, space: 1}, {unique: true});
// Define Activities schema.
const Activities = new Schema({
owner: {type: ObjectId, ref: 'Account'},
date: Date,
group: String,
action: String,
amount: {type: Number, default: 0}
});
Activities.index({owner: 1, group: 1, action: 1, date: 1}, {unique: true});
// Define Notifications schema.
const Notifications = new Schema({
owner: {type: ObjectId, ref: 'Account'},
date: Date,
message: String,
isShown: Boolean
});
return {
Space,
Account,
DomainModel,
Cache,
Igfs,
Cluster,
Notebook,
Activities,
Notifications
};
};