Esempio n. 1
0
        internal static void ExecuteDirect(EngineCommandContext ctx, string filePath, string dbName)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                throw new Exception("Attach requires the path of the data file to attach.");
            }
            try
            {
                filePath = Path.GetFullPath(filePath);
            }
            catch
            {
                throw new InvalidPathException();
            }
            if (!File.Exists(filePath))
            {
                MissingFileException.Throw(Path.GetFileName(filePath));
            }
            if (!string.IsNullOrEmpty(dbName))
            {
                DatabaseIdentifier identifier = DatabaseIdentifier.Parse(dbName);
                if (identifier.IsDatabaseName)
                {
                    dbName = identifier.Value;
                }
            }
            IDbConnection connection = ctx.ConnectionManager.BuildAttachConnection(filePath, dbName);

            connection.Open();
            connection.Close();
            Console.WriteLine("Command completed successfully.");
        }
Esempio n. 2
0
        internal void ExecuteDirect(EngineCommandContext ctx)
        {
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection();

            connection.Open();
            try
            {
                IDbCommand command = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                command.CommandText = "SELECT @@VERSION";
                Console.WriteLine(command.ExecuteScalar().ToString());
            }
            finally
            {
                connection.Close();
            }
        }
Esempio n. 3
0
        internal void ExecuteDirect(EngineCommandContext ctx)
        {
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection(true);
            string        str        = "SELECT owning_principal_name AS [User], instance_pipe_name AS [Pipe], OS_process_id AS [ProcessId], heart_beat AS [Status] FROM sys.dm_os_child_instances";
            IDbCommand    command    = DataUtil.CreateCommand(ctx.ConnectionManager, connection);

            command.CommandText = str;
            connection.Open();
            try
            {
                SqlDataReader dataReader = (SqlDataReader)command.ExecuteReader();
                if (dataReader != null)
                {
                    try
                    {
                        if (dataReader.HasRows)
                        {
                            ITableFormatter formatter = TableFormatterBuilder.BuildTableFormatter(dataReader);
                            Console.WriteLine("");
                            Console.WriteLine(formatter.ReadHeader());
                            Console.WriteLine(new string('-', formatter.TotalColumnWidth));
                            string str2 = null;
                            while ((str2 = formatter.ReadNextRow()) != null)
                            {
                                Console.WriteLine(str2);
                            }
                        }
                        else
                        {
                            Console.WriteLine("No child instance found.");
                        }
                    }
                    finally
                    {
                        dataReader.Close();
                    }
                }
            }
            finally
            {
                connection.Close();
            }
            Console.WriteLine("");
        }
Esempio n. 4
0
 internal static void ExecuteDirect(EngineCommandContext ctx, bool listRemote)
 {
     string[] remoteInstances;
     if (listRemote)
     {
         Console.WriteLine("Gathering list of remote servers...");
         try
         {
             remoteInstances = SqlServerEnumerator.GetRemoteInstances();
         }
         catch
         {
             Console.WriteLine("Failed to retrieve the remote servers.");
             return;
         }
     }
     else
     {
         try
         {
             remoteInstances = SqlServerEnumerator.GetLocalInstances();
         }
         catch
         {
             Console.WriteLine("Failed to retrieve local instances.");
             return;
         }
     }
     Console.WriteLine("");
     if ((remoteInstances != null) && (remoteInstances.Length > 0))
     {
         foreach (string str in remoteInstances)
         {
             Console.WriteLine(str);
         }
     }
     else
     {
         Console.WriteLine("No SQL Server instance found.");
     }
 }
Esempio n. 5
0
        internal void ExecuteDirect(EngineCommandContext ctx, bool enable, int traceToEnable)
        {
            string str;
            string str2;

            if (traceToEnable == -1)
            {
                str = "4054,-1";
            }
            else
            {
                str = traceToEnable.ToString() + ",-1";
            }
            if (enable)
            {
                str2 = "TRACEON";
            }
            else
            {
                str2 = "TRACEOFF";
            }
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection();
            IDbCommand    command    = DataUtil.CreateCommand(ctx.ConnectionManager, connection);

            command.CommandText = "DBCC " + str2 + " (" + str + ")";
            connection.Open();
            try
            {
                command.ExecuteNonQuery();
                Console.Write("Trace flags {" + str + "} were set to " + enable.ToString());
            }
            catch (Exception exception)
            {
                Console.WriteLine("Failed to enable trace flags -- " + exception.ToString());
            }
            finally
            {
                connection.Close();
            }
            Console.WriteLine("");
        }
Esempio n. 6
0
        internal static void ExecuteDirect(EngineCommandContext ctx)
        {
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection();

            connection.Open();
            try
            {
                List <DatabaseInfo> list = DataUtil.BuildDatabaseInfoList(ctx.ConnectionManager, connection);
                if (list != null)
                {
                    int num = 1;
                    foreach (DatabaseInfo info in list)
                    {
                        Console.WriteLine(num + ". " + info.Name);
                        num++;
                    }
                }
            }
            finally
            {
                connection.Close();
            }
        }
Esempio n. 7
0
        internal void ExecuteDirect(EngineCommandContext ctx, string upgradePath)
        {
            if (string.IsNullOrEmpty(upgradePath))
            {
                throw new Exception("Upgrade requires the path of the data file to upgrade or a folder.");
            }
            string[] files = null;
            if (Directory.Exists(upgradePath))
            {
                files = Directory.GetFiles(upgradePath, "*.mdf");
            }
            else if (File.Exists(upgradePath) && (string.Compare(Path.GetExtension(upgradePath), ".mdf", StringComparison.OrdinalIgnoreCase) == 0))
            {
                files = new string[] { upgradePath };
            }
            if ((files == null) || (files.Length == 0))
            {
                throw new Exception("Could not data file(s) at the location specified.");
            }
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection();

            connection.Open();
            int num = this.TryGetDatabaseVersion(connection, "master");

            connection.Close();
            foreach (string str in files)
            {
                connection.Open();
                try
                {
                    if (DataUtil.IsFileAttached(ctx.ConnectionManager, connection, str) != null)
                    {
                        Console.WriteLine("File '" + Path.GetFileName(str) + "' is already attached to the server. Skipping file.");
                        goto Label_019C;
                    }
                }
                finally
                {
                    connection.Close();
                }
                Console.Write("Processing '" + Path.GetFileName(str) + "'...");
                IDbConnection connection2  = ctx.ConnectionManager.BuildAttachConnection(str, 0);
                string        databaseName = null;
                connection2.Open();
                try
                {
                    int num2;
                    databaseName = connection2.Database;
                    DateTime now = DateTime.Now;
                    if (num == -1)
                    {
                        goto Label_0170;
                    }
Label_0123:
                    num2 = this.TryGetDatabaseVersion(connection2, databaseName);
                    if ((num2 != -1) && (num2 != num))
                    {
                        Thread.Sleep(500);
                        if ((DateTime.Now - now) < TimeSpan.FromMinutes(2.0))
                        {
                            goto Label_0123;
                        }
                    }
                }
                finally
                {
                    connection2.Close();
                }
Label_0170:
                if (databaseName != null)
                {
                    connection.Open();
                    try
                    {
                        DataUtil.DetachDatabase(ctx.ConnectionManager, connection, databaseName, true);
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
                Console.WriteLine(" Done");
                Label_019C :;
            }
        }
Esempio n. 8
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     this.ExecuteDirect(ctx, this._upgradePath);
 }
        internal static void ExecuteDirect(EngineCommandContext ctx, string database)
        {
            if (string.IsNullOrEmpty(database))
            {
                throw new Exception("Detach requires a file path or database name (within brackets).");
            }
            bool flag = false;
            DatabaseIdentifier identifier = DatabaseIdentifier.Parse(database);

            database = identifier.Value;
            if (identifier.IsDatabaseName)
            {
                if (string.IsNullOrEmpty(database))
                {
                    throw new Exception("Invalid database name specified.");
                }
            }
            else
            {
                if (database.EndsWith("*"))
                {
                    database = database.Substring(0, database.Length - 1);
                    flag     = true;
                }
                database = PathUtil.EnsureFullPath(database);
            }
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection();

            connection.Open();
            try
            {
                List <DatabaseInfo> list = DataUtil.BuildDatabaseInfoList(ctx.ConnectionManager, connection);
                if (list != null)
                {
                    bool flag2 = false;
                    foreach (DatabaseInfo info in list)
                    {
                        bool flag3 = false;
                        try
                        {
                            if (identifier.IsDatabaseName)
                            {
                                if (string.Equals(database, info.Name, StringComparison.OrdinalIgnoreCase))
                                {
                                    flag3 = true;
                                }
                            }
                            else
                            {
                                string b = PathUtil.EnsureFullPath(info.Path);
                                if (flag)
                                {
                                    if (b.StartsWith(database, StringComparison.OrdinalIgnoreCase))
                                    {
                                        flag3 = true;
                                    }
                                }
                                else if (string.Equals(database, b, StringComparison.OrdinalIgnoreCase))
                                {
                                    flag3 = true;
                                }
                            }
                            if (flag3 && (((string.Compare(info.Name, "master", StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(info.Name, "tempdb", StringComparison.OrdinalIgnoreCase) == 0)) || ((string.Compare(info.Name, "model", StringComparison.OrdinalIgnoreCase) == 0) || (string.Compare(info.Name, "msdb", StringComparison.OrdinalIgnoreCase) == 0))))
                            {
                                Console.WriteLine("Warning: Not detaching system database '{0}'. Use SQL commands in the console to do it.", info.Name);
                                flag3 = false;
                            }
                        }
                        catch
                        {
                        }
                        if (flag3)
                        {
                            DataUtil.DetachDatabase(ctx.ConnectionManager, connection, info.Name, false);
                            flag2 = true;
                        }
                    }
                    if (!flag2)
                    {
                        if (identifier.IsDatabaseName)
                        {
                            Console.WriteLine("No valid database name matches the value specified.");
                        }
                        else
                        {
                            Console.WriteLine("No valid database path matches the value specified.");
                        }
                    }
                }
            }
            finally
            {
                connection.Close();
            }
        }
Esempio n. 10
0
 internal static void ExecuteDirect(EngineCommandContext ctx, string filePath)
 {
     ExecuteDirect(ctx, filePath, null);
 }
Esempio n. 11
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     ExecuteDirect(ctx, this._filePath, this._dbName);
 }
Esempio n. 12
0
 internal void ExecuteDirect(EngineCommandContext ctx, string scriptPath, Dictionary <string, string> variables)
 {
     new SqlConsole(ctx.Engine).Run(scriptPath, variables);
 }
Esempio n. 13
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     ExecuteDirect(ctx, this._database, this._publicKeyFile);
 }
Esempio n. 14
0
        internal static void ExecuteDirect(EngineCommandContext ctx, string filePath, string databaseName)
        {
            if (string.IsNullOrEmpty(filePath))
            {
                throw new Exception("Create requires a file path or existing database name in brackets.");
            }
            bool flag = false;
            DatabaseIdentifier identifier = DatabaseIdentifier.Parse(filePath);

            if (identifier.IsDatabaseName)
            {
                if (!string.IsNullOrEmpty(databaseName))
                {
                    throw new Exception("Database name was already specified within brackets. Should not specify database name again.");
                }
                databaseName = identifier.Value;
                if (string.IsNullOrEmpty(databaseName))
                {
                    throw new Exception("Invalid empty database name specified.");
                }
            }
            else
            {
                filePath = identifier.Value;
                try
                {
                    filePath = Path.GetFullPath(filePath);
                }
                catch
                {
                    throw new InvalidPathException();
                }
                if (string.IsNullOrEmpty(databaseName))
                {
                    flag         = true;
                    databaseName = Path.GetFileNameWithoutExtension(filePath);
                    if (string.IsNullOrEmpty(databaseName))
                    {
                        throw new Exception("Invalid database path specified.");
                    }
                }
            }
            IDbConnection connection = ctx.ConnectionManager.BuildMasterConnection();

            connection.Open();
            try
            {
                IDbCommand command = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                string     str     = DataUtil.QuoteDbObjectName(databaseName);
                if (identifier.IsDatabaseName)
                {
                    command.CommandText = "CREATE DATABASE " + str;
                }
                else
                {
                    command.CommandText = "CREATE DATABASE " + str + " ON (NAME='" + str + "', FILENAME='" + filePath + "')";
                }
                command.ExecuteNonQuery();
                if (flag)
                {
                    DataUtil.DetachDatabase(ctx.ConnectionManager, connection, databaseName, true);
                }
            }
            finally
            {
                connection.Close();
            }
            Console.WriteLine("Command completed successfully.");
        }
Esempio n. 15
0
        internal static void ExecuteDirect(EngineCommandContext ctx, string database, string keyPath)
        {
            IDbConnection connection;

            if (string.IsNullOrEmpty(database))
            {
                throw new Exception("Sign requires a file path or existing database name in brackets.");
            }
            if (string.IsNullOrEmpty(keyPath))
            {
                throw new Exception("Sign requires the path to the key file (.snk) that contains the encryption key.");
            }
            keyPath = PathUtil.EnsureFullPath(keyPath);
            if (!File.Exists(keyPath))
            {
                MissingFileException.Throw(Path.GetFileName(keyPath));
            }
            string             dbName     = null;
            bool               flag       = false;
            DatabaseIdentifier identifier = DatabaseIdentifier.Parse(database);

            database = identifier.Value;
            if (identifier.IsDatabaseName)
            {
                if (string.IsNullOrEmpty(database))
                {
                    throw new Exception("Invalid empty database name specified.");
                }
                connection = ctx.ConnectionManager.BuildMasterConnection();
                connection.Open();
                try
                {
                    IDbCommand command = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                    command.CommandText = "use [" + database + "]";
                    command.ExecuteNonQuery();
                }
                catch
                {
                    connection.Close();
                    throw;
                }
                dbName = database;
            }
            else
            {
                if (!File.Exists(database))
                {
                    MissingFileException.Throw(Path.GetFileName(database));
                }
                connection = ctx.ConnectionManager.BuildMasterConnection();
                connection.Open();
                try
                {
                    dbName = DataUtil.IsFileAttached(ctx.ConnectionManager, connection, database);
                }
                finally
                {
                    connection.Close();
                }
                if (dbName == null)
                {
                    flag = true;
                }
                connection = ctx.ConnectionManager.BuildAttachConnection(database, dbName);
                connection.Open();
                dbName = connection.Database;
            }
            try
            {
                IDbCommand command2 = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                command2.CommandText = "sp_resign_database 'ASYMMETRIC KEY', '" + keyPath + "'";
                command2.ExecuteNonQuery();
                string str2 = null;
                try
                {
                    byte[] publicKey = StrongName.ExtractPublicKeyFromKeyFile(keyPath);
                    if ((publicKey == null) || (publicKey.Length == 0))
                    {
                        throw new Exception("Invalid empty public key.");
                    }
                    byte[] bytes = StrongName.CreatePublicKeyToken(publicKey);
                    if ((bytes == null) || (bytes.Length == 0))
                    {
                        throw new Exception("Invalid empty public key token.");
                    }
                    str2 = Util.FormatBytesAsHex(bytes);
                }
                catch (Exception)
                {
                }
                if (flag)
                {
                    command2.CommandText = "use master";
                    command2.ExecuteNonQuery();
                    DataUtil.DetachDatabase(ctx.ConnectionManager, connection, dbName, true);
                }
                if (str2 != null)
                {
                    Console.WriteLine("Database signed successfully with key token '" + str2 + "'.");
                }
                else
                {
                    Console.WriteLine("Database signed successfully.");
                }
            }
            finally
            {
                connection.Close();
            }
        }
Esempio n. 16
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     ExecuteDirect(ctx, this._database, this._keyPath);
 }
Esempio n. 17
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     ExecuteDirect(ctx, this._listRemote);
 }
Esempio n. 18
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     this.ExecuteDirect(ctx, this._enable, this._traceToEnable);
 }
Esempio n. 19
0
        internal static void ExecuteDirect(EngineCommandContext ctx, string database)
        {
            IDbConnection connection;

            if (string.IsNullOrEmpty(database))
            {
                throw new Exception("Shrink requires a file path or existing database name in brackets.");
            }
            bool               flag       = false;
            string             dbName     = null;
            DatabaseIdentifier identifier = DatabaseIdentifier.Parse(database);

            database = identifier.Value;
            if (identifier.IsDatabaseName)
            {
                database = identifier.Value;
                if (string.IsNullOrEmpty(database))
                {
                    throw new Exception("Invalid empty database name specified.");
                }
                connection = ctx.ConnectionManager.BuildMasterConnection();
                connection.Open();
                try
                {
                    IDbCommand command = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                    command.CommandText = "use [" + database + "]";
                    command.ExecuteNonQuery();
                }
                catch
                {
                    connection.Close();
                    throw;
                }
                dbName = database;
            }
            else
            {
                if (!File.Exists(database))
                {
                    MissingFileException.Throw(Path.GetFileName(database));
                }
                database   = PathUtil.EnsureFullPath(database);
                connection = ctx.ConnectionManager.BuildMasterConnection();
                connection.Open();
                try
                {
                    dbName = DataUtil.IsFileAttached(ctx.ConnectionManager, connection, database);
                }
                finally
                {
                    connection.Close();
                }
                if (dbName == null)
                {
                    flag = true;
                }
                connection = ctx.ConnectionManager.BuildAttachConnection(database, dbName);
                connection.Open();
                dbName = connection.Database;
            }
            string[] initialSizes = null;
            List <DataUtil.DatabaseFileInfo> databaseFiles = null;

            try
            {
                databaseFiles = DataUtil.GetDatabaseFiles(ctx.ConnectionManager, connection);
                if ((databaseFiles == null) || (databaseFiles.Count == 0))
                {
                    throw new Exception("Could not get database file information from the server.");
                }
                initialSizes = new string[databaseFiles.Count];
                for (int j = 0; j < databaseFiles.Count; j++)
                {
                    initialSizes[j] = databaseFiles[j].Size;
                }
                IDbCommand command2 = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                command2.CommandText = "CHECKPOINT";
                command2.ExecuteNonQuery();
                command2.CommandText = "CHECKPOINT";
                command2.ExecuteNonQuery();
                command2.CommandText = "DBCC SHRINKDATABASE ([" + dbName + "], 10)";
                command2.ExecuteNonQuery();
            }
            finally
            {
                connection.Close();
            }
            connection = ctx.ConnectionManager.BuildMasterConnection();
            connection.Open();
            try
            {
                IDbCommand command3 = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                command3.CommandText = "use [" + dbName + "]";
                command3.ExecuteNonQuery();
                databaseFiles = DataUtil.GetDatabaseFiles(ctx.ConnectionManager, connection);
                if (flag)
                {
                    command3.CommandText = "use master";
                    command3.ExecuteNonQuery();
                    DataUtil.DetachDatabase(ctx.ConnectionManager, connection, dbName, true);
                }
            }
            finally
            {
                connection.Close();
            }
            if ((databaseFiles == null) || (databaseFiles.Count == 0))
            {
                throw new Exception("Could not get database file information from the server.");
            }
            string[] finalSizes = new string[databaseFiles.Count];
            for (int i = 0; i < databaseFiles.Count; i++)
            {
                finalSizes[i] = databaseFiles[i].Size;
            }
            PrintSizeReport(databaseFiles, initialSizes, finalSizes);
            Console.WriteLine("Command completed successfully.");
        }
Esempio n. 20
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     this.ExecuteDirect(ctx);
 }
Esempio n. 21
0
        internal static void ExecuteDirect(EngineCommandContext ctx, string database, string publicKeyFile)
        {
            IDbConnection connection;

            if (string.IsNullOrEmpty(database))
            {
                throw new Exception("IsSigned requires a file path or existing database name in brackets.");
            }
            if (string.IsNullOrEmpty(publicKeyFile))
            {
                throw new Exception("IsSigned requires the path to the key file (.snk) that contains the public key.");
            }
            DatabaseIdentifier identifier = DatabaseIdentifier.Parse(database);

            database = identifier.Value;
            if (identifier.IsDatabaseName)
            {
                if (string.IsNullOrEmpty(database))
                {
                    throw new Exception("Invalid empty database name specified.");
                }
            }
            else if (!File.Exists(database))
            {
                MissingFileException.Throw(Path.GetFileName(database));
            }
            if (!Path.GetExtension(publicKeyFile).Equals(".snk", StringComparison.OrdinalIgnoreCase))
            {
                throw new Exception("Key file should have the .snk extension. Only asymmetric key files are supported.");
            }
            if (!File.Exists(publicKeyFile))
            {
                MissingFileException.Throw(Path.GetFileName(publicKeyFile));
            }
            publicKeyFile = PathUtil.EnsureFullPath(publicKeyFile);
            byte[] fileBytes = GetFileBytes(publicKeyFile);
            string str       = "0x" + Util.FormatBytesAsHex(fileBytes);
            string str2      = "0x" + Util.FormatBytesAsHex(StrongName.CreatePublicKeyToken(fileBytes));

            Console.WriteLine("Verifying signature using the specified key file...");
            bool flag = true;

            if (identifier.IsDatabaseName)
            {
                connection = ctx.ConnectionManager.BuildMasterConnection();
            }
            else
            {
                IDbConnection connection2 = ctx.ConnectionManager.BuildMasterConnection();
                connection2.Open();
                string dbName = null;
                try
                {
                    dbName = DataUtil.IsFileAttached(ctx.ConnectionManager, connection2, database);
                }
                finally
                {
                    connection2.Close();
                }
                if (dbName == null)
                {
                    flag = true;
                }
                connection = ctx.ConnectionManager.BuildAttachConnection(database, dbName);
            }
            connection.Open();
            try
            {
                string str4 = null;
                if (flag)
                {
                    str4 = connection.Database;
                }
                IDbCommand command = DataUtil.CreateCommand(ctx.ConnectionManager, connection);
                if (identifier.IsDatabaseName)
                {
                    command.CommandText = "use [" + database + "]";
                    command.ExecuteNonQuery();
                }
                bool flag2 = false;
                command.CommandText = "SELECT count(*) FROM sys.asymmetric_keys where thumbprint=" + str2 + " AND public_key=" + str;
                object obj2 = command.ExecuteScalar();
                if ((obj2 is int) && (((int)obj2) == 1))
                {
                    command.CommandText = "SELECT count (*) FROM sys.fn_check_object_signatures('ASYMMETRIC KEY', " + str2 + ") WHERE is_signed <> 1 OR is_signature_valid <> 1";
                    obj2 = command.ExecuteScalar();
                    if ((obj2 is int) && (((int)obj2) == 0))
                    {
                        flag2 = true;
                    }
                }
                if (flag2)
                {
                    Console.WriteLine("Succeeded. The signature for all database objects matched.");
                }
                else
                {
                    Console.WriteLine("Failed. One or more object(s) failed signature validation.");
                }
                if (flag)
                {
                    try
                    {
                        DataUtil.DetachDatabase(ctx.ConnectionManager, connection, str4, true);
                    }
                    catch (Exception)
                    {
                    }
                }
            }
            finally
            {
                connection.Close();
            }
        }
Esempio n. 22
0
 void IEngineCommand.Execute(EngineCommandContext ctx)
 {
     this.ExecuteDirect(ctx, this._scriptPath, this._variables);
 }