/// <summary>
/// Configure the trace to run against the local SQL Server.
/// </summary>
private static void SQLTraceLiveReader()
{
TraceServer traceServerReader;
SqlConnectionInfo sci;
string traceConfigFileName;
string programFilesPath;
// Setup connection to the SQL Server
traceServerReader = new TraceServer();
// Use the local SQL Server
sci = new SqlConnectionInfo();
sci.UseIntegratedSecurity = true;
// Test for SQL Express
Server srvr = new Server(sci.ServerName);
if (srvr.Information.Edition != @"Express Edition")
{
// Configure the reader
// Use the Standard profiler configuration
traceConfigFileName = Properties.Settings.Default.TraceConfigFile;
programFilesPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
traceServerReader.InitializeAsReader(sci, programFilesPath + traceConfigFileName);
// Start reading the trace information
SQLTraceReader(traceServerReader);
}
else
{
Console.WriteLine("SQL Express is not supported for tracing");
}
}
public SqlTrace(string filterHostname, SqlConnection conn)
{
this.filterHostname = filterHostname.ToLower();
ci = new SqlConnectionInfo(conn.DataSource);
ClearData();
}
public TraceSource(SqlConnectionInfo connectionInfo, String filename)
{
if (connectionInfo == null)
{
throw new ArgumentNullException("connectionInfo");
}
this.connectionInfo = connectionInfo;
this.filename = filename;
}
public List <ProfileDetail> Load(IConnectionInfo connection)
{
ISqlConnectionInfo sqlConnection = connection as ISqlConnectionInfo;
if (sqlConnection != null)
{
return(this.Load(sqlConnection));
}
using (sqlConnection = new SqlConnectionInfo(connection, this.Type))
return(this.Load(sqlConnection));
}
public List <Message> Load(IConnectionInfo connection, Customer customer, MessageType messageType)
{
ISqlConnectionInfo sqlConnection = connection as ISqlConnectionInfo;
if (sqlConnection != null)
{
return(this.Load(sqlConnection, customer, messageType));
}
using (sqlConnection = new SqlConnectionInfo(connection, this.Type))
return(this.Load(sqlConnection, customer, messageType));
}
public ProfileGroup Load(IConnectionInfo connection, MobiChat.Data.Instance instance, string name)
{
ISqlConnectionInfo sqlConnection = connection as ISqlConnectionInfo;
if (sqlConnection != null)
{
return(this.Load(sqlConnection, instance, name));
}
using (sqlConnection = new SqlConnectionInfo(connection, this.Type))
return(this.Load(sqlConnection, instance, name));
}
private void ReadEventsFromFile()
{
try
{
SqlConnectionInfo info = new SqlConnectionInfo();
info.ServerName = "(localdb)\\MSSQLLocalDB";
string sqlCreateTable = @"
IF OBJECT_ID('tempdb.dbo.trace_reader_queue') IS NULL
BEGIN
CREATE TABLE tempdb.dbo.trace_reader_queue (
ts datetime DEFAULT GETDATE(),
path nvarchar(4000)
)
END
TRUNCATE TABLE tempdb.dbo.trace_reader_queue;
INSERT INTO tempdb.dbo.trace_reader_queue (path) VALUES(@path);
";
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = info.ConnectionString;
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = sqlCreateTable;
SqlParameter prm = new SqlParameter()
{
ParameterName = "@path",
DbType = System.Data.DbType.String,
Size = 4000,
Value = tracePath
};
cmd.Parameters.Add(prm);
cmd.ExecuteNonQuery();
}
}
reader = new FileTraceEventDataReader(info.ConnectionString, Filter, Events);
reader.ReadEvents();
finished = true;
}
catch (Exception ex)
{
logger.Error(ex.Message);
if (ex.InnerException != null)
{
logger.Error(ex.InnerException.Message);
}
Dispose();
}
}
public Message Load(IConnectionInfo connection, Guid messageGuid)
{
ISqlConnectionInfo sqlConnection = connection as ISqlConnectionInfo;
if (sqlConnection != null)
{
return(this.Load(sqlConnection, messageGuid));
}
using (sqlConnection = new SqlConnectionInfo(connection, this.Type))
return(this.Load(sqlConnection, messageGuid));
}
public ProfileDetail Load(IConnectionInfo connection, Profile profile, MobiChat.Data.Language language)
{
ISqlConnectionInfo sqlConnection = connection as ISqlConnectionInfo;
if (sqlConnection != null)
{
return(this.Load(sqlConnection, profile, language));
}
using (sqlConnection = new SqlConnectionInfo(connection, this.Type))
return(this.Load(sqlConnection, profile, language));
}
public List <Profile> Load(IConnectionInfo connection, ProfileGroup profileGroup)
{
ISqlConnectionInfo sqlConnection = connection as ISqlConnectionInfo;
if (sqlConnection != null)
{
return(this.Load(sqlConnection, profileGroup));
}
using (sqlConnection = new SqlConnectionInfo(connection, this.Type))
return(this.Load(sqlConnection, profileGroup));
}
/// <summary>
/// Clones the current connection in a new one
/// </summary>
public void Clone()
{
if (CurrentConnection != null)
{
SqlConnectionInfo newItem = CurrentConnection.Clone();
newItem.ConnectionID += "(Copy)";
SqlConnections.Add(newItem);
CurrentConnection = newItem;
IsInEditMode = true;
IsChanged = true;
}
}
public static void ExecuteStoredProc(StoredProcedure sp, SqlConnectionInfo connInfo)
{
try
{
string execScript = string.Format("{0}\r\n EXECUTE [{2}].[{3}] {1}",
UseDataBaseGo(sp.Parent), Environment.NewLine, sp.Schema, sp.Name);
lock (sp)
{
sp.Refresh();
sp.Parameters.Refresh(true); // refresh all parameters and their types and default values
string parameterList = "";
bool hasAtLeastOneNondefaultParameter = false;
for (int i = 0; i < sp.Parameters.Count; i++)
{
bool hasDefaultValue = false;
string parameterValue = MakeParameter(sp.Parameters[i], out hasDefaultValue);
string commaOrComment = string.Empty;
// add comma only to second or subsequent line and only if parameter does not have default value
if (i > 0 && !hasDefaultValue && hasAtLeastOneNondefaultParameter)
{
commaOrComment = ",";
}
if (hasDefaultValue)
{
commaOrComment = " -- ";
}
else
{
hasAtLeastOneNondefaultParameter = true;
}
parameterList += string.Format("\t\t{0}{1}\r\n", commaOrComment, parameterValue);
}
if (sp.Parameters.Count > 0)
{
execScript += parameterList;
}
}
CreateSQLDocumentWithHeader(execScript, connInfo);
}
catch (Exception ex)
{
log.Error("ExecuteStoredProc failed.", ex);
}
}
public void OpenTable2(NamedSmoObject tbl, SqlConnectionInfo connection, Server server)
{
String fileName = null;
// step1 - get script to edit table - SelectFromTableOrView(Server server, Urn urn, int topNValue)
// step2 - create a file
try
{
var t = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.OpenTableHelperClass,ObjectExplorer", true, true);
var miSelectFromTable = t.GetMethod("SelectFromTableOrView", BindingFlags.Static | BindingFlags.Public);
//signature is: public static string SelectFromTableOrView(Server server, Urn urn, int topNValue)
String script = (String)miSelectFromTable.Invoke(null, new Object[] { server, tbl.Urn, 200 });
fileName = CreateFile(script);
// invoke designer
var mc = new ManagedConnection();
mc.Connection = connection;
if (_editTableMethod == null)
{
foreach (var mi in ServiceCache.ScriptFactory.GetType().GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
{
if ((mi.Name == "CreateDesigner") && (mi.GetParameters().Length == 5))
{
_editTableMethod = mi;
break;
}
}
}
if (_editTableMethod != null)
{
_editTableMethod.Invoke(ServiceCache.ScriptFactory, new Object[] { DocumentType.OpenTable, DocumentOptions.ManageConnection, new Urn(tbl.Urn.ToString() + "/Data"), mc, fileName });
}
else
{
log.Error("Could not find CreateDesigner method");
}
}
catch (Exception ex)
{
log.Error("Failed OpenTable2", ex);
}
finally
{
if (!String.IsNullOrEmpty(fileName) && File.Exists(fileName))
{
File.Delete(fileName);
}
}
}
public static void OpenTable(NamedSmoObject objectToSelect, SqlConnectionInfo connection)
{
if (objectToSelect.State == SqlSmoState.Dropped)
{
log.Info("trying to open dropped table.");
return;
}
var _manager = new ObjectExplorerManager(HuntingDog.HuntingDogPackage.Instance);
_manager.OpenTable(objectToSelect, connection);
}
private Tuple <SqlConnectionInfo, DataTable, ServerConnection> CreateSqlConnection(ConnectionInfo connInfo, String jobId)
{
var sqlConnection = ConnectionService.OpenSqlConnection(connInfo);
var serverConnection = new ServerConnection(sqlConnection);
var server = new Server(serverConnection);
var filter = new JobHistoryFilter();
filter.JobID = new Guid(jobId);
var dt = server.JobServer.EnumJobHistory(filter);
var sqlConnInfo = new SqlConnectionInfo(serverConnection, SqlServer.Management.Common.ConnectionType.SqlConnection);
return(new Tuple <SqlConnectionInfo, DataTable, ServerConnection>(sqlConnInfo, dt, serverConnection));
}
/// <summary>
/// Sets the stub of SqlStoreConnectionFactory.GetUserConnection(SqlStoreConnectionInfo connectionInfo)
/// </summary>
public override IUserStoreConnection GetUserConnection(SqlConnectionInfo connectionInfo)
{
Func <SqlConnectionInfo, IUserStoreConnection> func1 = this.GetUserConnectionString;
if (func1 != null)
{
return(func1(connectionInfo));
}
if (this.___callBase)
{
return(base.GetUserConnection(connectionInfo));
}
return(this.InstanceBehavior.Result <StubSqlStoreConnectionFactory, IUserStoreConnection>(this, "GetUserConnection"));
}
public TableAccessor(string defaultDatabase)
{
SqlConnectionInfo connectionInfo = Common.Connection.GetActiveConnectionInfo();
ServerConnection connection = new ServerConnection(connectionInfo);
connection.Connect();
_server = new Server(connection);
_defaultDatabase = defaultDatabase;
if (!_server.Databases.Contains(_defaultDatabase))
{
_defaultDatabase = Common.Connection.GetActiveDatabase(null);
}
_dbForeignKeyRules = new Dictionary <string, List <Rule> >();
}
public TraceWrapperTraceServer(ConnectionInfo connectionInfo, List<IResultHandler> handlers = null)
: base(handlers)
{
this.connectionInfo = FromConnectionInfo(connectionInfo);
TraceDefinitionFile.SaveAsTDF("mytrace.tdf");
traceDefinitionFile = "mytrace.tdf";
this.State = TraceState.NotInitiated;
this.backWorker.WorkerReportsProgress = true;
this.backWorker.WorkerSupportsCancellation = true;
this.backWorker.ProgressChanged += new ProgressChangedEventHandler(backWorker_ProgressChanged);
this.backWorker.DoWork += new DoWorkEventHandler(backWorker_DoWork);
}
public static void DesignTable(Table tbl, SqlConnectionInfo connInfo)
{
if (tbl.State == SqlSmoState.Dropped)
{
log.Info("trying to design dropped table.");
return;
}
var mc = new ManagedConnection();
mc.Connection = connInfo;
ServiceCache.ScriptFactory.DesignTableOrView(Microsoft.SqlServer.Management.UI.VSIntegration.Editors.DocumentType.Table,
DocumentOptions.ManageConnection, tbl.Urn.ToString(), mc);
}
public override ProjectTaskProperties ProcessTaskCmdlet()
{
SqlConnectionInfo targetConnectionInfo = null;
SqlConnectionInfo sourceConnectionInfo = null;
SsisMigrationInfo ssisMigrationInfo = null;
if (MyInvocation.BoundParameters.ContainsKey(TargetConnection))
{
targetConnectionInfo = (SqlConnectionInfo)MyInvocation.BoundParameters[TargetConnection];
PSCredential cred = (PSCredential)MyInvocation.BoundParameters[TargetCred];
targetConnectionInfo.UserName = cred.UserName;
targetConnectionInfo.Password = Decrypt(cred.Password);
}
if (MyInvocation.BoundParameters.ContainsKey(SourceConnection))
{
sourceConnectionInfo = (SqlConnectionInfo)MyInvocation.BoundParameters[SourceConnection];
PSCredential cred = (PSCredential)MyInvocation.BoundParameters[SourceCred];
sourceConnectionInfo.UserName = cred.UserName;
sourceConnectionInfo.Password = Decrypt(cred.Password);
}
if (MyInvocation.BoundParameters.ContainsKey(SsisMigrationInfo))
{
ssisMigrationInfo = (SsisMigrationInfo)MyInvocation.BoundParameters[SsisMigrationInfo];
}
else
{
ssisMigrationInfo = new SsisMigrationInfo
{
SsisStoreType = SsisStoreType.SsisCatalog,
ProjectOverwriteOption = SsisMigrationOverwriteOption.Ignore,
EnvironmentOverwriteOption = SsisMigrationOverwriteOption.Ignore
};
}
var properties = new MigrateSsisTaskProperties
{
Input = new MigrateSsisTaskInput
{
TargetConnectionInfo = targetConnectionInfo,
SourceConnectionInfo = sourceConnectionInfo,
SsisMigrationInfo = ssisMigrationInfo
}
};
return(properties);
}
internal void Run()
{
SqlConnectionInfo sci = this.CreateConnectionInfo();
ServerConnection sc = new ServerConnection(sci);
Server s = new Server(sc);
Database db = s.Databases[this.Database];
this.CleanFolder(this.TableScriptPath);
this.CleanFolder(this.IndexScriptPath);
this.CleanFolder(this.ForeignKeyScriptPath);
if (this.StoredProcedureScriptPath != null)
{
this.CleanFolder(this.StoredProcedureScriptPath);
}
this.ParseDatabase(db);
}
public override ProjectTaskProperties ProcessTaskCmdlet()
{
SqlConnectionInfo targetConnectionInfo = null;
List <MigrateSqlServerSqlMIDatabaseInput> selectedDatabases = null;
BlobShare backupBlobShare = null;
FileShare backupFileShare = null;
if (MyInvocation.BoundParameters.ContainsKey(TargetConnection))
{
targetConnectionInfo = (SqlConnectionInfo)MyInvocation.BoundParameters[TargetConnection];
PSCredential cred = (PSCredential)MyInvocation.BoundParameters[TargetCred];
targetConnectionInfo.UserName = cred.UserName;
targetConnectionInfo.Password = Decrypt(cred.Password);
}
if (MyInvocation.BoundParameters.ContainsKey(SelectedDatabase))
{
selectedDatabases
= ((MigrateSqlServerSqlMIDatabaseInput[])MyInvocation.BoundParameters[SelectedDatabase]).ToList();
}
if (MyInvocation.BoundParameters.ContainsKey(BackupBlobSasUri))
{
backupBlobShare = new BlobShare
{
SasUri = MyInvocation.BoundParameters[BackupBlobSasUri] as string
};
}
if (MyInvocation.BoundParameters.ContainsKey(BackupFileShare))
{
backupFileShare = (FileShare)MyInvocation.BoundParameters[BackupFileShare];
}
var properties = new ValidateMigrationInputSqlServerSqlMITaskProperties
{
Input = new ValidateMigrationInputSqlServerSqlMITaskInput
{
TargetConnectionInfo = targetConnectionInfo,
SelectedDatabases = selectedDatabases,
BackupBlobShare = backupBlobShare,
BackupFileShare = backupFileShare
}
};
return(properties);
}
private static UIConnectionInfo CreateFrom(SqlConnectionInfo connInfo)
{
var ci = new UIConnectionInfo();
ci.ServerName = connInfo.ServerName;
ci.ServerType = new Guid("8c91a03d-f9b4-46c0-a305-b5dcc79ff907");
ci.UserName = connInfo.UserName;
ci.Password = connInfo.Password;
ci.PersistPassword = true;
ci.ApplicationName = "Microsoft SQL Server Management Studio - Query";
ci.AuthenticationType = !connInfo.UseIntegratedSecurity
? 1
: 0;
return(ci);
}
private static Tuple <ShardLocation, DbConnection> CreateDbConnectionForLocation(
ShardLocation shardLocation,
SqlConnectionInfo connectionInfo)
{
string shardConnectionString =
new SqlConnectionStringBuilder(connectionInfo.ConnectionString)
{
DataSource = shardLocation.DataSource,
InitialCatalog = shardLocation.Database
}.ConnectionString;
SqlConnectionInfo shardConnectionInfo = connectionInfo.CloneWithUpdatedConnectionString(shardConnectionString);
return(new Tuple <ShardLocation, DbConnection>(
shardLocation,
shardConnectionInfo.CreateConnection()));
}
public void TransactionTest()
{
var connection = new SqlConnectionInfo();
connection.DatabaseName = "TEST";
connection.ServerName = "test.opennetcf.com";
connection.ServerPort = 1433;
connection.UserName = "******";
connection.Password = "******";
var store = new SqlServerDataStore(connection);
try
{
store.AddType <PublishedTenantBuildingState>();
store.AddType <PublishedTenantApartmentState>();
var b = new PublishedTenantBuildingState()
{
PublishID = Guid.NewGuid(),
RecordDateUtc = DateTime.Now.ToUniversalTime()
};
var a1 = new PublishedTenantApartmentState()
{
PublishID = Guid.NewGuid(),
PublishedBuildingStateID = b.PublishID,
SpaceTemperature = 1
};
var a2 = new PublishedTenantApartmentState()
{
PublishID = Guid.NewGuid(),
PublishedBuildingStateID = b.PublishID,
SpaceTemperature = 2
};
store.BeginTransaction();
store.Insert(b);
store.Insert(a1);
store.Insert(a2);
store.Commit();
}
catch (Exception ex)
{
}
}
/// <summary>
/// Gets the active window connection.
/// </summary>
/// <returns></returns>
internal SqlConnectionInfo GetActiveWindowConnection()
{
SqlConnectionInfo info = null;
try
{
UIConnectionInfo connInfo = null;
if (ServiceCache.ScriptFactory.CurrentlyActiveWndConnectionInfo != null)
{
connInfo = ServiceCache.ScriptFactory.CurrentlyActiveWndConnectionInfo.UIConnectionInfo;
}
if (connInfo != null)
{
if (connInfo == currentUiConnection)
{
return(currentConnection);
}
else
{
info = CreateSqlConnectionInfo(connInfo);
currentConnection = info;
currentUiConnection = connInfo;
}
}
if (info == null)
{
var nodes = GetObjectExplorerSelectedNodes();
if (nodes.Length > 0)
{
info = nodes[0].Connection as SqlConnectionInfo;
}
}
return(info);
}
catch (NullReferenceException)
{
return(null);
}
}
public bool CanConnectToLocalDB()
{
try
{
SqlConnectionInfo info = new SqlConnectionInfo();
info.ServerName = @"(localdb)\MSSQLLocalDB";
info.UseIntegratedSecurity = true;
using (SqlConnection conn = new SqlConnection(info.ConnectionString + ";Connect Timeout=30;"))
{
conn.Open();
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public ObjectAccessor()
{
SqlConnectionInfo connectionInfo = Common.Connection.GetActiveConnectionInfo();
_serverName = connectionInfo.ServerName;
ServerConnection connection = new ServerConnection(connectionInfo);
connection.Connect();
_server = new Server(connection);
_scripter = new Scripter(_server);
_scripter.Options.IncludeDatabaseContext = true;
// does not work: _scripter.Options.ScriptBatchTerminator = true;
_scripter.Options.IncludeDatabaseRoleMemberships = true;
_scripter.Options.IncludeFullTextCatalogRootPath = true;
_scripter.Options.IncludeHeaders = true;
}
static private void CreateSQLDocument(String sqlText, SqlConnectionInfo connInfo)
{
if (!_uiConn.ContainsKey(connInfo.ServerName))
{
var aci = ServiceCache.ScriptFactory.CurrentlyActiveWndConnectionInfo;
_uiConn[connInfo.ServerName] = CreateFrom(connInfo);
}
var uiConn = _uiConn[connInfo.ServerName];
ServiceCache.ScriptFactory.CreateNewBlankScript(Microsoft.SqlServer.Management.UI.VSIntegration.Editors.ScriptType.Sql, uiConn, null);
// create new document
EnvDTE.TextDocument doc = (EnvDTE.TextDocument)ServiceCache.ExtensibilityModel.Application.ActiveDocument.Object(null);
// insert SQL definition to document
doc.EndPoint.CreateEditPoint().Insert(sqlText);
}
/// <summary>
/// Creates a SqlConnectionInfo object from a UIConnectionInfo object
/// </summary>
/// <param name="connectionInfo">The connection info.</param>
/// <returns></returns>
public static SqlConnectionInfo CreateSqlConnectionInfo(UIConnectionInfo connectionInfo)
{
var sqlConnInfo = new SqlConnectionInfo();
sqlConnInfo.ServerName = connectionInfo.ServerName;
sqlConnInfo.UserName = connectionInfo.UserName;
if (string.IsNullOrEmpty(connectionInfo.Password))
{
sqlConnInfo.UseIntegratedSecurity = true;
}
else
{
sqlConnInfo.Password = connectionInfo.Password;
}
return(sqlConnInfo);
}
/// <summary>
/// Load settings
/// </summary>
/// <param name="filePath">File path; pass null to use default settings file path</param>
/// <returns></returns>
public virtual DataSettings LoadSettings(string filePath = null, SqlConnectionInfo connectionStringName = null)
{
if (String.IsNullOrEmpty(filePath))
{
//use webHelper.MapPath instead of HostingEnvironment.MapPath which is not available in unit tests
filePath = Path.Combine(CommonHelper.MapPath("~/App_Data/"), filename);
}
if (File.Exists(filePath))
{
string text = File.ReadAllText(filePath);
return(ParseSettings(text));
}
else
{
return(LoadFromConfigFile(connectionStringName));
}
//return new DataSettings();
}
private void OpenTable(HierarchyTreeNode node, SqlConnectionInfo connection)
{
var t = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.OpenTableHelperClass,ObjectExplorer", true, true);
var mi = t.GetMethod("EditTopNRows", BindingFlags.Static | BindingFlags.Public);
var ncT = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.NodeContext,ObjectExplorer", true, true);
IServiceProvider provider = node as IServiceProvider;
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
var inst = Activator.CreateInstance(ncT, containedItem);
if (inst == null)
{
throw new Exception("Cannot create type" + ncT.ToString());
}
mi.Invoke(null, new Object[] { containedItem, 200 });
}
public IProfiler CreateProfiler(string serverName, string userName, string password, string rawConnection)
{
SqlConnectionInfo ci;
if (rawConnection == null)
{
ci = new SqlConnectionInfo(serverName);
ci.UserName = userName;
ci.Password = password;
if (userName == string.Empty)
ci.UseIntegratedSecurity = true;
return new Profiler(new SqlConnInfo(ci));
}
else
{
return new Profiler(new SqlConnInfo(delegate { return new SqlConnection(rawConnection); }));
}
}
/// <summary>
/// Handle request to get Agent Job history
/// </summary>
internal async Task HandleJobHistoryRequest(AgentJobHistoryParams parameters, RequestContext <AgentJobHistoryResult> requestContext)
{
await Task.Run(async() =>
{
try
{
var result = new AgentJobHistoryResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
Tuple <SqlConnectionInfo, DataTable, ServerConnection> tuple = CreateSqlConnection(connInfo, parameters.JobId);
SqlConnectionInfo sqlConnInfo = tuple.Item1;
DataTable dt = tuple.Item2;
ServerConnection connection = tuple.Item3;
int count = dt.Rows.Count;
List <AgentJobHistoryInfo> jobHistories = new List <AgentJobHistoryInfo>();
if (count > 0)
{
var job = dt.Rows[0];
string jobName = Convert.ToString(job[AgentUtilities.UrnJobName], System.Globalization.CultureInfo.InvariantCulture);
Guid jobId = (Guid)job[AgentUtilities.UrnJobId];
int runStatus = Convert.ToInt32(job[AgentUtilities.UrnRunStatus], System.Globalization.CultureInfo.InvariantCulture);
var t = new LogSourceJobHistory(jobName, sqlConnInfo, null, runStatus, jobId, null);
var tlog = t as ILogSource;
tlog.Initialize();
var logEntries = t.LogEntries;
jobHistories = AgentUtilities.ConvertToAgentJobHistoryInfo(logEntries, job);
tlog.CloseReader();
}
result.Jobs = jobHistories.ToArray();
result.Success = true;
connection.Disconnect();
await requestContext.SendResult(result);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
/// <summary>
/// called to create SqlConnectionInfo out of the given CDataContainer object
/// </summary>
/// <param name="dc"></param>
/// <returns></returns>
public static SqlConnectionInfo GetSqlConnectionInfoFromDataContainer(CDataContainer dc)
{
if (dc != null)
{
// we may have been given conneciton information by the object explorer. in which case there is no need
// to build it ourselves.
SqlConnectionInfo result = dc.ConnectionInfo as SqlConnectionInfo;
if (result == null)
{
throw new InvalidOperationException();
}
return(result);
}
else
{
return(null);
}
}
protected virtual SqlConnectionInfo FromConnectionInfo(ConnectionInfo info)
{
SqlConnectionInfo connectionInfo = new SqlConnectionInfo();
connectionInfo.ServerName = info.ServerName;
connectionInfo.UseIntegratedSecurity = info.UseIntegratedSecurity;
if (!connectionInfo.UseIntegratedSecurity)
{
connectionInfo.UserName = info.UserName;
connectionInfo.Password = info.Password;
}
return connectionInfo;
}
public void Open()
{
SqlConnectionInfo smoConn = new SqlConnectionInfo
{
UserName = _server.UserName,
Password = _server.Password,
UseIntegratedSecurity = _server.UseWindowsAuth,
ServerName = _server.ServerAddress
};
_smoConnection = new ServerConnection(smoConn);
_smoConnection.DatabaseName = _server.DatabaseName;
_smoConnection.Connect();
IsOpened = true;
}
public Server GetServer(string serverName, string userName, string password)
{
var connectionInfo = new SqlConnectionInfo();
connectionInfo.ServerName = serverName;
if (string.IsNullOrWhiteSpace(userName))
{
// Use Windows authentication.
connectionInfo.UseIntegratedSecurity = true;
}
else
{
// Use SQL authentication.
connectionInfo.UseIntegratedSecurity = false;
connectionInfo.UserName = userName;
connectionInfo.Password = password;
}
var connection = new ServerConnection(connectionInfo);
var server = new Server(connection);
return server;
}
public SqlConnectionInfo GetActiveWindowConnectionInfo()
{
SqlConnectionInfo info = null;
try
{
UIConnectionInfo uiConnInfo = GetActiveUIConnectionInfo();
//Dim uiConnInfo As UIConnectionInfo = Nothing
//If ServiceCache.ScriptFactory.CurrentlyActiveWndConnectionInfo IsNot Nothing Then
// uiConnInfo = ServiceCache.ScriptFactory.CurrentlyActiveWndConnectionInfo.UIConnectionInfo
//End If
if (uiConnInfo != null)
{
if (uiConnInfo == currentUIConnection)
{
return currentConnection;
}
else
{
info = CreateSqlConnectionInfo(uiConnInfo);
currentConnection = info;
currentUIConnection = uiConnInfo;
}
}
if (info == null)
{ //desiti ce se ako GetActiveUIConnectionInfo() vrati nothing
INodeInformation[] nodes = GetObjectExplorerSelectedNodes();
if (nodes.Length > 0)
{
info = nodes[0].Connection as SqlConnectionInfo;
}
}
return info;
}
//catch (NullReferenceException e)
catch (Exception e)
{
throw; // rethrows exception
throw (new ApplicationException("GetActiveWindowConnectionInfo: unable to find connection info", e));
//return null;
}
}
/// <summary>
/// Iz UIConnectionInfo builda SqlConnectionInfo kopirajući server, username, password, odabranu bazu.
/// SqlConnectionInfo zna na temelju toga vratiti connectionstring i mozes ga koristiti za kreiranje sql konekcija.
/// </summary>
/// <param name="uiConnInfo"></param>
/// <returns></returns>
/// <remarks></remarks>
private SqlConnectionInfo CreateSqlConnectionInfo(UIConnectionInfo uiConnInfo)
{
SqlConnectionInfo sqlConnInfo = new SqlConnectionInfo();
sqlConnInfo.ServerName = uiConnInfo.ServerName;
sqlConnInfo.UserName = uiConnInfo.UserName;
if (string.IsNullOrEmpty(uiConnInfo.Password))
{
sqlConnInfo.UseIntegratedSecurity = true;
}
else
{
sqlConnInfo.Password = uiConnInfo.Password;
}
sqlConnInfo.DatabaseName = uiConnInfo.AdvancedOptions["DATABASE"];
sqlConnInfo.ConnectionTimeout = 3; // default je 15, jedinice su sekunde
sqlConnInfo.QueryTimeout = 5; // max trajanje upita
sqlConnInfo.ApplicationName = "XDetails"; // da se vidi u sesijama baze tko se spaja
return sqlConnInfo;
}
public SqlConnectionInfo GetConnection()
{
if (null == _connectionInfo)
_connectionInfo = new SqlConnectionInfo("Data Source=.;Integrated Security=SSPI;");
return _connectionInfo;
}
public static TraceServer BeginTrace(SqlConnectionInfo sci)
{
TraceServer traceServerReader = new TraceServer();
traceServerReader.InitializeAsReader(sci, GetTraceTemplateName());
return traceServerReader;
}
public static SqlConnectionInfo GetTraceSqlConnectionInfo()
{
SqlConnectionInfo sci = new SqlConnectionInfo();
sci.UseIntegratedSecurity = true;
return sci;
}
public void Setup()
{
SqlConnectionInfo ci = new SqlConnectionInfo(@".");
profiler = new Profiler(new SqlConnInfo(ci));
profiler.Initialize(TraceOptions.FileRollover, path);
}
public void TestDeep(Cookie cookie, SqlConnectionInfo sci)
{
Uri root = new Uri("http://localhost/DBlog/Default.aspx");
List<Uri> queue = new List<Uri>(2500);
List<Uri> visited = new List<Uri>(5000);
PerformanceDataCollection perfdata = (sci == null ? null : new PerformanceDataCollection());
double totaltime = 0;
int totalcount = 0;
queue.Add(root);
Dictionary<Uri, Uri> references = new Dictionary<Uri, Uri>();
references.Add(root, new Uri("http://localhost/DBlog/"));
while (queue.Count > 0)
{
Uri topofqueue = queue[0];
List<HtmlUri> links;
double ts = 0;
PerformanceData perf = (perfdata != null ? new PerformanceData(topofqueue.ToString()) : null);
try
{
TraceServer traceServerReader = (sci == null ? null : SqlTrace.BeginTrace(sci));
TestPage(references[topofqueue], topofqueue, cookie, out links, out ts);
if (perfdata != null) perfdata.Add(SqlTrace.EndTrace(topofqueue.ToString(), traceServerReader));
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine("{0}: {1}", topofqueue, ex.Message);
throw ex;
}
finally
{
totalcount++;
totaltime += ts;
// add to visited links
visited.Add(topofqueue);
// remove from queue
queue.RemoveAt(0);
}
if (perfdata != null)
{
perfdata.Add(perf);
}
// -----------------
Console.Write("{0}/{1} [avg: {2}]", totalcount, queue.Count, (totaltime / totalcount).ToString("0.00"));
if (perf != null) Console.Write("[SQL: {0} in {1}] ", perf.Queries, perf.TotalDuration);
Console.Write(" => ");
int count = 0;
foreach (HtmlUri uri in links)
{
Uri fulluri = uri.Uri;
if (!root.IsBaseOf(fulluri))
{
// Console.WriteLine("\tSkipping {0}.", uri);
continue;
}
if (references.ContainsKey(fulluri) || queue.Contains(fulluri) || visited.Contains(fulluri))
continue;
Assert.IsFalse(fulluri.ToString().Contains("\0"),
string.Format("Uri {0} in {1} contains non-ASCII character.", fulluri, topofqueue));
Assert.IsFalse(fulluri.ToString().Contains("<%"),
string.Format("Uri {0} in {1} contains non-executed ASP.NET code.", fulluri, topofqueue));
Assert.IsFalse(fulluri.ToString().Contains("id=0"),
string.Format("Uri {0} in {1} contains a link to a zero id.", fulluri, topofqueue));
references.Add(fulluri, topofqueue);
// Console.WriteLine("\tAdding {0}.", fulluri.OriginalString);
queue.Add(fulluri);
count++;
}
if ((perfdata != null) && (((totalcount > 0) && ((totalcount % 100) == 0)) || (queue.Count == 0)))
{
perfdata.DumpPigs();
}
}
}
