public PlatformConfigurationManager(IPlatformDatabaseConfiguration uiConfiguration) : base(uiConfiguration) { var config = (PlatformDatabaseConfiguration)uiConfiguration; config.SqlEngineEdition = ConfigurationManagerUtils.GetSqlEngineEdition(uiConfiguration); }
public void CheckRoles(out string friendlyMessage, UserType user, string username) { try { bool hasLogRole = false, owner = false, canRead = false, canWrite = false; bool hasAccessAdmin = false, hasDDLAdmin = false, hasSecurityAdmin = false; var config = ((TwoUserDatabaseConfiguration)uiConfiguration).RuntimeDatabaseConfiguration(user); try { ConfigurationManagerUtils.GetDBUserRoles(username, ref hasLogRole, ref owner, ref canRead, ref canWrite, ref hasAccessAdmin, ref hasDDLAdmin, ref hasSecurityAdmin, config); if (!owner) { if (!CheckDBRolesForUserType(user, username, canRead, canWrite, hasAccessAdmin, hasSecurityAdmin, hasDDLAdmin, hasLogRole, out friendlyMessage)) { return; } } if (!ConfigurationManagerUtils.CheckHubServerVersion(this, config, out friendlyMessage)) { return; } } catch { friendlyMessage = "Database connection was successful.\r\n\r\nHowever, it was not possible to read the schema version. This may be because the schema has not been created yet."; return; } } catch (Exception exception) { friendlyMessage = "Database connection was successful.\r\n\r\nHowever the following error ocurred while trying to read user permissions:\r\n\r\nFailed to retrieve user roles:\r\n\r\n" + exception.Message; return; } friendlyMessage = "Test completed successfully."; }
public override void Pre_CreateOrUpgradePlatform() { NormalizeAllUsers(); var elevated = (IElevatedUserConfiguration)uiConfiguration; var masterElevated = ConfigurationManagerUtils.ConfigurationToMaster(elevated); var runtimeElevated = (RuntimeDatabaseConfiguration)elevated.ElevatedRuntimeDatabaseConfiguration(); bool isAzureDB = ConfigurationManagerUtils.IsDatabaseAzure(masterElevated); if (isAzureDB) { // On the unlikely scenario of an on-premise installation with Azure SQL, // we try to minimise the chance of timeouts. ConfigurationManagerUtils.QueryTimeout = 300; } ConfigurationManagerUtils.CheckIfUserHasNecessaryElevatedPermissions(masterElevated); if (!isAzureDB) { ConfigurationManagerUtils.CreateSqlServerCatalogIfDoesntExist(masterElevated, runtimeElevated.Catalog); } else { // We will not support automatically creating Azure databases. // An appropriate message is displayed. ConfigurationManagerUtils.CheckIfAzureDatabaseExists(masterElevated, runtimeElevated.Catalog); } ConfigurationManagerUtils.GrantUserPermissions((PlatformDatabaseConfiguration)uiConfiguration); ConfigurationManagerUtils.AddHubLogRole(runtimeElevated); }
public virtual void run() { if (this.showConfig) { ConfigurationManagerUtils.showConfig(this.cm); } if (this.showHTML) { try { HTMLDumper.showConfigAsHTML(this.cm, "foo.html"); } catch (IOException ex) { this.logger.warning(new StringBuilder().append("Can't open ").append(this.htmlPath).append(' ').append(ex).toString()); } } if (this.showGDL) { try { GDLDumper.showConfigAsGDL(this.cm, this.gdlPath); } catch (IOException ex4) { this.logger.warning(new StringBuilder().append("Can't open ").append(this.gdlPath).append(' ').append(ex4).toString()); } } if (this.saveXML) { ConfigurationManager configurationManager = this.cm; ConfigurationManagerUtils.save(configurationManager, new File(this.xmlPath)); } }
/* * (non-Javadoc) * * @see * edu.cmu.sphinx.util.props.Configurable#newProperties(edu.cmu.sphinx.util * .props.PropertySheet) */ public override void NewProperties(PropertySheet ps) { base.NewProperties(ps); BaseUrl = ConfigurationManagerUtils.GetResource(PropBaseGrammarUrl, ps); //logger = ps.getLogger(); GrammarName = ps.GetString(PropGrammarName); LoadGrammar = true; }
private static void GrantPlatformPermissions(PlatformDatabaseConfiguration platformConfiguration) { try { ConfigurationManagerUtils.ExecuteStatements( platformConfiguration.ElevatedRuntimeDatabaseConfiguration(), GetGrantPlatformPermissionsStatements(platformConfiguration.RuntimeUser)); } catch { } }
public override bool TestSessionConnection(out string friendlyMessage) { NormalizeWindowsUser(); bool result = base.TestSessionConnection(out friendlyMessage); ConfigurationManagerUtils.CheckSessionRoles(sessionConfiguration, out friendlyMessage); return(result); }
public override void newProperties(PropertySheet ps) { base.newProperties(ps); this.logger = ps.getLogger(); this.logMath = LogMath.getLogMath(); this.baseURL = ConfigurationManagerUtils.getResource("grammarLocation", ps); this.grammarName = ps.getString("grammarName"); this.loadGrammar = true; }
public SessionConfigurationManager(ISessionDatabaseConfiguration sessionConfiguration) : base(sessionConfiguration) { PreProcessedStatements = new ArrayList(); var config = (SessionDatabaseConfiguration)sessionConfiguration; config.SqlEngineEdition = ConfigurationManagerUtils.GetSqlEngineEdition(sessionConfiguration); }
// TODO jmt: remove the systemDatabaseName parameter after we don't need synonyms anymore. public TwoUserDatabaseConfigurationManager(ISettableTwoUserDatabaseConfiguration uiConfiguration, IPlatformDatabaseConfiguration systemDatabaseconfig) : base(uiConfiguration) { extraTokens.Add("[SYSTEM_DB]", ((IDatabaseConfiguration)systemDatabaseconfig).Catalog); var config = (TwoUserDatabaseConfiguration)uiConfiguration; config.SqlEngineEdition = ConfigurationManagerUtils.GetSqlEngineEdition(uiConfiguration); }
/* * (non-Javadoc) * * @see * edu.cmu.sphinx.util.props.Configurable#newProperties(edu.cmu.sphinx.util * .props.PropertySheet) */ public override void NewProperties(PropertySheet ps) { wordDictionaryFile = ConfigurationManagerUtils.GetResource(PropDictionary, ps); fillerDictionaryFile = ConfigurationManagerUtils.GetResource(PropFillerDictionary, ps); addendaUrlList = ps.GetResourceList(PropAddenda); wordReplacement = ps.GetString(PropWordReplacement); unitManager = (UnitManager)ps.GetComponent(PropUnitManager); g2pModelFile = ConfigurationManagerUtils.GetResource(PropG2PModelPath, ps); g2pMaxPron = ps.GetInt(PropG2PMaxPronunciations); }
public void NewProperties(PropertySheet ps) { Init(ConfigurationManagerUtils.GetResource(PropLocation, ps), ps.GetString(PropModel), ps.GetString(PropDataLocation), (UnitManager)ps.GetComponent(PropUnitManager), ps.GetFloat(PropMcFloor), ps.GetFloat(PropMwFloor), ps.GetFloat(PropVarianceFloor), ps.GetInt(PropTopn), ps.GetBoolean(PropUseCdUnits)); }
public override string GenerateSetupScript() { NormalizeAllUsers(); //for P10 the setup script is going to be generated by the conf tool to avoid duplication string setupScript = ConfigurationManagerUtils.ReplaceTokens((TwoUserDatabaseConfiguration)uiConfiguration, ReadScriptFile(StreamForSetupScriptFile), extraTokens); return(setupScript); }
public virtual void newProperties(PropertySheet ps) { this.logger = ps.getLogger(); if (this.allocated) { string text = "Can't change properties after allocation"; throw new RuntimeException(text); } this.classDefsLocation = ConfigurationManagerUtils.getResource("classDefsLocation", ps); }
public override bool TestLogConnection(out string friendlyMessage, Source source) { NormalizeLogUser(); bool result = base.TestLogConnection(out friendlyMessage, source); if (result) { ConfigurationManagerUtils.CheckRoles(uiConfiguration, out friendlyMessage, source, User.Log, uiConfiguration.LogAuthenticationCredential.UserName); } return(result); }
public override bool RequiresElevatedPrivilges() { try { RuntimeDatabaseConfiguration confAdmin = (RuntimeDatabaseConfiguration)uiConfiguration.RuntimeDatabaseConfiguration(Source.Services, User.Admin); return(ConfigurationManagerUtils.LoginExists(confAdmin, confAdmin.Username) == false || ConfigurationManagerUtils.DatabaseExists(confAdmin, confAdmin.Catalog) == false); } catch { return(base.RequiresElevatedPrivilges()); } }
public override void newProperties(PropertySheet ps) { this.logger = ps.getLogger(); this.wordDictionaryFile = ConfigurationManagerUtils.getResource("dictionaryPath", ps); this.fillerDictionaryFile = ConfigurationManagerUtils.getResource("fillerPath", ps); this.addendaUrlList = ps.getResourceList("addenda"); this.wordReplacement = ps.getString("wordReplacement"); this.unitManager = (UnitManager)ps.getComponent("unitManager"); this.g2pModelFile = ConfigurationManagerUtils.getResource("g2pModelPath", ps); this.g2pMaxPron = ps.getInt("g2pMaxPron"); }
public string execute(CommandInterpreter commandInterpreter, string[] array) { if (array.Length != 4) { commandInterpreter.putResponse("Usage: set component property value"); } else { ConfigurationManagerUtils.setProperty(this.this_0.cm, array[1], array[3], array[2]); } return(""); }
public override IEnumerable <Block> ExtraDatabaseStatements(Version currentModelVersion) { // Create an extra Block for the current version to add extra permissions to runtime user. var newBlock = new Block(); newBlock.SetTagValue(Tag.END_IGNORING_BLOCK.ToString(), ""); string runtimeuser = ((PlatformDatabaseConfiguration)uiConfiguration).RuntimeUser; ConfigurationManagerUtils.GetGrantRuntimePermissionsStatements(runtimeuser).Apply(statement => newBlock.AddStatement(statement)); GetGrantPlatformPermissionsStatements(runtimeuser).Apply(statement => newBlock.AddStatement(statement)); yield return(newBlock); }
public string execute(CommandInterpreter commandInterpreter, string[] array) { if (array.Length != 2) { commandInterpreter.putResponse("Usage: save filename.xml"); } else { ConfigurationManager cm = this.this_0.cm; ConfigurationManagerUtils.save(cm, new File(array[1])); } return(""); }
public void CMU_ComponentProperty() { var configFile = new URL(Helper.FilesDirectory + "/util/props/ConfigurationManagerTest.testconfig.sxl"); var cm = new ConfigurationManager(configFile); const int newBeamWidth = 4711; ConfigurationManagerUtils.SetProperty(cm, "beamWidth", newBeamWidth.ToString(CultureInfo.InvariantCulture)); var dummyComp = (DummyComp)cm.Lookup("duco"); Assert.AreEqual(newBeamWidth, dummyComp.GetBeamWidth()); }
public override bool RequiresElevatedPrivilges() { try { RuntimeDatabaseConfiguration confAdmin = (RuntimeDatabaseConfiguration)((TwoUserDatabaseConfiguration)uiConfiguration).RuntimeDatabaseConfiguration(UserType.Admin); RuntimeDatabaseConfiguration confRuntime = (RuntimeDatabaseConfiguration)((TwoUserDatabaseConfiguration)uiConfiguration).RuntimeDatabaseConfiguration(UserType.Runtime); return(ConfigurationManagerUtils.LoginExists(confAdmin, confAdmin.Username) == false || ConfigurationManagerUtils.LoginExists(confRuntime, confRuntime.Username) == false || ConfigurationManagerUtils.DatabaseExists(confAdmin, confAdmin.Catalog) == false); } catch { return(base.RequiresElevatedPrivilges()); } }
/* * (non-Javadoc) * @see * edu.cmu.sphinx.util.props.Configurable#newProperties(edu.cmu.sphinx. * util.props.PropertySheet) */ public override void NewProperties(PropertySheet ps) { Location = ConfigurationManagerUtils.GetResource(PropLocation, ps); NgramLogFile = ps.GetString(PropQueryLogFile); NgramCacheSize = ps.GetInt(PropNgramCacheSize); ClearCacheAfterUtterance = ps.GetBoolean(PropClearCachesAfterUtterance); MaxDepth = ps.GetInt(PropMaxDepth); Dictionary = (IDictionary)ps.GetComponent(PropDictionary); ApplyLanguageWeightAndWip = ps.GetBoolean(PropApplyLanguageWeightAndWip); LanguageWeight = ps.GetFloat(PropLanguageWeight); Wip = ps.GetDouble(PropWordInsertionProbability); UnigramWeight = ps.GetFloat(PropUnigramWeight); FullSmear = ps.GetBoolean(PropFullSmear); }
/// <summary> /// Replaces known tokens in the given statement /// </summary> /// <param name="statement"></param> /// <returns></returns> private string ReplaceTokens(string statement) { PlatformDatabaseConfiguration conf = (PlatformDatabaseConfiguration)uiConfiguration; const string TAG_LOGUSERNAME = "******"; const string TAG_LOGPASSWORD = "******"; var tokenMap = new Dictionary <string, string>() { { TAG_LOGUSERNAME, conf.LogUser }, { TAG_LOGPASSWORD, conf.LogPassword }, }; return(ConfigurationManagerUtils.ReplaceTokens(conf, statement, tokenMap)); }
public override void NewProperties(PropertySheet ps) { logMath = LogMath.GetLogMath(); location = ConfigurationManagerUtils.GetResource(PropLocation, ps); ngramLogFile = ps.GetString(PROP_QUERY_LOG_FILE); MaxDepth = ps.GetInt(LanguageModel.PropMaxDepth); ngramCacheSize = ps.GetInt(PROP_NGRAM_CACHE_SIZE); clearCacheAfterUtterance = ps.GetBoolean(PROP_CLEAR_CACHES_AFTER_UTTERANCE); dictionary = (IDictionary)ps.GetComponent(PropDictionary); applyLanguageWeightAndWip = ps.GetBoolean(PROP_APPLY_LANGUAGE_WEIGHT_AND_WIP); languageWeight = ps.GetFloat(PROP_LANGUAGE_WEIGHT); logWip = logMath.LinearToLog(ps.GetDouble(PROP_WORD_INSERTION_PROBABILITY)); unigramWeight = ps.GetFloat(PropUnigramWeight); }
public override void newProperties(PropertySheet ps) { this.logger = ps.getLogger(); this.logMath = LogMath.getLogMath(); this.location = ConfigurationManagerUtils.getResource("location", ps); this.ngramLogFile = ps.getString("queryLogFile"); this.maxDepth = ps.getInt("maxDepth"); this.ngramCacheSize = ps.getInt("ngramCacheSize"); this.clearCacheAfterUtterance = ps.getBoolean("clearCachesAfterUtterance").booleanValue(); this.dictionary = (dictionary.Dictionary)ps.getComponent("dictionary"); this.applyLanguageWeightAndWip = ps.getBoolean("applyLanguageWeightAndWip").booleanValue(); this.languageWeight = ps.getFloat("languageWeight"); this.logWip = this.logMath.linearToLog(ps.getDouble("wordInsertionProbability")); this.unigramWeight = ps.getFloat("unigramWeight"); }
public override bool CheckDBRolesForUserType(UserType user, string username, bool canRead, bool canWrite, bool hasAccessAdmin, bool hasSecurityAdmin, bool hasDDLAdmin, bool hasLogRole, out string friendlyMessage) { friendlyMessage = ""; switch (user) { case UserType.Admin: return(ConfigurationManagerUtils.CheckDBAdminRoles(username, hasAccessAdmin, hasSecurityAdmin, hasDDLAdmin, canRead, canWrite, out friendlyMessage)); case UserType.Runtime: return(ConfigurationManagerUtils.CheckDBLogRoles(username, canRead, canWrite, hasLogRole, uiConfiguration.AuthenticationMode, out friendlyMessage)); } return(true); }
private void GrantPlatformDatabaseUserPermissions(PlatformDatabaseConfiguration dbConfig) { var configRuntime = dbConfig.ElevatedRuntimeDatabaseConfiguration(); var configMaster = ConfigurationManagerUtils.ConfigurationToMaster(dbConfig); var authType = dbConfig.AuthenticationMode; // Create User if (ConfigurationManagerUtils.NeedsCreate(configMaster, configRuntime, dbConfig.AdminUser)) { if (authType == AuthenticationType.Windows_Authentication) { ConfigurationManagerUtils.AddIntegratedAuthLogin(configRuntime, dbConfig.AdminUser); } else { ConfigurationManagerUtils.AddDBAuthLogin(configMaster, dbConfig.AdminUser, dbConfig.AdminPassword); } } if (ConfigurationManagerUtils.NeedsPermissionsForAdmin(configRuntime, dbConfig.AdminUser)) { ConfigurationManagerUtils.AddAdminPermissions(configRuntime, dbConfig.AdminUser); } if (ConfigurationManagerUtils.NeedsCreate(configMaster, configRuntime, dbConfig.RuntimeUser)) { if (authType == AuthenticationType.Windows_Authentication) { ConfigurationManagerUtils.AddIntegratedAuthLogin(configRuntime, dbConfig.RuntimeUser); } else { ConfigurationManagerUtils.AddDBAuthLogin(configMaster, dbConfig.RuntimeUser, dbConfig.RuntimePassword); } } if (ConfigurationManagerUtils.NeedsPermissionsForReadWrite(configRuntime, dbConfig.RuntimeUser, dbConfig.AuthenticationMode)) { ConfigurationManagerUtils.AddReadWritePermissions(configRuntime, dbConfig.RuntimeUser); } try { ConfigurationManagerUtils.AddRuntimePermissionsAfterUpgradeScript(configRuntime, dbConfig.RuntimeUser); } catch { } GrantPlatformPermissions(dbConfig); }
public override void Pre_CreateOrUpgradeSession() { NormalizeWindowsUser(); var elevated = (IElevatedUserConfiguration)sessionConfiguration; var masterElevated = ConfigurationManagerUtils.ConfigurationToMaster(elevated); var runtimeElevated = (RuntimeDatabaseConfiguration)elevated.ElevatedRuntimeDatabaseConfiguration(); bool isAzureDB = ConfigurationManagerUtils.IsDatabaseAzure(masterElevated); if (isAzureDB) { // On the unlikely scenario of an on-premise installation with Azure SQL, // we try to minimise the chance of timeouts. ConfigurationManagerUtils.QueryTimeout = 300; } ConfigurationManagerUtils.CheckIfUserHasNecessaryElevatedPermissions(masterElevated); if (!isAzureDB) { ConfigurationManagerUtils.CreateSqlServerCatalogIfDoesntExist(masterElevated, runtimeElevated.Catalog); } else { // We will not support automatically creating Azure databases. // An appropriate message is displayed. ConfigurationManagerUtils.CheckIfAzureDatabaseExists(masterElevated, runtimeElevated.Catalog); } // Prepare statements PreProcessedStatements.Add(ConfigurationManagerUtils.GrantSessionUserPermissions( (SessionDatabaseConfiguration)sessionConfiguration, (PlatformDatabaseConfiguration)platformConfiguration)); // Azure does not support changing the recovery model if (!isAzureDB) { try { // Set database recovery model to Simple ConfigurationManagerUtils.SetRecoveryModel(masterElevated, runtimeElevated.Catalog, "Simple"); } catch (Exception exception) { throw new ConfigurationOperationException("After the Configuration Tool closes, you must set the '" + runtimeElevated.Catalog + "' database recovery model to simple.", exception); } } }
public string execute(CommandInterpreter commandInterpreter, string[] array) { if (array.Length < 2) { ConfigurationManagerUtils.showConfig(this.this_0.cm); } else { for (int i = 1; i < array.Length; i++) { string name = array[i]; ConfigurationManagerUtils.showConfig(this.this_0.cm, name); } } return(""); }