| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| 'use strict'; |
| |
| const mongoose = require('mongoose'); |
| const passportMongo = require('passport-local-mongoose'); |
| |
| // Fire me up! |
| |
| /** |
| * Module mongo schema. |
| */ |
| module.exports = { |
| implements: 'schemas', |
| inject: [] |
| }; |
| |
| 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 |
| }; |
| }; |
