public IList<SiqualFile> AddFileListToServer(IList<SiqualFile> files, DatabaseServer server)
{
server.AddFileRange(files);
_databaseRepository.SaveOrUpdate(server);
return files;
}
public DbServerSettings(DatabaseServer dbServer)
{
InitializeComponent();
DatabaseServer = dbServer ?? new DatabaseServer();
InitializeControls();
}
public bool SyncFileCollectionFromPath(ICollection<SiqualFile> files, DatabaseServer server, Project project)
{
string folderPath = project.FolderPath;
if (!Directory.Exists(folderPath))
return false;
string[] filePaths = Directory.GetFiles(folderPath, "*.sql", SearchOption.AllDirectories);
IList<SiqualFile> filesRemovedFromPath = new List<SiqualFile>();
foreach (SiqualFile file in files)
{
if (filePaths.FirstOrDefault(x => x == file.FullFilePath) != null) continue;
filesRemovedFromPath.Add(file);
_filesChanged = true;
}
foreach (string filePath in filePaths)
{
if (files.FirstOrDefault(x => x.FullFilePath == filePath) != null) continue;
files.Add(new SiqualFile(filePath, server, project));
_filesChanged = true;
}
foreach (SiqualFile fileToRemove in filesRemovedFromPath)
{
files.Remove(fileToRemove);
}
return _filesChanged;
}
public void RunScripts(DatabaseServer server, IList<int> fileIds, bool runAtomic)
{
IList<SiqualFile> notRanScript = server.GetScripts(fileIds);
_runAtomic = runAtomic;
_server = server;
_scripts = notRanScript;
_worker.RunWorkerAsync();
}
public void RunScript(DatabaseServer server, int fileId, bool runAtomic)
{
SiqualFile notRanScript = server.GetScript(fileId);
_runAtomic = runAtomic;
_server = server;
_scripts = new List<SiqualFile> { notRanScript };
_worker.RunWorkerAsync();
}
public void RunNewScripts(DatabaseServer server, bool runAtomic)
{
IList<SiqualFile> notRanScripts = server.GetNotRanScripts();
_runAtomic = runAtomic;
_server = server;
_scripts = notRanScripts;
_worker.RunWorkerAsync();
}
public StoredProcedure(DatabaseServer server, String name)
: base(DatabaseObjectType.StoredProcedure)
{
this.Name = name;
this.DatabaseServer = server;
this.Parameters = new List<SqlInputParameter>();
this.ResultSets = new List<StoredProcedureResultSetColumn>();
}
public void RunScripts(DatabaseServer server, IList<SiqualFile> scripts)
{
_server = server;
using (ISiqualConnection connection = _siqualConnectionManager.CreateConnectionFor(server))
{
connection.Open();
RunScriptsInternal(server, scripts, connection);
}
}
private void RunScriptsInternal(DatabaseServer server, IEnumerable<SiqualFile> files, ISiqualConnection connection)
{
_server = server;
foreach (SiqualFile file in files)
{
RunScriptWithStatistics(file, connection);
}
}
public DatabaseServer AddServerToProject(string serverAddress, string userName, string password, bool useWindowsAuth,Project existingProject)
{
DatabaseServer server = new DatabaseServer
{
Password = password,
ServerAddress = serverAddress,
UserName = userName,
UseWindowsAuth = useWindowsAuth
};
existingProject.AddServer(server);
_projectRepository.SaveOrUpdate(existingProject);
return server;
}
//private ConnectionInfo _connnectionInfo;
public QueryController(ConnectionInfo info)
{
//_connnectionInfo = info;
if (info.Type == "Oracle") {
_db = new OracleDatabase(info.ConnectionString);
} else if (info.Type == "SQL Server") {
_db = new SqlDatabase(info.ConnectionString);
} else {
throw new ApplicationException("Unable to connect to DB Type: '" + info.Type + "'");
}
_server = new DatabaseServer(info.Name);
_server.DefaultCatalog = new Catalog(info.InitialCatalog);
}
public static Boolean CanConnectToDatabase(DatabaseServer server, String connectionString)
{
switch (server)
{
case DatabaseServer.SqlServer:
{
var cn = new SqlServerDatabase(connectionString);
return cn.CanOpen();
}
case DatabaseServer.MySql:
{
var cn = new MySqlDatabase(connectionString);
return cn.CanOpen();
}
case DatabaseServer.Oracle:
case DatabaseServer.PostgreSql: throw new NotImplementedException();
default: throw new NotImplementedException();
}
}
public void RunScriptsAtomic(DatabaseServer server, IList<SiqualFile> scripts)
{
_runAtomic = true;
using (ISiqualConnection connection = _siqualConnectionManager.CreateConnectionFor(server))
{
try
{
connection.Open();
connection.BeginTransaction();
RunScriptsInternal(server, scripts, connection);
connection.Commit();
}
catch
{
connection.Rollback();
}
}
}
public static IDataReader ExecuteReader(DatabaseServer edt, string connection, ExecutionQuery executableQuery)
{
//ADO.NET objects are not disposed because of the CloseConnection CommandBehaviour.
IDataReader iread = null;
DbConnection icon = null;
DbCommand icmd = null;
DataFactory.InitializeDbConnection(edt, ref icon);
icon.ConnectionString = connection;
DataFactory.InitializeDbCommand(edt, ref icmd);
icmd.Connection = icon;
icmd.Parameters.Clear();
if (executableQuery.Parameters != null)
{
foreach (IDataParameter var in executableQuery.Parameters)
{
icmd.Parameters.Add(var);
}
}
icmd.CommandType = CommandType.Text;
icmd.CommandText = executableQuery.Query;
(new ExecutionEngineLogger()).LogContext(executableQuery);
icon.Open();
iread = icmd.ExecuteReader(CommandBehavior.CloseConnection);
return(iread);
}
public static void CriarGrafo()
{
Component c = new Component("Component", "192.168.0.1");
DatabaseServer ds = new DatabaseServer("Homolog_Server", "192.168.1.1");
DatabaseServer ds2 = new DatabaseServer("Producao_Server", "192.168.512.478");
ApplicationServer a = new ApplicationServer("App_User", "192.168.150.50");
ApplicationServer a2 = new ApplicationServer("App_User_Connection", "192.168.02.980");
Proxy p = new Proxy("Network_Proxy", "8.8.8.8");
User u = new User("Theduardds", "123456");
User u2 = new User("Afqf", "123456");
No component1 = new No(c);
No database1 = new No(ds);
No database2 = new No(ds2);
No applicationServer1 = new No(a);
No applicationServer2 = new No(a2);
No proxy1 = new No(p);
No user1 = new No(u);
No user2 = new No(u2);
G.AddVertice(component1);
G.AddVertice(database1);
G.AddVertice(database2);
G.AddVertice(applicationServer1);
G.AddVertice(applicationServer2);
G.AddVertice(proxy1);
G.AddVertice(user1);
G.AddVertice(user2);
G.AddAresta(user1, component1);
G.AddAresta(component1, applicationServer1);
G.AddAresta(applicationServer1, database1);
G.AddAresta(user1, proxy1);
G.AddAresta(proxy1, applicationServer1);
G.AddAresta(user2, component1);
G.AddAresta(component1, applicationServer2);
G.AddAresta(applicationServer2, database2);
}
/// <summary>
/// Executes the query, and returns the first column of the first row
/// in the result set returned by the query. Extra columns or rows are ignored.
/// </summary>
/// <param name="edt">Provider Type</param>
/// <param name="connectionString">Connection String</param>
/// <param name="storedProcedureName">The stored procedure's name</param>
/// <param name="iparams">Stored Procedure's parameters.</param>
/// <returns></returns>
public object ExecuteScalar(DatabaseServer edt, string connectionString, string storedProcedureName, params IDataParameter[] iparams)
{
DbConnection icon = null;
DbCommand icmd = null;
object result = null;
DataFactory factory = new DataFactory();
try
{
factory.InitializeDbConnection(edt, ref icon);
factory.InitializeDbCommand(edt, ref icmd);
icon.ConnectionString = connectionString;
icmd.Connection = icon;
icon.Open();
icmd.CommandType = CommandType.StoredProcedure;
icmd.CommandText = storedProcedureName;
if (iparams != null)
{
for (int i = 0; i < iparams.Length; i++)
{
icmd.Parameters.Add(iparams[i]);
}
}
(new ExecutionEngineLogger()).LogContext(storedProcedureName);
return(result = icmd.ExecuteScalar());
}
finally
{
DisposeObjects(ref icon, ref icmd);
}
}
private void listBoxConnections_DoubleClick(object sender, EventArgs e)
{
try
{
if (listBoxConnections.SelectedItems.Count > 0)
{
int index = listBoxConnections.SelectedIndex;
selectedConnection = scValue[index];
if (scDatabaseType[index].ToLower() == "access")
{
selectedDatabaseType = DatabaseServer.Access;
}
else if (scDatabaseType[index].ToLower() == "sqlserver")
{
selectedDatabaseType = DatabaseServer.SqlServer;
}
else if (scDatabaseType[index].ToLower() == "mysql")
{
selectedDatabaseType = DatabaseServer.MySql;
}
else if (scDatabaseType[index].ToLower() == "postgresql")
{
selectedDatabaseType = DatabaseServer.PostgreSQL;
}
DialogResult = DialogResult.OK;
Close();
}
}
catch
{
}
}
private TreeNodeViewModel CreateServerTreeNode(DatabaseServer server, bool warning)
{
TreeNodeViewModel serverNode = new TreeNodeViewModel()
{
IsExpanded = false,
NodeIcon = (warning) ? SERVER_WARNING_ICON : SERVER_ICON,
NodeText = string.IsNullOrWhiteSpace(server.Address)
? server.Name
: $"{server.Name} ({server.Address})",
NodeToolTip = (warning) ? "connection might be broken" : "connection is ok",
NodePayload = server
};
serverNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Edit server settings",
MenuItemIcon = SERVER_SETTINGS_ICON,
MenuItemCommand = new RelayCommand(EditDataServerCommand),
MenuItemPayload = serverNode
});
serverNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Add database",
MenuItemIcon = ADD_DATABASE_ICON,
MenuItemCommand = new RelayCommand(AddDatabaseCommand),
MenuItemPayload = serverNode
});
TreeNodeViewModel queues = CreateQueuesTreeNode(serverNode);
if (queues != null)
{
serverNode.TreeNodes.Add(queues);
}
return(serverNode);
}
private static string GenerateMsSqlServerConnectionString(DatabaseServer server, string database)
{
return(new SqlConnectionStringBuilder
{
DataSource = server.Server,
InitialCatalog = database,
UserID = server.UserId,
Password = server.Password,
Pooling = true,
MinPoolSize = 50,
/*
* https://docs.microsoft.com/en-us/azure/sql-database/sql-database-resource-limits#service-tiers-and-performance-levels
* eDTUs 50 100 125 200 250 300 400 500 800 1000 1200 1500 1600 2000 2500 3000 3500 4000
* Basic: 100 200 n/a 400 n/a 600 800 n/a 1600 n/a 2400 n/a 3200 n/a n/a n/a n/a n/a
* Standard: 100 200 n/a 400 n/a 600 800 n/a 1600 n/a 2400 n/a 3200 4000 5000 6000 n/a n/a
* Premium: n/a n/a 200 n/a 400 n/a n/a 800 n/a 1600 n/a 2400 n/a 3200 4000 4800 5600 6400
*/
MaxPoolSize = 200,
//MultipleActiveResultSets = true,
ConnectTimeout = 60 * 2,
TrustServerCertificate = true,
}.ToString());
}
/// <summary>
/// Query datas
/// </summary>
/// <typeparam name="T">Data type</typeparam>
/// <param name="server">Database server</param>
/// <param name="command">Command</param>
/// <returns>Return datas</returns>
public async Task <IEnumerable <T> > QueryAsync <T>(DatabaseServer server, ICommand command)
{
if (command.Query == null)
{
throw new EZNEWException("ICommand.Query is null");
}
#region query translate
IQueryTranslator translator = SqlServerFactory.GetQueryTranslator(server);
var tranResult = translator.Translate(command.Query);
string preScript = tranResult.PreScript;
string joinScript = tranResult.AllowJoin ? tranResult.JoinScript : string.Empty;
#endregion
#region script
string cmdText;
switch (command.Query.QueryType)
{
case QueryCommandType.Text:
cmdText = tranResult.ConditionString;
break;
case QueryCommandType.QueryObject:
default:
int size = command.Query.QuerySize;
string objectName = DataManager.GetEntityObjectName(DatabaseServerType.SQLServer, command.EntityType, command.ObjectName);
string orderString = string.IsNullOrWhiteSpace(tranResult.OrderString) ? string.Empty : $"ORDER BY {tranResult.OrderString}";
var queryFields = SqlServerFactory.GetQueryFields(command.Query, command.EntityType, true);
string outputFormatedField = string.Join(",", SqlServerFactory.FormatQueryFields(translator.ObjectPetName, queryFields, true));
if (string.IsNullOrWhiteSpace(tranResult.CombineScript))
{
cmdText = $"{preScript}SELECT {(size > 0 ? $"TOP {size}" : string.Empty)} {outputFormatedField} FROM {SqlServerFactory.WrapKeyword(objectName)} AS {translator.ObjectPetName} {joinScript} {(string.IsNullOrWhiteSpace(tranResult.ConditionString) ? string.Empty : $"WHERE {tranResult.ConditionString}")} {orderString}";
}
[HttpGet("{server}/database/{uuid?}")] public async Task <ActionResult> SelectDatabase([FromRoute] Guid server, [FromRoute] Guid uuid)
{
DatabaseServer srv = Metadata.Servers.Where(s => s.Identity == server).FirstOrDefault();
if (srv == null)
{
return(NotFound());
}
List <DatabaseInfo> databases = new List <DatabaseInfo>();
foreach (DatabaseInfo database in srv.Databases)
{
if (uuid == Guid.Empty || database.Identity == uuid)
{
databases.Add(new DatabaseInfo()
{
Name = database.Name,
Identity = database.Identity
});
}
}
if (uuid != Guid.Empty && databases.Count == 0)
{
return(NotFound());
}
JsonSerializerOptions options = new JsonSerializerOptions()
{
WriteIndented = true
};
string json = JsonSerializer.Serialize(databases, options);
return(Content(json));
}
private void CreateRouteNodesFromDatabase(TreeNodeViewModel rootNode)
{
DatabaseServer server = rootNode.GetAncestorPayload <DatabaseServer>();
IMessagingService messaging = Services.GetService <IMessagingService>();
ConfigureMessagingService(messaging, server, null);
if (!messaging.DaJetMQExists())
{
return;
}
DatabaseInfo database = new DatabaseInfo()
{
Name = DAJET_MQ_DATABASE_NAME,
UserName = server.UserName,
Password = server.Password
};
ConfigureMessagingService(messaging, server, database);
List <RouteInfo> routes = messaging.SelectRoutes(out string errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
_ = MessageBox.Show(errorMessage, "DaJet", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
TreeNodeViewModel routeNode;
foreach (RouteInfo route in routes)
{
routeNode = CreateRouteNode(rootNode, route);
rootNode.TreeNodes.Add(routeNode);
}
}
static void Main(string[] args)
{
DatabaseServer server = new DatabaseServer(5454);
server.Initialize();
//var db = new eVoteModel();
//Stopwatch stopwatch = new Stopwatch();
//Console.WriteLine(DateTime.Now);
//stopwatch.Start();
//VoteCounter c = new VoteCounter(db.Polls.First());
//c.CountVotes();
//stopwatch.Stop();
//Console.WriteLine(stopwatch.Elapsed);
//Console.WriteLine(DateTime.Now);
while (Console.ReadLine() != "q")
{
}
}
/// <summary>
/// Converts the specified DataField into a IDataParameter. This ensures that the
/// name of the parameter is unique by comparing with a list of specified used names
/// </summary>
/// <param name="database">Database server</param>
/// <param name="tableName">Name of the table to which the field belongs</param>
/// <param name="field">DatabaseField which will be converted</param>
/// <param name="listUsedParameterNames">List with used names of a parameter. When the name of the parameter is given it is checked against the values in this list. If the name if found then it is changed to be unique</param>
/// <returns>The IDataParameter</returns>
public IDataParameter ConvertToDataParameter(DatabaseServer database, string tableName, DatabaseField field, ref List <string> listUsedParameterNames)
{
IDataParameter parameter = null;
SqlGenerator generator = new SqlGenerator();
DataFactory factory = new DataFactory();
factory.InitializeDataParameter(database, ref parameter);
string parameterName = factory.GetParameterChar(database) + generator.GetTableName(tableName) + field.fieldName;
while (listUsedParameterNames.Contains(parameterName))
{
parameterName = parameterName + PARAMETER_NAME_ENDING;
}
parameter.ParameterName = parameterName;
//add it to the external list
listUsedParameterNames.Add(parameterName);
if (field.fieldValue == null)
{
parameter.Value = DBNull.Value;
}
else
{
parameter.Value = field.fieldValue;
}
parameter.DbType = field.fieldType;
parameter.SourceColumn = field.fieldName;
return(parameter);
}
/// <summary>
/// Initializes a DataParameter.
/// </summary>
/// <param name="database">Database server type</param>
/// <param name="iparam">DataParameter which will be initialized</param>
public void InitializeDataParameter(DatabaseServer database, ref IDataParameter iparam)
{
//check for new provider in the custom providers list.
if (loadedProviders.ContainsKey(database.ToString().ToLower()))
{
string fileName = string.Empty;
loadedProviders.TryGetValue(database.ToString().ToLower(), out fileName);
if (fileName == ODBC_DRIVER)
{
InitializeODBCDataParameter(ref iparam);
}
else
{
InitializeDataParameter(database, fileName, ref iparam);
}
}
else
{
//initialize the IDbParameter using the normal provider.
switch (database)
{
case DatabaseServer.Access:
iparam = new OleDbParameter();
break;
case DatabaseServer.SqlServer:
iparam = new SqlParameter();
break;
case DatabaseServer.Oracle:
iparam = new OracleParameter();
break;
}
}
}
private void btnTestConnection_Click(object sender, EventArgs e)
{
try
{
DatabaseServer tempServer = new DatabaseServer
{
ServerAddress = txtServerAddress.Text,
Password = txtPassword.Text,
UserName = txtUserName.Text,
DatabaseName = txtDatabaseName.Text,
UseWindowsAuth = chkWindowsAuth.Checked
};
_siqualConnection = _siqualConnectionManager.CreateConnectionFor(tempServer);
_siqualConnection.Open();
_siqualConnection.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
MessageBox.Show("Connection test successful.");
}
public async Task <IActionResult> InitializeServerConfiguration(string serverId)
{
if (String.IsNullOrWhiteSpace(serverId))
{
throw new ArgumentException("Argument cannot be null, empty, or entirely composed of whitespace: 'serverId'.", nameof(serverId));
}
Log.LogInformation("Initialising configuration for server {ServerId}...", serverId);
DatabaseServer targetServer = await DocumentSession.LoadAsync <DatabaseServer>(serverId);
using (CancellationTokenSource cancellationSource = new CancellationTokenSource())
{
Uri baseAddress = await GetServerBaseAddress(serverId);
cancellationSource.CancelAfter(
TimeSpan.FromSeconds(30)
);
Log.LogInformation("Using (deliberately) insecure setup mode for server {ServerId}...", serverId);
HttpResponseMessage response = await HttpClient.PostAsJsonAsync(
Requests.StartUnsecuredSetup.WithBaseUri(baseAddress),
postBody : new
{
PublicServerUrl = baseAddress.AbsoluteUri,
Port = 8080,
Addresses = new string[]
{
"127.0.0.1"
}
},
cancellationToken : cancellationSource.Token
);
using (response)
{
response.EnsureSuccessStatusCode();
}
Log.LogInformation("Committing changes to configuration for server {ServerId}...", serverId);
response = await HttpClient.PostAsync(
Requests.CompleteSetup.WithBaseUri(baseAddress),
cancellationToken : cancellationSource.Token
);
using (response)
{
response.EnsureSuccessStatusCode();
}
while (true)
{
using (CancellationTokenSource aliveCheckCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationSource.Token))
{
aliveCheckCancellationSource.CancelAfter(
TimeSpan.FromSeconds(1)
);
try
{
Log.LogDebug("Checking to see if server {ServerId} has restarted...", serverId);
response = await HttpClient.GetAsync(
Requests.IsServerAlive.WithBaseUri(baseAddress),
cancellationToken : cancellationSource.Token
);
using (response)
{
response.EnsureSuccessStatusCode();
break;
}
}
catch (OperationCanceledException timedOut)
{
if (timedOut.CancellationToken == cancellationSource.Token)
{
throw new TimeoutException("Timed out after waiting 30 seconds for RavenDB server to restart.", timedOut);
}
}
}
}
Log.LogInformation("Configuration has been initialised for server {ServerId}.", serverId);
return(Ok("Server configuration initialised."));
}
}
/// <summary>
/// Determine the connection string for the specified <see cref="SqlRequest"/>.
/// </summary>
/// <param name="request">
/// The <see cref="SqlRequest"/> being executed.
/// </param>
/// <returns>
/// The connection string.
/// </returns>
async Task <string> GetConnectionString(SqlRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
Log.LogInformation("Determining connection string for database {DatabaseId} in server {ServerId}...",
request.DatabaseId,
request.ServerId
);
DatabaseServer targetServer = await DocumentSession.LoadAsync <DatabaseServer>(request.ServerId);
if (targetServer == null)
{
Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (server not found).",
request.DatabaseId,
request.ServerId
);
throw RespondWith(Ok(new SqlResult
{
ResultCode = -1,
Errors =
{
new SqlError
{
Kind = SqlErrorKind.Infrastructure,
Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (server not found)."
}
}
}));
}
List <ServiceV1> matchingServices = await KubeClient.ServicesV1().List(
labelSelector: $"cloud.dimensiondata.daas.server-id = {targetServer.Id},cloud.dimensiondata.daas.service-type = internal",
kubeNamespace: KubeOptions.KubeNamespace
);
if (matchingServices.Count == 0)
{
Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (server's associated Kubernetes Service not found).",
request.DatabaseId,
request.ServerId
);
throw RespondWith(Ok(new SqlResult
{
ResultCode = -1,
Errors =
{
new SqlError
{
Kind = SqlErrorKind.Infrastructure,
Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (server's associated Kubernetes Service not found)."
}
}
}));
}
ServiceV1 serverService = matchingServices[matchingServices.Count - 1];
(string serverFQDN, int?serverPort) = serverService.GetHostAndPort(portName: "sql-server");
if (serverPort == null)
{
Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (cannot find the port named 'sql-server' on server's associated Kubernetes Service).",
request.DatabaseId,
request.ServerId
);
throw RespondWith(Ok(new SqlResult
{
ResultCode = -1,
Errors =
{
new SqlError
{
Kind = SqlErrorKind.Infrastructure,
Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (cannot find the port named 'sql-server' on server's associated Kubernetes Service)."
}
}
}));
}
Log.LogInformation("Database proxy will connect to SQL Server '{ServerFQDN}' on {ServerPort}.", serverFQDN, serverPort);
var connectionStringBuilder = new SqlClient.SqlConnectionStringBuilder
{
DataSource = $"tcp:{serverFQDN},{serverPort}",
};
var serverSettings = targetServer.GetSettings <SqlServerSettings>();
if (request.DatabaseId != MasterDatabaseId)
{
DatabaseInstance targetDatabase = await DocumentSession.LoadAsync <DatabaseInstance>(request.DatabaseId);
if (targetDatabase == null)
{
Log.LogWarning("Cannot determine connection string for database {DatabaseId} in server {ServerId} (database not found).",
request.DatabaseId,
request.ServerId
);
throw RespondWith(Ok(new SqlResult
{
ResultCode = -1,
Errors =
{
new SqlError
{
Kind = SqlErrorKind.Infrastructure,
Message = $"Unable to determine connection settings for database {request.DatabaseId} in server {request.ServerId} (database not found)."
}
}
}));
}
connectionStringBuilder.InitialCatalog = targetDatabase.Name;
if (request.ExecuteAsAdminUser)
{
connectionStringBuilder.UserID = "sa";
connectionStringBuilder.Password = serverSettings.AdminPassword;
}
else
{
connectionStringBuilder.UserID = targetDatabase.DatabaseUser;
connectionStringBuilder.Password = targetDatabase.DatabasePassword;
}
}
else
{
connectionStringBuilder.InitialCatalog = "master";
connectionStringBuilder.UserID = "sa";
connectionStringBuilder.Password = serverSettings.AdminPassword;
}
Log.LogInformation("Successfully determined connection string for database {DatabaseId} ({DatabaseName}) in server {ServerId} ({ServerSqlName}).",
request.DatabaseId,
connectionStringBuilder.InitialCatalog,
request.ServerId,
connectionStringBuilder.DataSource
);
return(connectionStringBuilder.ConnectionString);
}
public AuthorPersistentObject(DatabaseServer database, string connectionString, TableMetadata mainTable)
: base(database, connectionString, mainTable)
{
}
public static MigrationConfiguration AddUCommerceFromNamespaceOfThis <T>(this MigrationConfiguration migration, DatabaseServer db, string identifyingName = null)
where T : Migration
{
if (migration == null)
{
throw new ArgumentNullException(nameof(migration));
}
migration.Application
.UseUCommerce(uCommerce => uCommerce
.AddMigrationFromNamespaceOfThis <T>(db, identifyingName));
return(migration);
}
public BookAuthorsBusinessObject(DatabaseServer database, string connectionString)
{
persistent = new PersistentObject(database, connectionString, mapped);
}
public void SetServerDetails(string host, uint port, string username, string password, string databaseName) => _server = new DatabaseServer(host, port, username, password, databaseName);
public static BotModerationNavigator CreateBotModerationNavigator(DatabaseServer server, SocketGuild discordServer) => new BotModerationNavigator
{
Server = server, DiscordServer = discordServer
};
public DataConvertSqlScriptFile(DatabaseServer databaseServer)
{
this.DatabaseServer = databaseServer;
}
public DatabaseView(XtraTabPage tab, DatabaseServer databaseServer) : this()
{
_tabPage = tab;
_databaseServer = databaseServer;
}
/// <summary>
/// This method receives database server object and export it to real server
///
/// </summary>
/// <param name="server"></param>
public void UpgradeServer(DatabaseServer server)
{
}
/// <summary>
/// Get sqlserver database connection
/// </summary>
/// <param name="server">Database server</param>
/// <returns>Return database connection</returns>
internal static IDbConnection GetConnection(DatabaseServer server)
{
return(DataManager.GetDatabaseConnection(server) ?? new SqlConnection(server.ConnectionString));
}
public DatabaseServer Save(DatabaseServer server)
{
_databaseRepository.SaveOrUpdate(server);
return server;
}
public static void Start()
{
DatabaseServer.Start();
HostMachine.HideInterfaceArtifacts();
}
public SiqualConnection(DatabaseServer server)
{
_server = server;
}
public static int AddSite(SharePointSite item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
// check quota
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.SHAREPOINT_SITES);
if (quota.QuotaExhausted)
return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT;
// check if stats resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharePoint);
if (serviceId == 0)
return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE;
// check package items
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSite)) != null)
return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS;
// place log record
TaskManager.StartTask("SHAREPOINT", "ADD_SITE", item.Name);
TaskManager.WriteParameter("Database group", item.DatabaseGroupName);
TaskManager.WriteParameter("Database name", item.DatabaseName);
TaskManager.WriteParameter("Database user", item.DatabaseUser);
int databaseItemId = 0;
int databaseUserItemId = 0;
try
{
// load web site
WebSite siteItem = (WebSite)PackageController.GetPackageItemByName(item.PackageId,
item.Name, typeof(WebSite));
if (siteItem == null)
return BusinessErrorCodes.ERROR_WEB_SITE_SERVICE_UNAVAILABLE;
// get service web site
WebServer web = new WebServer();
ServiceProviderProxy.Init(web, siteItem.ServiceId);
WebSite site = web.GetSite(siteItem.SiteId);
/////////////////////////////////////////
//
// PREPARE SHAREPOINT SITE INSTALLATION
//
ServiceInfo wssService = ServerController.GetServiceInfo(serviceId);
bool wss30 = (wssService.ProviderId == 23); // WSS 3.0
// remember original web site bindings
ServerBinding[] bindings = site.Bindings;
// set application pool and root folder
item.ApplicationPool = site.ApplicationPool;
item.RootFolder = site.ContentPath;
// change web site .NET framework if required
bool siteUpdated = false;
if (!wss30 && (site.AspNetInstalled != "1"
|| site.DedicatedApplicationPool))
{
site.AspNetInstalled = "1";
site.DedicatedApplicationPool = false;
web.UpdateSite(site);
siteUpdated = true;
}
if (wss30 && site.AspNetInstalled != "2")
{
site.AspNetInstalled = "2";
web.UpdateSite(site);
siteUpdated = true;
}
if (siteUpdated)
{
site = web.GetSite(siteItem.SiteId);
item.ApplicationPool = site.ApplicationPool;
}
if (site.FrontPageInstalled)
{
// remove FrontPage
web.UninstallFrontPage(siteItem.SiteId, siteItem.FrontPageAccount);
}
// create SQL database
SqlDatabase database = new SqlDatabase();
database.PackageId = item.PackageId;
database.Name = item.DatabaseName;
databaseItemId = DatabaseServerController.AddSqlDatabase(database, item.DatabaseGroupName);
if (databaseItemId < 0)
return databaseItemId;
// create SQL user
SqlUser dbUser = new SqlUser();
dbUser.PackageId = item.PackageId;
dbUser.Name = item.DatabaseUser;
dbUser.Password = item.DatabasePassword;
databaseUserItemId = DatabaseServerController.AddSqlUser(dbUser, item.DatabaseGroupName);
if (databaseUserItemId < 0)
return databaseUserItemId;
// delete SQL database from service
// and change database user role
int sqlServiceId = PackageController.GetPackageServiceId(item.PackageId, item.DatabaseGroupName);
if (sqlServiceId < 0)
return BusinessErrorCodes.ERROR_MSSQL_RESOURCE_UNAVAILABLE;
// load server settings
StringDictionary sqlSettings = ServerController.GetServiceSettings(sqlServiceId);
item.DatabaseServer = sqlSettings["ExternalAddress"];
DatabaseServer dbServer = new DatabaseServer();
ServiceProviderProxy.Init(dbServer, sqlServiceId);
// delete database from service
dbServer.DeleteDatabase(database.Name);
// give SQL user "db_creator" role
dbServer.ExecuteSqlNonQuery("master", String.Format(
"sp_addsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name));
// install SharePoint site
SharePointServer sps = GetSharePoint(serviceId);
sps.ExtendVirtualServer(item);
// remove SQL user from "db_creator" role
dbServer.ExecuteSqlNonQuery("master", String.Format(
"sp_dropsrvrolemember '{0}', 'dbcreator'\nGO", dbUser.Name));
// restore original web site bindings
web.UpdateSiteBindings(site.SiteId, bindings, false);
// save statistics item
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
TaskManager.ItemId = itemId;
return itemId;
}
catch (Exception ex)
{
// delete database if required
if (databaseItemId > 0)
DatabaseServerController.DeleteSqlDatabase(databaseItemId);
// delete user if required
if (databaseUserItemId > 0)
DatabaseServerController.DeleteSqlUser(databaseUserItemId);
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public IntegrationDatabaseConfiguration ChangeDatabaseServer(DatabaseServer databaseServer)
{
_configuration.DatabaseServer = databaseServer;
return(this);
}
/// <summary>
/// Get query translator
/// </summary>
/// <param name="server">Database server</param>
/// <returns>Return query translator</returns>
internal static IQueryTranslator GetQueryTranslator(DatabaseServer server)
{
return(DataManager.GetQueryTranslator(server.ServerType) ?? new SqlServerQueryTranslator());
}
public CustomerBusinessObject(DatabaseServer database, string connectionString)
{
persistent = new PersistentObject(database, connectionString, mapped);
}
/// <summary>
/// This method receives from and to and generate upgrade script in SQL
/// </summary>
public string GenerateUpgradeScript(DatabaseServer from, DatabaseServer to)
{
throw new NotImplementedException();
}
public No(DatabaseServer obj)
{
this.TipoAtivo = 3;
this.DatabaseServer = obj;
this.Nome = obj.Nome;
}
public BookPersistentNew(DatabaseServer server, string connectionString)
{
pojo = new PersistentObject(server, connectionString, bok);
}
public SyncOperation(IList <ExternalServerData> data, IExternalServerDataRepository repository, DatabaseServer dbServer)
{
_data = data;
_repository = repository;
_dbServer = dbServer;
_dataStore = new DataStore(new TempStoreRepository());
}
public static TableStoredProcedureFactory Create(DatabaseServer server, String connectionString)
{
var r = DatabaseSchemaReader.Create(server, connectionString);
return(Create(r));
}
public ISiqualConnection CreateConnectionFor(DatabaseServer server)
{
SiqualConnection connection = new SiqualConnection(server);
//connection.Open();
return connection;
}
