/// <summary>
        /// Constructor for specifying a Pooled Instance of RBroker
        /// </summary>
        /// <param name="brokerConfig">Pooled Broker Configuration object</param>
        /// <remarks></remarks>
        public PooledTaskBroker(PooledBrokerConfig brokerConfig)
            : base((RBrokerConfig)brokerConfig)
        {
            m_rClient = RClientFactory.createClient(brokerConfig.deployrEndpoint, brokerConfig.maxConcurrentTaskLimit);

            m_rUser = m_rClient.login(brokerConfig.userCredentials);

            if (brokerConfig.poolCreationOptions != null)
            {
                if (brokerConfig.poolCreationOptions.releaseGridResources == true)
                {
                    m_rUser.releaseProjects();
                }
            }

            ProjectCreationOptions options = ROptionsTranslator.translate(brokerConfig.poolCreationOptions);

            List <RProject> deployrProjectPool = m_rUser.createProjectPool(brokerConfig.maxConcurrentTaskLimit, options);

            /*
             * Prep the base RBrokerEngine.
             */

            initEngine(deployrProjectPool.Count());

            /*
             * Initialize the resourceTokenPool with RProject.
             */
            foreach (RProject rProject in deployrProjectPool)
            {
                m_resourceTokenPool.TryAdd(rProject);
            }

            try
            {
                Task.Factory.StartNew(() => HTTPKeepAliveManager(m_rUser));
            }
            catch (Exception rex)
            {
                shutdown();
                throw new Exception("Broker failed to start HTTP keep-alive manager, cause: " + rex.ToString());
            }
        }
        static public void Execute()
        {
            Console.WriteLine("AuthProjectPoolCreate - start");

            //
            // 1. Connect to the DeployR Server
            //
            RClient rClient = Utility.Connect();

            //
            // 2. Authenticate the user
            //
            RUser rUser = Utility.Authenticate(rClient);

            //
            // 3. Create a pool of temporary projects (R sessions).
            //
            // Population options as needed.
            //
            int requestedPoolSize          = 4;
            ProjectCreationOptions options = new ProjectCreationOptions();
            List <RProject>        pool    = rUser.createProjectPool(requestedPoolSize, options);

            Console.WriteLine("AuthProjectPoolCreate: created pool of " +
                              pool.Count + " temporary R sessions, pool=" + pool);


            //
            //  5. Cleanup
            //
            foreach (RProject rProject in pool)
            {
                rProject.close();
            }

            Utility.Cleanup(rUser, rClient);

            Console.WriteLine("AuthProjectPoolCreate - end");
        }
        public static ProjectCreationOptions translate(PoolCreationOptions poolOptions)
        {
            ProjectCreationOptions options = null;

            if (poolOptions != null)
            {
                options = new ProjectCreationOptions();

                /*
                 * PoolCreationOptions to ProjectCreationOptions.
                 */

                options.rinputs = poolOptions.rinputs;

                if (poolOptions.preloadWorkspace != null)
                {
                    options.preloadWorkspace           = new ProjectPreloadOptions();
                    options.preloadWorkspace.filename  = poolOptions.preloadWorkspace.filename;
                    options.preloadWorkspace.directory = poolOptions.preloadWorkspace.directory;
                    options.preloadWorkspace.author    = poolOptions.preloadWorkspace.author;
                    options.preloadWorkspace.version   = poolOptions.preloadWorkspace.version;
                }

                if (poolOptions.preloadDirectory != null)
                {
                    options.preloadDirectory           = new ProjectPreloadOptions();
                    options.preloadDirectory.filename  = poolOptions.preloadDirectory.filename;
                    options.preloadDirectory.directory = poolOptions.preloadDirectory.directory;
                    options.preloadDirectory.author    = poolOptions.preloadDirectory.author;
                    options.preloadDirectory.version   = poolOptions.preloadDirectory.version;
                }

                options.preloadByDirectory = poolOptions.preloadByDirectory;
            }

            return(options);
        }