/// <summary> /// Implementation of the refresh method on RBroker interface /// /// </summary> /// <param name="config">Pooled Broker Configuration object</param> /// <remarks></remarks> public new void refresh(RBrokerConfig config) { if (!status().isIdle) { throw new Exception("RBroker is not idle, refresh not permitted."); } if (!(config is PooledBrokerConfig)) { throw new Exception("PooledTaskBroker refresh requires PooledBrokerConfig."); } PooledBrokerConfig pooledConfig = (PooledBrokerConfig)config; try { /* * Temporarily disable RBroker to permit * configuration refresh. */ Interlocked.Exchange(ref m_refreshingConfig, 1); ProjectExecutionOptions options = ROptionsTranslator.migrate(pooledConfig.poolCreationOptions); foreach (Object resourceToken in m_resourceTokenPool) { RProject rProject = (RProject)resourceToken; /* * Recycle project to remove all existing * workspace objects and directory files. */ rProject.recycle(); /* * Execute code to cause workspace and directory * preloads and adoptions to take place. */ rProject.executeCode("# Refresh project on PooledTaskBroker.", options); } } catch (Exception rex) { throw new Exception("RBroker refresh failed with unexpected error=" + rex.ToString()); } finally { /* * Re-enabled RBroker following * configuration refresh. */ Interlocked.Exchange(ref m_refreshingConfig, 0); } }
/// <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()); } }
/// <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()); } }
/// <summary> /// Utility function for creating a Pooled Instance of RBroker /// </summary> /// <param name="brokerConfig">Pooled Broker Configuration object</param> /// <returns>PooledTaskBroker instance</returns> /// <remarks></remarks> public static RBroker pooledTaskBroker(PooledBrokerConfig brokerConfig) { return new PooledTaskBroker(brokerConfig); }
/// <summary> /// Implementation of RBroker Interface 'shutdown' method /// </summary> /// <remarks></remarks> public void shutdown() { Interlocked.Exchange(ref m_taskBrokerIsActive, 0); if (m_resourceTokenPool.Count > 0) { Boolean releaseGridResources = false; if (m_brokerConfig is PooledBrokerConfig) { PooledBrokerConfig pbcfg = (PooledBrokerConfig)m_brokerConfig; releaseGridResources = pbcfg.poolCreationOptions.releaseGridResources; } if (releaseGridResources) { /* * If PooledTaskBroker resource tokens * and rUser available, perform a server-wide * flush of projects on the grid. */ m_rUser.releaseProjects(); } else { /* * If PooledTaskBroker resource tokens * and rUser not available, perform * project-by-project flush on the grid. */ foreach (Object resourceToken in m_resourceTokenPool) { try { if (resourceToken is RProject) { RProject projectToken = (RProject)resourceToken; projectToken.close(); } } catch (Exception cex) { throw new Exception("RBroker: project close failed, cause: " + cex.ToString()); } } } } if (m_rClient != null) { try { if (m_rUser != null) { m_rClient.logout(m_rUser); } } catch (Exception rex) { throw new Exception("RBroker: RClient logout failed, cause: " + rex.ToString()); } } }
public static void Execute() { try { /* * 1. Prepare PooledBrokerConfig instance. * * This example creates an authenticated PooledTaskBroker * to act as our scoring engine. * * The following steps initialize the pool of * R sessions dedicated to our scoring engine. * * In this example, we pre-initialize the workspace * for each R session in the pool to contain the * R model used when scoring customer requests. * * The R model, insurModel.rData, is loaded from * the DeployR repository into each workspace at * startup time. Preloading the R model at startup * reduces runtime overhead and improves overall * response times in the application. */ RAuthentication rAuth = new RBasicAuthentication(Program.AUTH_USER_NAME, Program.AUTH_PASSWORD); PoolCreationOptions poolOptions = new PoolCreationOptions(); PoolPreloadOptions preloadOptions = new PoolPreloadOptions(); preloadOptions.filename = Program.TUTORIAL_INSURANCE_MODEL; preloadOptions.directory = Program.TUTORIAL_REPO_DIRECTORY; preloadOptions.author = Program.TUTORIAL_REPO_OWNER; poolOptions.preloadWorkspace = preloadOptions; /* * 2. Create RBroker instance. * * The application designer, in conjunction with the * DeployR administrator who provisions and sets * limits on DeployR grid resources, need to decide how * many R sessions will be reserved for the PooledRBroker * used by our scoring engine application. */ int TARGET_POOL_SIZE = 10; PooledBrokerConfig brokerConfig = new PooledBrokerConfig(Program.DEPLOYR_ENDPOINT, rAuth, TARGET_POOL_SIZE, poolOptions); Console.WriteLine("About to create pooledTaskBroker."); RBroker rBroker = RBrokerFactory.pooledTaskBroker(brokerConfig); Console.WriteLine("R session pool size, requested: " + TARGET_POOL_SIZE + " , actual: " + rBroker.maxConcurrency() + "\n"); /* * 3. Create an RTaskAppSimulator. It will drive * sample customer data scoring requests through the * RBroker. */ ScoringEngineSimulation simulation = new ScoringEngineSimulation(rBroker); /* * 4. Launch RTaskAppSimulator simulation. */ rBroker.simulateApp(simulation); /* * 5. Block until all tasks are complete, and shutdown has been called */ rBroker.waitUntilShutdown(); } catch(Exception tex) { Console.WriteLine("constructor: ex=" + tex.ToString()); } }
/// <summary> /// Utility function for creating a Pooled Instance of RBroker /// </summary> /// <param name="brokerConfig">Pooled Broker Configuration object</param> /// <returns>PooledTaskBroker instance</returns> /// <remarks></remarks> public static RBroker pooledTaskBroker(PooledBrokerConfig brokerConfig) { return(new PooledTaskBroker(brokerConfig)); }