Source: corelink.browser.lib.js

  1. /* eslint-disable prefer-const */
  2. /* eslint-disable no-unused-vars */
  3. /* eslint-disable max-len */
  4. /* eslint-disable func-names */
  5. /* eslint-disable no-async-promise-executor */
  6. /* eslint-disable no-restricted-syntax */
  8. /**
  9.  * @file Browser client library for Corelink
  10.  * @author Robert Pahle, Ted Wong
  11.  * @version V3.0.0.0
  12.  */
  14. // V3.0.0.0 support new data protocol
  15. // V2.0.0.0 self building version based on the corelink.lib.js library
  16. // V1.0.0.0 initial version
  19. // test for nodejs
  20. if (typeof window === 'undefined') { throw new Error('This library is designed to run in a browser.') }
  22. // test if namespace is already used
  23. // eslint-disable-next-line no-undef
  24. if (typeof window.corelink !== 'undefined') { throw new Error('The corelink namespace is already registered.') }
  26. // Main Namespace
  27. const corelink = {};
  29. (function () {
  30.   // set debug to true for additional error reporting
  31.   let debug = true
  33.   // const headerSize = Buffer.alloc(6)
  35.   let attempts = 0
  36.   let connected = false
  39.   const receiverStream = {}
  40.   const senderStreams = []
  41.   const allowedStreams = []
  42.   let token = null
  44.   let sourceIP = null
  46.   let connCredentials = null
  47.   let connConfig = null
  50.   let dataCb = null
  51.   let receiverCb = null
  52.   let senderCb = null
  53.   let staleCb = null
  54.   let droppedCb = null
  55.   let closeCb = null
  58.   /**
  59.   * Helper function to create random exponential delay to reconnect
  60.   * @param {string} data JSON string to decode.
  61.   * @returns {object} Javascript object with the parsed data
  62.   * @private
  63.   * @module parseJson
  64.   */
  66.   function generateInterval(k) {
  67.     let maxInterval = ((2 ** k) - 1) * 1000
  68.     if (maxInterval > 30 * 1000) {
  69.       maxInterval = 30 * 1000
  70.     }
  71.     return Math.random() * maxInterval
  72.   }
  74.   // helper function to convert buffer to string
  75.   function ab2str(buf) {
  76.     return String.fromCharCode.apply(null, new Uint8Array(buf))
  77.   }
  79.   /**
  80.   * Helper function to parse JSON
  81.   * @param {string} data JSON string to decode.
  82.   * @returns {object} Javascript object with the parsed data
  83.   * @private
  84.   * @module parseJson
  85.   */
  87.   function parseJson(data) {
  88.     return (new Promise((resolve, reject) => {
  89.       try {
  90.         const parsedData = JSON.parse(`[${data.toString().replace(/}{/g, '},{')}]`)
  91.         resolve(parsedData)
  92.       } catch (e) {
  93.         reject(new Error(`Received message not a proper JSON: ${data.toString()}`))
  94.       }
  95.     }))
  96.   }
  99.   // all control stream functions
  101.   const control = {}
  102.   control.client = null
  103.   control.ID = 0
  105.   control.connect = async (IP, port) => (new Promise(async (resolve, reject) => {
  106.     try {
  107.       // eslint-disable-next-line no-undef
  108.       control.client = new WebSocket(`wss://${IP}:${port}/`)
  109.     } catch (e) {
  110.       reject(e)
  111.     }
  112.     control.client.binaryType = 'arraybuffer'
  114.     control.client.onopen = () => {
  115.       resolve()
  116.     }
  118.     control.request = async (data) => {
  119.       if (debug) console.log('request', data)
  120.       // eslint-disable-next-line no-shadow
  121.       return (new Promise(async (resolve, reject) => {
  122.         const wdata = data
  123.         wdata.ID = control.ID
  124.         control.ID += 1
  125.         let retries = 5
  126.         control.client.addEventListener('message', async (content) => { // it should be data instead of message (Abhishek Khanna), Rob : please review
  127.           const parsed = await parseJson(content.data).catch((e) => reject(e))
  128.           console.log('parsed all', parsed)
  129.           for (let i = 0; i < parsed.length; i += 1) {
  130.             retries -= 1
  131.             if ('ID' in parsed[i] && parsed[i].ID === wdata.ID) {
  132.               delete parsed[i].ID
  133.               if (debug) console.log('parsed', parsed[i])
  134.               if ('statusCode' in parsed[i]) {
  135.                 if (parsed[i].statusCode === 0) {
  136.                   resolve(parsed[i])
  137.                   break
  138.                 } if ('message' in parsed[i]) reject(new Error(`${parsed[i].message} (${parsed[i].statusCode})`))
  139.                 else reject(new Error(`Error (${parsed[i].statusCode}) with out specific message returned.`))
  140.               } reject(new Error('Status code or function not found in answer.'))
  141.             }
  142.             if (retries === 0) reject(new Error('Server did not responded with an answer.'))
  143.           }
  144.         })
  145.         control.client.send(JSON.stringify(wdata))
  146.         if (debug) console.log('request sent:', JSON.stringify(wdata))
  147.       }))
  148.     }
  151.     /**
  152.     *Call the on function with either data or close function.
  153.     * @param {string} data The module is defined to parse JSON data. The client checks for the
  154.                             'function' in data. The event 'update' or 'status' will be triggered
  155.                             and accordingly 'receiver_cb' or 'stale_cb' will be checked for
  156.                             null values.
  157.     * @param {string} close The callback function close_cb is checked for null values and close_cb()
  158.                             is called
  159.     * @module on
  160.     */
  162.     // set callbacks
  163.     control.client.addEventListener('message', async (data) => {
  164.       const parsedJson = await parseJson(data.data)
  165.       if (debug) console.log('stream.on', parsedJson)
  166.       for (let i = 0; i < parsedJson.length; i += 1) {
  167.         const parsedData = parsedJson[i]
  168.         if ('function' in parsedData) {
  169.           switch (parsedData.function) {
  170.             case 'update':
  171.               if (receiverCb != null) {
  172.                 delete parsedData.function
  173.                 receiverCb(parsedData)
  174.               } else console.log('No receiver update callback provided.')
  175.               break
  176.             case 'subscriber':
  177.               if (senderCb != null) {
  178.                 delete parsedData.function
  179.                 senderCb(parsedData)
  180.               } else console.log('No sender update callback provided.')
  181.               break
  182.             case 'stale':
  183.               if (staleCb != null) {
  184.                 delete parsedData.function
  185.                 staleCb(parsedData)
  186.               } else console.log('No stale update callback provided.')
  187.               break
  188.             case 'dropped':
  189.               if (droppedCb != null) {
  190.                 delete parsedData.function
  191.                 droppedCb(parsedData)
  192.               } else console.log('No dropped update callback provided.')
  193.               break
  194.             default:
  195.               console.log('Unknown callback. Maybe this library is outdated?')
  196.           }
  197.         }
  198.       }
  199.     })
  202.     // make connect attemps and manage exponential backoff in connection attempts
  203.     function reconnect() {
  204.       control.connect(connCredentials, connConfig).catch((err) => {
  205.         console.log('Connection failed.', err)
  206.       })
  207.     }
  210.     control.client.onclose = () => {
  211.       console.log('reconnect: ', connConfig.autoReconnect)
  212.       if (connConfig.autoReconnect) {
  213.         if (closeCb != null) closeCb()
  214.         else console.log('No close connection callback provided.')
  215.         console.log(`Control connection lost: Retrying websocket (${attempts})`)
  216.         const time = generateInterval(attempts)
  217.         console.log(`Waiting ${time}ms to reconnect.`)
  218.         setTimeout(() => {
  219.           attempts += 1
  220.           reconnect(attempts)
  221.         }, time)
  222.       } else
  223.       if (closeCb != null) closeCb()
  224.       else {
  225.         console.log('No close connection callback provided.')
  226.       }
  227.     }
  228.   }))
  230.   async function setupSender(streamID = null, port = null) {
  231.     return (new Promise(((resolve, reject) => {
  232.       if (debug) console.log('setting up data WS', 'streamID', streamID, 'port', port)
  233.       try {
  234.         // eslint-disable-next-line no-undef
  235.         senderStreams[streamID].client = new WebSocket(`wss://${connConfig.ControlIP}:${port}/`)
  236.       } catch (e) {
  237.         reject(e)
  238.       }
  239.       senderStreams[streamID].client.binaryType = 'arraybuffer'
  241.       senderStreams[streamID].client.addEventListener('open', () => {
  242.         // if ((streamID != null) && (port != null)) receiverSetup(streamID, port)
  243.         resolve(true)
  244.       })
  246.       senderStreams[streamID].client.addEventListener('error', (err) => {
  247.         reject(err)
  248.       })
  249.     })))
  250.   }
  252.   async function setupReceiver(streamID = null, port = null) {
  253.     return (new Promise(((resolve, reject) => {
  254.       if (debug) console.log('setting up data WS', 'streamID', streamID, 'port', port)
  255.       try {
  256.         // eslint-disable-next-line no-undef
  257.         receiverStream.client = new WebSocket(`wss://${connConfig.ControlIP}:${port}/`)
  258.       } catch (e) {
  259.         reject(e)
  260.       }
  261.       receiverStream.client.binaryType = 'arraybuffer'
  263.       receiverStream.client.addEventListener('open', () => {
  264.         // adding header
  265.         const buffersize = 8
  266.         const buffer = new ArrayBuffer(buffersize)
  267.         new DataView(buffer).setUint16(0, 0, true)
  268.         new DataView(buffer).setUint16(2, 0, true)
  269.         new DataView(buffer).setUint32(4, streamID, true)
  270.         console.log('bufferlength to send:', buffer.byteLength)
  272.         receiverStream.client.send(buffer)
  274.         resolve(true)
  275.       })
  277.       receiverStream.client.addEventListener('error', (err) => {
  278.         reject(err)
  279.       })
  281.       receiverStream.client.addEventListener('message', (message) => {
  282.         if (dataCb != null) {
  283.           let header
  284.           const view = new DataView(message.data)
  285.           const headSize = view.getUint16(0, true)
  286.           // const dataSize = view.getUint16(2, true)
  287.           const sourceID = view.getUint16(4, true)
  288.           const data = message.data.slice(8 + headSize)
  289.           if (headSize > 0) {
  290.             header = ab2str(message.data.slice(8, 8 + headSize))
  291.             try {
  292.               header = JSON.parse(header)
  293.             } catch (e) {
  294.               console.log(`Received header not a proper JSON: ${message.toString()}`)
  295.               return
  296.             }
  297.           }
  298.           dataCb(sourceID, data, header)
  299.         } else console.log('Data received, but no callback for data available.')
  300.       })
  301.     })))
  302.   }
  305.   /**
  306.    *Requests a 'sender' function from Corelink protocol which  needs input like
  307.   *workspace,protocol,Source IP, token etc. The client awaits to read, after
  308.   *which it parses the JSON data. The statusCode checks for streamID,port,MTU
  309.   *and message in the content. After getting values for workspace,protocol,type
  310.   *and metadata, UDP protocol is set up. The function expects and object with the
  311.   *following parameters:
  312.   *@param {String} workspace Workspaces are used to separate out groups of streams
  313.     so that several independent groups of researchers can work together.
  314.   *@param {String} protocol  Protocol for the stream to use (UDP/TCP/WS)
  315.   *@param {String} type type information can be freely selected.But well known
  316.     formats will be published.At the moment those are 3d, audio.
  317.   *@param {String} metadata Information about data
  318.   *@param {String} from sender information
  319.   *@module createSender
  320.   */
  322.   async function createSender(options) {
  323.     return (new Promise(async (resolve, reject) => {
  324.       const workOptions = options
  325.       // checking inputs
  326.       if (!('workspace' in workOptions)) reject(new Error('Workspace not found.'))
  327.       if (!('type' in workOptions)) reject(new Error('Type not defined.'))
  328.       workOptions.protocol = 'ws'
  329.       if (!('metadata' in workOptions)) workOptions.metadata = ''
  330.       if (!('from' in workOptions)) workOptions.from = ''
  331.       if (!('alert' in workOptions)) workOptions.alert = false
  334.       const request = `{"function":"sender","workspace":"${workOptions.workspace}","proto":"${workOptions.protocol}","IP":"${sourceIP}","port":0,"alert":${workOptions.alert},"type":"${workOptions.type}","meta":${JSON.stringify(workOptions.metadata)},"from":"${workOptions.from}","token":"${token}"}`
  335.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  336.       if (debug) console.log('CreateSender Result:', content)
  338.       if ('streamID' in content) senderStreams[content.streamID] = []
  339.       else reject(new Error('StreamID not found.'))
  340.       if ('port' in content) senderStreams[content.streamID].port = content.port
  341.       else reject(new Error('Target port not found.'))
  342.       if ('MTU' in content) senderStreams[content.streamID].MTU = content.MTU
  343.       else reject(new Error('Target MTU not found.'))
  345.       senderStreams[content.streamID].workspace = workOptions.workspace
  346.       senderStreams[content.streamID].protocol = workOptions.protocol
  347.       senderStreams[content.streamID].type = workOptions.type
  348.       senderStreams[content.streamID].metadata = workOptions.metadata
  349.       senderStreams[content.streamID].from = workOptions.from
  350.       senderStreams[content.streamID].alert = workOptions.alert
  352.       if (workOptions.protocol === 'ws') await setupSender(content.streamID, content.port).catch((err) => { console.log(err) })
  354.       if (debug) console.log('createSender returns:', content.streamID)
  355.       resolve(content.streamID)
  356.     }))
  357.   }
  359.   /**
  360.    *It takes arameters streamID and port and requests a receiver function from
  361.   *Corelink protocol which has inputs workspace name, streamID,source IP,token etc.
  362.   *Further,it checks for statusCode,streamID,port,potocol,streamList,MTU. UDP
  363.   *protocol is the set up on receiver's side. The function expects and object with the
  364.   *following parameters:
  365.   *@param {String} workspace Workspaces are used to separate out groups of streams
  366.     so that several independent groups of researchers can work together.
  367.   *@param {String} protocol Protocol for the stream to use (UDP/TCP/WS)
  368.   *@param {String} streamIDs Allows a user to select streams to Subscribe to.
  369.     If StreamID is not given, all streams are sent
  370.   *@param {String} type type information can be freely selected.But well known
  371.     formats will be published.At the moment those are 3d, audio.
  372.   *@param {String} alert alert is an optional argument that false,if new streams
  373.     of this type are registered will send the streamID’s to the client via server
  374.     initiated controlFunction (default is false)
  375.   *@param {String} echo receive data that was sent by the same user (default is false)
  376.   *@param {String} receiverID Receiver streamID to reuse
  377.   *@module createReceiver
  378.   */
  380.   async function createReceiver(options) {
  381.     return (new Promise(async (resolve, reject) => {
  382.       // checking inputs
  383.       const workOptions = options
  385.       if (!('workspace' in workOptions)) reject(new Error('Workspace not found.'))
  386.       workOptions.protocol = 'ws'
  387.       if (!('streamIDs' in workOptions)) workOptions.streamIDs = []
  388.       if (!('type' in workOptions)) workOptions.type = []
  389.       if (!('alert' in workOptions)) workOptions.alert = false
  390.       if (!('echo' in workOptions)) workOptions.echo = false
  391.       if ('receiverID' in workOptions) workOptions.receiverID = `,"receiverID":"${workOptions.receiverID}"`
  392.       else workOptions.receiverID = ''
  394.       const request = `{"function":"receiver","workspace":"${workOptions.workspace}"${workOptions.receiverID},"streamIDs":${JSON.stringify(workOptions.streamIDs)},"proto":"${workOptions.protocol}","IP":"${sourceIP}","port":0,"echo":${workOptions.echo},"alert":${workOptions.alert},"type":${JSON.stringify(workOptions.type)},"token":"${token}"}`
  395.       if (debug) console.log('createReceiver request', request)
  396.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  397.       if (debug) console.log('create Receiver content', content)
  399.       if ('streamID' in content) receiverStream.streamID = content.streamID
  400.       else reject(new Error('StreamID not found.'))
  401.       if (debug) console.log(`createReceiver port: ${content.port}`)
  402.       if ('port' in content) receiverStream.port = content.port
  403.       else reject(new Error('Target port not found.'))
  404.       if ('proto' in content) receiverStream.proto = content.proto
  405.       else reject(new Error('Target proto not found.'))
  406.       if ('streamList' in content) receiverStream.streamList = content.streamList
  407.       else reject(new Error('Target streamList not found.'))
  408.       if ('MTU' in content) receiverStream.MTU = content.MTU
  409.       else reject(new Error('Target MTU not found.'))
  411.       receiverStream.workspace = workOptions.workspace
  412.       receiverStream.protocol = workOptions.protocol
  413.       receiverStream.type = workOptions.type
  414.       receiverStream.alert = workOptions.alert
  415.       receiverStream.echo = workOptions.echo
  417.       for (const stream in content.streamList) {
  418.         if (!allowedStreams.includes(content.streamList[stream].streamID)) {
  419.           allowedStreams.push(content.streamList[stream].streamID)
  420.         }
  421.       }
  423.       await setupReceiver(content.streamID, content.port).catch((e) => console.log(e))
  425.       resolve(content.streamList)
  426.     }))
  427.   }
  429.   /**
  430.    *The function first checks if the array of streamIDs is not empty as well as
  431.   *the protocol set up is UDP. After the header and packet are defined, the
  432.   *message is send at the appropriate port number and target IP.
  433.   *@param {String} streamID  Allows a user to select streams to Subscribe to.
  434.     If StreamID is not given, all streams are sent
  435.   *@param {String} data Refers to the data to be sent.
  436.   *@param {object} header Is a JSON object that will be placed in the header in general these could be arbitrary information,
  437.       however, several tags will be decoded
  438.     - stamp: the server will fill in the server time stamp
  439.     - limit: array of receiver ids, the server will send the packet only to these id's
  440.   *@module send
  441.   */
  443.   function send(streamID, data, header) {
  444.     if ((typeof senderStreams[streamID] !== 'undefined') && (senderStreams[streamID].protocol === 'ws')) {
  445.       let workingHeader
  446.       if (typeof header === 'object') workingHeader = JSON.stringify(header)
  447.       else workingHeader = ''
  449.       // adding header
  450.       const buffersize = 8 + workingHeader.length + data.byteLength
  451.       const buffer = new ArrayBuffer(buffersize)
  452.       new DataView(buffer).setUint16(0, 0, true)
  453.       new DataView(buffer).setUint16(2, data.byteLength, true)
  454.       new DataView(buffer).setUint32(4, streamID, true)
  455.       const bufView = new Uint8Array(buffer)
  456.       const dataView = new Uint8Array(data)
  458.       // add json header to send buffer
  459.       for (let i = 0, strLen = workingHeader.length; i < strLen; i += 1) {
  460.         bufView[i + 8] = workingHeader.charCodeAt(i)
  461.       }
  463.       // add the data to buffer
  464.       for (let i = 0; i < dataView.byteLength; i += 1) {
  465.         bufView[i + 8 + workingHeader.length] = dataView[i]
  466.       }
  467.       try {
  468.         senderStreams[streamID].client.send(buffer)
  469.       } catch (e) {
  470.         console.log('socket error', e)
  471.       }
  472.       if (debug) console.log(`sent: ID${streamID} h${0},d${data.byteLength}`)
  473.     }
  474.   }
  477.   // Begin Common Functions
  479.   /**
  480.    *set the debug variable to enable enhanced debug output
  481.    *@param {boolean} flag A boolen that will set the enhanced debug functionality
  482.    *@module setDebug
  483.    */
  485.   function setDebug(flag) {
  486.     debug = flag
  487.   }
  490.   /**
  491.    *Login to the corelink server
  492.    *with username and password or token
  493.    *If the credentials are incorrect then it throws an error.
  494.    *The module ends with a
  495.     Promise. A promise is an object which can be returned synchronously from an asynchronous function.
  496.    *@param {String} credentials Refers to all login credentials like username,password and token.
  497.    *@module login
  498.    */
  500.   async function login(credentials) {
  501.     return (new Promise(async (resolve, reject) => {
  502.       let request = ''
  503.       if ((typeof credentials.username === 'undefined')
  504.               && (typeof credentials.password === 'undefined')) {
  505.         if ((typeof credentials.token === 'undefined')) reject(new Error('Credentials not found.'))
  506.         else request = `{"function":"auth","token":"${credentials.token}"}`
  507.       } else request = `{"function":"auth","username":"${credentials.username}","password":"${credentials.password}"}`
  508.       if (debug) console.log('Login ', request)
  509.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  510.       if (!content) return
  511.       if (debug) console.log('Login result ', content)
  512.       if ('token' in content) token = content.token
  513.       else reject(new Error('Token not found.'))
  514.       if ('IP' in content) sourceIP = content.IP
  515.       else reject(new Error('SourceIP not found.'))
  516.       resolve(true)
  517.     }))
  518.   }
  521.   /**
  522.    *Connects with client at the specified Port and IP number after verifying login credentials
  523.    *like username,password and token defined in the 'login' function.
  524.    *If the credentials are incorrect then it throws an error.
  525.    *The 'await' keyword waits for a value of ControlPort and ControlIP. The module ends with a
  526.     Promise. A promise is an object which can be returned synchronously from an asynchronous function.
  527.    *@param {String} credentials Refers to all login credentials like username,password and token.
  528.    *@param {String} config Refers to connection configuration like ControlPort and ControlIP
  530.    *@module connect
  531.    */
  533.   async function connect(credentials, config) {
  534.     return (new Promise(async (resolve, reject) => {
  535.       if (debug) console.log('Connecting...')
  536.       connConfig = config
  538.       connCredentials = credentials
  540.       // dns.lookup(connConfig.ControlIP, (err, address) => {
  541.       //   connConfig.ControlIP = address
  542.       //   if (debug) console.log('address:', address)
  543.       // })
  545.       if (debug) console.log('Target IP:', connConfig.ControlIP, 'target port :', connConfig.ControlPort)
  546.       let conn
  547.       connected = true
  548.       // connect the client
  549.       await control.connect(connConfig.ControlIP, connConfig.ControlPort).catch((e) => {
  550.         connected = false
  551.         if (debug) console.log('not connectd', e)
  552.         reject(e)
  553.       })
  555.       if (connected) {
  556.         // check if there is a token and if it is valid
  557.         // checkToken()
  559.         // login if we dont have a good token
  560.         if (token == null) conn = await login(credentials).catch((e) => reject(e))
  562.         // if all streams are still valid
  563.         // if (conn) checkConnections()
  564.       }
  565.       if (conn) {
  566.         attempts = 1
  567.         resolve(conn)
  568.       } else reject(new Error('Problem loggin in'))
  569.     }))
  570.   }
  572.   /**
  573.    *Queries the corelink relay for available User
  574.    *@param {string} config the parameter name that should be set
  575.    *@param {string} context context that this cofiguration applies to global (server global
  576.                     settings), profile (global user specific settings), app (app global
  577.                     settings), or private (app user specific settings), if omitted or empty
  578.                     it is a global configuration parameter
  579.    *@param {string} app name of the app that this cofiguration applies to, can be omitted or
  580.                     empty for global or profile configuration parameters
  581.    *@param {string} plugin name of the plugin that this cofiguration applies to, can be omitted or
  582.                     empty for global or profile configuration parameters
  583.    *@param {string} user name of the user that this cofiguration applies to, can be omitted
  584.                     or empty for global or app configuration parameters, only an admin can
  585.                     set this parameter, otherwise the logged in username will be taken.'
  586.    *@param {string} value value to apply to the parameter, all parameters are stored as strings,
  587.                     but are applied in the defined type',
  588.    *@exports setConfig
  589.    *@module setConfig
  590.    */
  592.   async function setConfig(options) {
  593.     return (new Promise(async (resolve, reject) => {
  594.       const request = options
  595.       if (!('config' in request)) { reject(new Error('Name of the configuration parameter required.')); return }
  596.       if (!('value' in request)) { reject(new Error('Context of the configuration parameter required.')); return }
  597.       if (!('context' in request) || (request === '')) { request.context = 'global' }
  598.       if (!('app' in request)) { request.app = '' }
  599.       if (!('plugin' in request)) { request.plugin = '' }
  600.       if (!('user' in request)) { request.user = '' }
  601.       request.function = 'setConfig'
  602.       request.token = token
  603.       console.log(request)
  604.       await control.request(request).catch((e) => reject(e))
  605.       resolve(true)
  606.     }))
  607.   }
  609.   // User management functions
  611.   /**
  612.    *Queries the corelink relay to add a user
  613.    *@param {String} username  name that you would like to add
  614.    *@param {String} password  password of the user that you would like to add
  615.    *@param {String} email  emailid of the user that you would like to add
  616.    *@param {String} first  name that you would like to add
  617.    *@param {String} last  name that you would like to add
  618.    *@param {boolean} admin  admin property of the new user
  619.    *@exports addUser
  620.    *@module addUser
  621.    */
  623.   async function addUser(options) {
  624.     return (new Promise(async (resolve, reject) => {
  625.       const workOptions = options
  626.       // checking inputs
  627.       if (!('username' in workOptions)) {
  628.         reject(new Error('user not found.'))
  629.         return
  630.       }
  631.       if (!('password' in workOptions)) {
  632.         reject(new Error('password not found.'))
  633.         return
  634.       }
  635.       if (!('email' in workOptions)) {
  636.         reject(new Error('email name not defined.'))
  637.         return
  638.       }
  639.       if (!('first' in workOptions)) workOptions.first = workOptions.username
  640.       if (!('last' in workOptions)) workOptions.last = workOptions.username
  641.       if (!('admin' in workOptions)) workOptions.admin = false
  642.       const request = `{"function":"addUser","username":"${workOptions.username}","password":"${workOptions.password}","first":"${workOptions.first}",
  643.       "email":"${workOptions.email}","last":"${workOptions.last}","admin":${workOptions.admin},"token":"${token}"}`
  644.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  645.       resolve(true)
  646.     }))
  647.   }
  649.   /**
  650.    *Queries the corelink relay to change the password of the user
  651.    *@param {String} password password that need to be change
  652.    *@exports password
  653.    *@module password
  654.    */
  655.   async function password(options) {
  656.     return (new Promise(async (resolve, reject) => {
  657.       const workOptions = options
  658.       // checking inputs
  659.       if (!('password' in workOptions)) {
  660.         reject(new Error('password not found.'))
  661.         return
  662.       }
  663.       const request = `{"function":"password","password":"${workOptions.password}","token":"${token}"}`
  664.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  665.       resolve(true)
  666.     }))
  667.   }
  669.   /**
  670.    *Queries the corelink relay to remove a user
  671.    *@param {String} username  user name that you would like to remove
  672.    *@exports rmUser
  673.    *@module rmUser
  674.    */
  676.   async function rmUser(options) {
  677.     return (new Promise(async (resolve, reject) => {
  678.       const workOptions = options
  679.       // checking inputs
  680.       if (!('username' in workOptions)) {
  681.         reject(new Error('username not given.'))
  682.         return
  683.       }
  684.       const request = `{"function":"rmUser","username":"${workOptions.username}","token":"${token}"}`
  685.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  686.       resolve(true)
  687.     }))
  688.   }
  690.   /**
  691.    *Queries the corelink relay for available User
  692.    *@returns {Array} Array of User, empty array if no User are available
  693.    *@exports listUsers
  694.    *@module listUsers
  695.    */
  697.   async function listUsers() {
  698.     return (new Promise(async (resolve, reject) => {
  699.       const request = `{"function":"listUsers","token":"${token}"}`
  700.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  701.       if ('userList' in content) resolve(content.userList)
  702.       else reject(new Error('Users not found.'))
  703.     }))
  704.   }
  706.   // Group management functions:
  709.   /**
  710.    *Queries the corelink relay to add a user to group(login user should either admin/ owner)
  711.    *@param {String} User  name that you would like to user to group
  712.    *@param {String} group  Groupname that will have a new user
  713.    *@module addUserGroup
  714.    */
  716.   async function addUserGroup(options) {
  717.     return (new Promise(async (resolve, reject) => {
  718.       const workOptions = options
  719.       // checking inputs
  720.       if (!('username' in workOptions)) reject(new Error('user not found.'))
  721.       else if (!('group' in workOptions)) reject(new Error('group not found.'))
  722.       else {
  723.         const request = `{"function":"addUserGroup","username":"${workOptions.username}","group":"${workOptions.group}","token":"${token}"}`
  724.         await control.request(JSON.parse(request)).catch((e) => reject(e))
  725.       }
  726.       resolve(true)
  727.     }))
  728.   }
  730.   /**
  731.    *Queries the corelink relay to remove user from group(login user should either admin/ owner)
  732.    *@param {String} User  name that you would like to user to group
  733.    *@param {String} group  Groupname that will have a new user
  734.    *@module rmUserGroup
  735.    */
  737.   async function rmUserGroup(options) {
  738.     return (new Promise(async (resolve, reject) => {
  739.       const workOptions = options
  740.       // checking inputs
  741.       if (!('username' in workOptions)) reject(new Error('user not found.'))
  742.       else if (!('group' in workOptions)) reject(new Error('group not found.'))
  743.       else {
  744.         const request = `{"function":"rmUserGroup","user":"${workOptions.username}","group":"${workOptions.group}","token":"${token}"}`
  745.         await control.request(JSON.parse(request)).catch((e) => reject(e))
  746.       }
  747.       resolve(true)
  748.     }))
  749.   }
  751.   /**
  752.    *Queries the corelink relay for available group
  753.    *@returns {Array} Array of group, empty array if no grou[] are available
  754.    *@exports listGroups
  755.    *@module listGroups
  756.    */
  757.   async function listGroups() {
  758.     return (new Promise(async (resolve, reject) => {
  759.       const request = `{"function":"listGroups","token":"${token}"}`
  760.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  761.       if ('groupList' in content) resolve(content.groupList)
  762.       else reject(new Error('  groupList not found.'))
  763.     }))
  764.   }
  767.   /**
  768.    *Queries the corelink relay to add a Group
  769.    *@param {String} Group Group name that you would like to add
  770.    *@param {String} owner owner name of the new group
  771.    *@exports addGroup
  772.    *@module addGroup
  773.    */
  774.   async function addGroup(options) {
  775.     return (new Promise(async (resolve, reject) => {
  776.       const workOptions = options
  777.       if (!('group' in workOptions)) {
  778.         reject(new Error('new groupname not found.'))
  779.         return
  780.       }
  781.       const request = `{"function":"addGroup","group":"${workOptions.group}","token":"${token}"}`
  782.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  783.       resolve(true)
  784.     }))
  785.   }
  788.   /**
  789.    *Queries the corelink relay to remove a group
  790.    *@param {String} Group group name that you would like to remove
  791.    *@exports rmGroup
  792.    *@module rmGroup
  793.    */
  794.   async function rmGroup(options) {
  795.     return (new Promise(async (resolve, reject) => {
  796.       const workOptions = options
  797.       // checking inputs
  798.       if (!('group' in workOptions)) {
  799.         reject(new Error('remove group not found.'))
  800.         return
  801.       }
  802.       const request = `{"function":"rmGroup","group":"${workOptions.group}","token":"${token}"}`
  803.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  804.       resolve(true)
  805.     }))
  806.   }
  808.   /**
  809.    *Queries the corelink relay to change the ownerhip of group
  810.    *@param {String} Group group name that you would like to change owner
  811.     *@param {String} username user name that you would like to be owner
  812.    *@exports changeOwner
  813.    *@module changeOwner
  814.    */
  815.   async function changeOwner(options) {
  816.     return (new Promise(async (resolve, reject) => {
  817.       const workOptions = options
  818.       // checking inputs
  819.       if (!('group' in workOptions)) {
  820.         reject(new Error('groupname not found.'))
  821.         return
  822.       }
  823.       if (!('username' in workOptions)) {
  824.         reject(new Error('username not found.'))
  825.         return
  826.       }
  827.       const request = `{"function":"changeOwner","group":"${workOptions.group}","username":"${workOptions.username}","token":"${token}"}`
  828.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  829.       resolve(true)
  830.     }))
  831.   }
  834.   // Workspace management functions:
  836.   /**
  837.    *Queries the corelink relay for available workspaces
  838.    *@returns {Array} Array of workspaces, empty array if no workspaces are available
  839.    *@exports listWorkspaces
  840.    *@module listWorkspaces
  841.    */
  842.   async function listWorkspaces() {
  843.     return (new Promise(async (resolve, reject) => {
  844.       const request = `{"function":"listWorkspaces","token":"${token}"}`
  845.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  846.       if ('workspaceList' in content) resolve(content.workspaceList)
  847.       else reject(new Error('workspaceList not found.'))
  848.     }))
  849.   }
  852.   /**
  853.    *Queries the corelink relay to add a workspace
  854.    *@param {String} workspace workspace name that you would like to add
  855.    *@exports addWorkspace
  856.    *@module addWorkspace
  857.    */
  858.   async function addWorkspace(workspace) {
  859.     return (new Promise(async (resolve, reject) => {
  860.       const request = `{"function":"addWorkspace","workspace":"${workspace}","token":"${token}"}`
  861.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  862.       resolve(true)
  863.     }))
  864.   }
  867.   /**
  868.    *Queries the corelink relay to remove a workspaces
  869.    *@param {String} workspace workspace name that you would like to remove
  870.    *@exports rmWorkspace
  871.    *@module rmWorkspace
  872.    */
  873.   async function rmWorkspace(workspace) {
  874.     return (new Promise(async (resolve, reject) => {
  875.       const request = `{"function":"rmWorkspace","workspace":"${workspace}","token":"${token}"}`
  876.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  877.       resolve(true)
  878.     }))
  879.   }
  882.   /**
  883.    *Queries the corelink relay to set a default workspace
  884.    *@param {String} workspace workspace name that you would like to set as default
  885.    *@exports setDefaultWorkspace
  886.    *@module setDefaultWorkspace
  887.    */
  888.   async function setDefaultWorkspace(workspace) {
  889.     return (new Promise(async (resolve, reject) => {
  890.       const request = `{"function":"setDefaultWorkspace","workspace":"${workspace}","token":"${token}"}`
  891.       await control.request(JSON.parse(request)).catch((e) => reject(e))
  892.       resolve(true)
  893.     }))
  894.   }
  897.   /**
  898.    *Queries the corelink relay to get the current default workspace
  899.    *@returns {String} workspace name that is currently set as default
  900.    *@exports getDefaultWorkspace
  901.    *@module getDefaultWorkspace
  902.    */
  903.   async function getDefaultWorkspace() {
  904.     return (new Promise(async (resolve, reject) => {
  905.       const request = `{"function":"getDefaultWorkspace","token":"${token}"}`
  906.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  907.       if ('workspace' in content) resolve(content.workspace)
  908.       else reject(new Error('No default workspace found.'))
  909.     }))
  910.   }
  912.   // introspect functions functions
  914.   /**
  915.    *Queries the corelink relay for available functions
  916.    *@returns {Array} Array of functions that the server has available
  917.    *@exports listFunctions
  918.    *@module listFunctions
  919.    */
  921.   async function listFunctions() {
  922.     return (new Promise(async (resolve, reject) => {
  923.       const request = {}
  924.       request.function = 'listFunctions'
  925.       request.token = token
  926.       const content = await control.request(request).catch((e) => reject(e))
  927.       if ('functionList' in content) resolve(content)
  928.       else reject(new Error('functionList not found.'))
  929.     }))
  930.   }
  932.   /**
  933.    *Queries the corelink relay for available functions
  934.    *@returns {object} the object has functionList which is an array of functions names that the
  935.                       server has available
  936.    *@exports listServerFunctions
  937.    *@module listServerFunctions
  938.    */
  940.   async function listServerFunctions() {
  941.     return (new Promise(async (resolve, reject) => {
  942.       const request = {}
  943.       request.function = 'listServerFunctions'
  944.       request.token = token
  945.       const content = await control.request(request).catch((e) => reject(e))
  946.       if ('functionList' in content) resolve(content)
  947.       else reject(new Error('functionList not found.'))
  948.     }))
  949.   }
  951.   /**
  952.    *Queries a specific function to get its self descriptor
  953.    *@param {String} options Options object, it has to have a function name
  954.    *@returns {Object} JSON object that describes the function
  955.    *@exports describeFunction
  956.    *@module describeFunction
  957.    */
  959.   async function describeFunction(options) {
  960.     return (new Promise(async (resolve, reject) => {
  961.       // checking inputs
  962.       if (typeof options !== 'object') reject(new Error('No object supplied.'))
  963.       if (!('functionName' in options)) reject(new Error('No function name found.'))
  965.       const request = {}
  966.       request.function = 'describeFunction'
  967.       request.functionName = options.functionName
  968.       request.token = token
  969.       const content = await control.request(request).catch((e) => reject(e))
  970.       if ('description' in content) resolve(content)
  971.       else reject(new Error('description not found.'))
  972.     }))
  973.   }
  975.   /**
  976.    *Queries a specific function to get its self descriptor
  977.    *@param {String} options Options object, it has to have a server function name
  978.    *@returns {Object} JSON object that describes the function
  979.    *@exports describeServerFunction
  980.    *@module describeServerFunction
  981.    */
  983.   async function describeServerFunction(options) {
  984.     return (new Promise(async (resolve, reject) => {
  985.       // checking inputs
  986.       if (!('functionName' in options)) reject(new Error('No function name found.'))
  988.       const request = {}
  989.       request.function = 'describeServerFunction'
  990.       request.functionName = options.functionName
  991.       request.token = token
  992.       const content = await control.request(request).catch((e) => reject(e))
  993.       if ('description' in content) resolve(content)
  994.       else reject(new Error('description not found.'))
  995.     }))
  996.   }
  998.   /**
  999.    *Get the receiverID of the current active receiver
  1000.    *@returns {String} receiverID Receiver streamID to remove streams from
  1001.    *@module getReceiverID
  1002.    */
  1004.   async function getReceiverID() {
  1005.     return receiverStream.streamID
  1006.   }
  1008.   /**
  1009.    *Queries the corelink relay for available functions
  1010.    *@param {array} workspaces an array of workspaces to list streams, omitted or empty array
  1011.                               will list all workspaces that a user has access to
  1012.    *@param {array} types an array of types of streams to list
  1013.    *@returns {object} with senderStreams and receiverStreams arrays
  1014.    *@exports listStreams
  1015.    *@module listStreams
  1016.    */
  1018.   async function listStreams(options) {
  1019.     return (new Promise(async (resolve, reject) => {
  1020.       const request = options || {}
  1021.       request.function = 'listStreams'
  1022.       request.token = token
  1023.       if (!('workspaces' in request)) request.workspaces = []
  1024.       if (!('types' in request)) request.types = []
  1025.       const content = await control.request(request).catch((e) => reject(e))
  1026.       resolve(content)
  1027.     }))
  1028.   }
  1030.   /**
  1031.   *In the request made, subscribe function from Corelink protocol is called which
  1032.   *gets the value of streamID and token. Further,the streamList array is checked
  1033.   *to see if it has target streamList.
  1034.   *@param {String} options objet. Allows a user to select streams to subscribe to.
  1035.       The options object should hold and array of streamIDs. If streamIDs or options
  1036.       is not given, all streams are sent
  1037.   *@module subscribe
  1038.   */
  1040.   async function subscribe(options) {
  1041.     return (new Promise(async (resolve, reject) => {
  1042.       let workOptions
  1043.       if (typeof options === 'undefined') workOptions = {}
  1044.       else workOptions = options
  1046.       if (!('streamIDs' in workOptions)) workOptions.streamIDs = []
  1048.       const request = `{"function":"subscribe","receiverID":"${receiverStream.streamID}","streamIDs":${JSON.stringify(workOptions.streamIDs)},"token":"${token}"}`
  1049.       if (debug) console.log('subscribe request', request)
  1050.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  1051.       if (debug) console.log('subscribe json', content)
  1053.       if ('streamList' in content) receiverStream.streamList = content.streamList
  1054.       else reject(new Error('Target streamList not found.'))
  1056.       for (const stream in content.streamList) {
  1057.         if (!allowedStreams.includes(content.streamList[stream].streamID)) {
  1058.           allowedStreams.push(content.streamList[stream].streamID)
  1059.         }
  1060.       }
  1061.       if (debug) console.log('subscribe streamList', content.streamList)
  1062.       resolve(content.streamList)
  1063.     }))
  1064.   }
  1067.   /**
  1068.   *In the request made, subscribe function from Corelink protocol is called which
  1069.   *gets the value of streamID and token. Further,the streamList array is checked
  1070.   *to see if it has target streamList. The function expects an object with the
  1071.   *following parameters:
  1072.   *@param {array} streamIDs Allows a user to select streams to unsubscribe from.
  1073.                             If streamIDs are not given or empty all are unsubscribed from
  1074.   *@module unsubscribe
  1075.   */
  1077.   async function unsubscribe(options) {
  1078.     return (new Promise(async (resolve, reject) => {
  1079.       let workOptions
  1080.       if (typeof options === 'undefined') workOptions = {}
  1081.       else workOptions = options
  1083.       if (!('streamIDs' in workOptions)) workOptions.streamIDs = []
  1085.       const request = `{"function":"unsubscribe","receiverID":${receiverStream.streamID},"streamIDs":${JSON.stringify(workOptions.streamIDs)},"token":"${token}"}`
  1086.       if (debug) console.log('unsubscribe request', request)
  1087.       const content = await control.request(JSON.parse(request)).catch((e) => reject(e))
  1088.       if (debug) console.log('unsubscribe json', content)
  1090.       for (let i = 0; i < allowedStreams.length; i += 1) {
  1091.         if (content.streamList.includes(allowedStreams[i])) delete allowedStreams[i]
  1092.       }
  1093.       resolve(content.streamList)
  1094.     }))
  1095.   }
  1098.   /**
  1099.   *Function to register event handlers for specific events
  1100.   *@param {array} type type of event:
  1101.     - receiver: calls back with new streams that are available
  1102.     - sender: calls back with new streams that are subscribed
  1103.     - stale: call back with streams that went stale for this receiver and can be unsubscribed
  1104.     - dropped: calls back with streams that dropped the subscription for a sender
  1105.     - close: the control connection was closed
  1106.     - data: calls back when data has arrived with (streamID, data, header)
  1107.   *@param {array} cb a function with the corresponding callback
  1108.   *@module on
  1109.   */
  1111.   const on = (async function on(type, cb) {
  1112.     switch (type) {
  1113.       case 'receiver':
  1114.         receiverCb = cb
  1115.         break
  1116.       case 'sender':
  1117.         senderCb = cb
  1118.         break
  1119.       case 'data':
  1120.         dataCb = cb
  1121.         break
  1122.       case 'stale':
  1123.         staleCb = cb
  1124.         break
  1125.       case 'dropped':
  1126.         droppedCb = cb
  1127.         break
  1128.       case 'close':
  1129.         closeCb = cb
  1130.         break
  1131.       default:
  1132.         break
  1133.     }
  1134.   })
  1137.   /**
  1138.    *Queries server functions that dont need special parameters
  1139.     *@param {object} options Options object,
  1140.             if generic is called the function name and the parameters need to be in a JSON object according to
  1141.             https://corelink.hpc.nyu.edu/documentation/server-documentation/client-initiated-control-functions
  1142.    *@returns {Object} JSON object that contains the function result
  1143.    *@exports generic
  1144.    *@module generic
  1145.    */
  1147.   async function generic(options) {
  1148.     return (new Promise(async (resolve, reject) => {
  1149.       // checking inputs
  1150.       const workOptions = options
  1151.       if (typeof workOptions !== 'object') reject(new Error('No object supplied.'))
  1152.       if (!('function' in workOptions)) reject(new Error('No function name'))
  1154.       // adding token to request
  1155.       if (!workOptions.token) workOptions.token = token
  1156.       if (debug) console.log(workOptions)
  1157.       const content = await control.request(workOptions).catch((e) => reject(e))
  1158.       if (content) resolve(content)
  1159.       else reject(new Error('Wrong Expresions.'))
  1160.     }))
  1161.   }
  1164.   /**
  1165.    *Requests a disconnect streams
  1166.    *@param {String} workspaces Workspaces are used to separate out groups of
  1167.     streams so that several independent groups of researchers can work together.
  1168.    *@param {String} types disconnect only streams of a particular type.
  1169.    *@param {String} streamIDs Allows a user to select streams to Subscribe to. If
  1170.     StreamID is not given, all streams are sent, the streamIDs have to be numbers
  1171.    *@returns {object} in the object there will be the array streamList
  1172.    *@module disconnect
  1173.   */
  1175.   async function disconnect(options) {
  1176.     return (new Promise(async (resolve, reject) => {
  1177.       console.log('options', options)
  1178.       const request = {}
  1179.       request.types = []
  1180.       request.workspaces = []
  1181.       request.streamIDs = []
  1183.       if (typeof options === 'object') {
  1184.         if (('types' in options) && Array.isArray(options.types) && (options.types.length > 0)) request.types = request.types.concat(options.types)
  1185.         if (('types' in options) && (typeof options.types === 'string')) request.types.push(options.types)
  1186.         if (('workspaces' in options) && Array.isArray(options.workspaces) && (options.workspaces.length > 0)) request.workspaces = request.workspaces.concat(options.workspaces)
  1187.         if (('workspaces' in options) && (typeof options.workspaces === 'string')) request.workspaces.push(options.workspaces)
  1188.         if (('streamIDs' in options) && Array.isArray(options.streamIDs) && (options.streamIDs.length > 0)) request.streamIDs = request.streamIDs.concat(options.streamIDs)
  1189.         if (('streamIDs' in options) && (typeof options.streamIDs === 'number')) request.streamIDs.push(options.streamIDs)
  1190.       }
  1191.       request.function = 'disconnect'
  1192.       request.token = token
  1194.       if (debug) console.log('disconnect request', request)
  1195.       const content = await control.request(request).catch((e) => reject(e))
  1196.       if (debug) console.log('disconnect content', content)
  1197.       resolve(content)
  1198.     }))
  1199.   }
  1201.   /**
  1202.    *This module gets all local streamIDs and,checks if they are undefined and
  1203.     pushes them. The connection then waits for a disconnect to occur.
  1204.    *@param {String} resolve If all streamIDs are fetched successfully for a
  1205.     successful disconnect
  1206.    *@param {String} reject If all streamIDs are not fetched, an error message is displayed
  1207.    *@module exit
  1208.   */
  1209.   async function exit() {
  1210.     console.log('Trying to exit.')
  1211.     return (new Promise((async (resolve, reject) => {
  1212.       // get all local streamID's
  1213.       const streamIDs = []
  1214.       if (typeof receiverStream.streamID !== 'undefined') streamIDs.push(receiverStream.streamID)
  1215.       for (const streamID in senderStreams) if (streamID) streamIDs.push(parseInt(streamID, 10))
  1216.       if (debug) console.log('Exit: Disconnect Request.')
  1217.       const dis = await disconnect({ streamIDs }).catch((err) => reject(err))
  1218.       if (dis === true) resolve(true)
  1219.       else reject(dis)
  1220.     })))
  1221.   }
  1223.   // End Common Functions
  1226.   this.debug = debug
  1227.   this.on = on
  1228.   this.connect = connect
  1229.   this.setDebug = setDebug
  1230.   this.generic = generic
  1231.   this.addWorkspace = addWorkspace
  1232.   this.rmWorkspace = rmWorkspace
  1233.   this.setDefaultWorkspace = setDefaultWorkspace
  1234.   this.getDefaultWorkspace = getDefaultWorkspace
  1235.   this.listWorkspaces = listWorkspaces
  1236.   this.listFunctions = listFunctions
  1237.   this.listServerFunctions = listServerFunctions
  1238.   this.describeFunction = describeFunction
  1239.   this.describeServerFunction = describeServerFunction
  1240.   this.createSender = createSender
  1241.   this.send = send
  1242.   this.subscribe = subscribe
  1243.   this.unsubscribe = unsubscribe
  1244.   this.disconnect = disconnect
  1245.   this.createReceiver = createReceiver
  1246.   this.getReceiverID = getReceiverID
  1247.   this.exit = exit
  1248.   this.login = login
  1249.   this.setConfig = setConfig
  1250.   this.listStreams = listStreams
  1251.   this.listUsers = listUsers
  1252.   this.rmUser = rmUser
  1253.   this.addUser = addUser
  1254.   this.password = password
  1255.   this.listGroups = listGroups
  1256.   this.rmGroup = rmGroup
  1257.   this.addGroup = addGroup
  1258.   this.addUserGroup = addUserGroup
  1259.   this.rmUserGroup = rmUserGroup
  1260.   this.changeOwner = changeOwner
  1261. }).apply(corelink)