/// <summary>
/// Handle request to start a profiling session
/// </summary>
internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext <StartProfilingResult> requestContext)
{
try
{
var result = new StartProfilingResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
int xEventSessionId = StartSession(parameters.OwnerUri, parameters.TemplateName, connInfo);
result.SessionId = xEventSessionId.ToString();
result.Succeeded = true;
}
else
{
result.Succeeded = false;
result.ErrorMessage = SR.ProfilerConnectionNotFound;
}
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(new Exception(SR.StartSessionFailed(e.Message)));
}
}
/// <summary>
/// Handles request to generate deploy script
/// </summary>
/// <returns></returns>
public async Task HandleGenerateDeployScriptRequest(GenerateDeployScriptParams parameters, RequestContext <DacFxResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
GenerateDeployScriptOperation operation = new GenerateDeployScriptOperation(parameters, connInfo);
SqlTask sqlTask = null;
TaskMetadata metadata = TaskMetadata.Create(parameters, SR.GenerateScriptTaskName, operation, ConnectionServiceInstance);
// want to show filepath in task history instead of server and database
metadata.ServerName = parameters.ScriptFilePath;
metadata.DatabaseName = string.Empty;
sqlTask = SqlTaskManagerInstance.CreateAndRun <SqlTask>(metadata);
await requestContext.SendResult(new DacFxResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
internal async Task HandleAgentProxiesRequest(AgentProxiesParams parameters, RequestContext <AgentProxiesResult> requestContext)
{
await Task.Run(async() =>
{
var result = new AgentProxiesResult();
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
int proxyCount = dataContainer.Server.JobServer.ProxyAccounts.Count;
var proxies = new AgentProxyInfo[proxyCount];
for (int i = 0; i < proxyCount; ++i)
{
var proxy = dataContainer.Server.JobServer.ProxyAccounts[i];
proxies[i] = new AgentProxyInfo
{
AccountName = proxy.Name,
Description = proxy.Description,
CredentialName = proxy.CredentialName
};
}
result.Proxies = proxies;
result.Success = true;
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.ToString();
}
await requestContext.SendResult(result);
});
}
/// <summary>
/// Handles external language delete request
/// </summary>
/// <param name="parameters">Request parameters</param>
/// <param name="requestContext">Request Context</param>
/// <returns></returns>
public async Task HandleExternalLanguageDeleteRequest(ExternalLanguageDeleteRequestParams parameters, RequestContext <ExternalLanguageDeleteResponseParams> requestContext)
{
Logger.Write(TraceEventType.Verbose, "HandleExternalLanguageDeleteRequest");
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
ExternalLanguageDeleteResponseParams response = new ExternalLanguageDeleteResponseParams
{
};
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ConnectionServiceDbErrorDefaultNotConnected(parameters.OwnerUri)));
}
else
{
using (IDbConnection dbConnection = ConnectionService.OpenSqlConnection(connInfo))
{
ExternalLanguageOperations.DeleteLanguage(dbConnection, parameters.LanguageName);
}
await requestContext.SendResult(response);
}
}
catch (Exception e)
{
// Exception related to run task will be captured here
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle request to start a profiling session
/// </summary>
internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext <StartProfilingResult> requestContext)
{
await Task.Run(async() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
// create a new XEvent session and Profiler session
var xeSession = this.XEventSessionFactory.GetXEventSession(parameters.SessionName, connInfo);
// start monitoring the profiler session
monitor.StartMonitoringSession(parameters.OwnerUri, xeSession);
var result = new StartProfilingResult();
await requestContext.SendResult(result);
}
else
{
throw new Exception(SR.ProfilerConnectionNotFound);
}
}
catch (Exception e)
{
await requestContext.SendError(new Exception(SR.StartSessionFailed(e.Message)));
}
});
}
internal async Task <Tuple <bool, string> > ConfigureAgentAlert(
string ownerUri,
AgentAlertInfo alert,
ConfigAction configAction,
RunType runType)
{
return(await Task <Tuple <bool, string> > .Run(() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(ownerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
STParameters param = new STParameters(dataContainer.Document);
param.SetParam("alert", alert.JobName);
if (alert != null && !string.IsNullOrWhiteSpace(alert.JobName))
{
using (AgentAlertActions agentAlert = new AgentAlertActions(dataContainer, alert, configAction))
{
var executionHandler = new ExecutonHandler(agentAlert);
executionHandler.RunNow(runType, this);
}
}
return new Tuple <bool, string>(true, string.Empty);
}
catch (Exception ex)
{
return new Tuple <bool, string>(false, ex.ToString());
}
}));
}
/// <summary>
/// Handles request to generate deploy plan
/// </summary>
/// <returns></returns>
public async Task HandleGenerateDeployPlanRequest(GenerateDeployPlanParams parameters, RequestContext <GenerateDeployPlanRequestResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
GenerateDeployPlanOperation operation = new GenerateDeployPlanOperation(parameters, connInfo);
operation.Execute(parameters.TaskExecutionMode);
await requestContext.SendResult(new GenerateDeployPlanRequestResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty,
Report = operation.DeployReport
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
internal async Task <Tuple <bool, string> > ConfigureAgentProxy(
string ownerUri,
string accountName,
AgentProxyInfo proxy,
ConfigAction configAction,
RunType runType)
{
return(await Task <bool> .Run(() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(ownerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
STParameters param = new STParameters(dataContainer.Document);
param.SetParam("proxyaccount", accountName);
using (AgentProxyAccountActions agentProxy = new AgentProxyAccountActions(dataContainer, proxy, configAction))
{
var executionHandler = new ExecutonHandler(agentProxy);
executionHandler.RunNow(runType, this);
}
return new Tuple <bool, string>(true, string.Empty);
}
catch (Exception ex)
{
return new Tuple <bool, string>(false, ex.ToString());
}
}));
}
private void CreateJobData(
string ownerUri,
string jobName,
out CDataContainer dataContainer,
out JobData jobData,
ConfigAction configAction = ConfigAction.Create,
AgentJobInfo jobInfo = null)
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(ownerUri, out connInfo);
dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
XmlDocument jobDoc = CreateJobXmlDocument(dataContainer.Server.Name.ToUpper(), jobName);
dataContainer.Init(jobDoc.InnerXml);
STParameters param = new STParameters(dataContainer.Document);
string originalName = jobInfo != null && !string.Equals(jobName, jobInfo.Name) ? jobName : string.Empty;
param.SetParam("job", configAction == ConfigAction.Update ? jobName : string.Empty);
param.SetParam("jobid", string.Empty);
jobData = new JobData(dataContainer, jobInfo, configAction);
}
internal async Task <Tuple <bool, string> > ConfigureCredential(
string ownerUri,
CredentialInfo credential,
ConfigAction configAction,
RunType runType)
{
return(await Task <Tuple <bool, string> > .Run(() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(ownerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
using (CredentialActions actions = new CredentialActions(dataContainer, credential, configAction))
{
var executionHandler = new ExecutonHandler(actions);
executionHandler.RunNow(runType, this);
}
return new Tuple <bool, string>(true, string.Empty);
}
catch (Exception ex)
{
return new Tuple <bool, string>(false, ex.ToString());
}
}));
}
/// <summary>
/// Handle request to delete an alert
/// </summary>
internal async Task HandleDeleteAgentAlertRequest(DeleteAgentAlertParams parameters, RequestContext <DeleteAgentAlertResult> requestContext)
{
await Task.Run(async() =>
{
var result = new DeleteAgentAlertResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
AgentAlertInfo alert = parameters.Alert;
if (connInfo != null && ValidateAgentAlertInfo(alert))
{
CDataContainer dataContainer = AdminService.CreateDataContainer(connInfo, databaseExists: true);
STParameters param = new STParameters(dataContainer.Document);
param.SetParam("alert", alert.JobName);
using (AgentAlert agentAlert = new AgentAlert(dataContainer, alert))
{
agentAlert.Drop();
}
}
await requestContext.SendResult(result);
});
}
/// <summary>
/// Handle request to start a profiling session
/// </summary>
internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext <StartProfilingResult> requestContext)
{
try
{
var result = new StartProfilingResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ProfilerSession session = StartSession(parameters.OwnerUri, connInfo);
result.SessionId = session.SessionId;
result.Succeeded = true;
}
else
{
result.Succeeded = false;
result.ErrorMessage = SR.ProfilerConnectionNotFound;
}
await requestContext.SendResult(result);
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle request to pause a profiling session
/// </summary>
internal async Task HandleGetXEventSessionsRequest(GetXEventSessionsParams parameters, RequestContext <GetXEventSessionsResult> requestContext)
{
await Task.Run(async() =>
{
try
{
var result = new GetXEventSessionsResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
await requestContext.SendError(new Exception(SR.ProfilerConnectionNotFound));
}
else
{
List <string> sessions = GetXEventSessionList(parameters.OwnerUri, connInfo);
result.Sessions = sessions;
await requestContext.SendResult(result);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
internal async Task <Tuple <bool, string> > ConfigureAgentOperator(
string ownerUri,
AgentOperatorInfo operatorInfo,
ConfigAction configAction,
RunType runType)
{
return(await Task <Tuple <bool, string> > .Run(() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(ownerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
STParameters param = new STParameters(dataContainer.Document);
param.SetParam("operator", operatorInfo.Name);
using (AgentOperatorActions actions = new AgentOperatorActions(dataContainer, operatorInfo, configAction))
{
ExecuteAction(actions, runType);
}
return new Tuple <bool, string>(true, string.Empty);
}
catch (Exception ex)
{
return new Tuple <bool, string>(false, ex.ToString());
}
}));
}
/// <summary>
/// Handles request to generate deploy script
/// </summary>
/// <returns></returns>
public async Task HandleGenerateDeployScriptRequest(GenerateDeployScriptParams parameters, RequestContext <DacFxResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
GenerateDeployScriptOperation operation = new GenerateDeployScriptOperation(parameters, connInfo);
SqlTask sqlTask = null;
TaskMetadata metadata = new TaskMetadata();
metadata.TaskOperation = operation;
metadata.TaskExecutionMode = parameters.TaskExecutionMode;
metadata.ServerName = connInfo.ConnectionDetails.ServerName;
metadata.DatabaseName = parameters.DatabaseName;
metadata.Name = SR.GenerateScriptTaskName;
sqlTask = SqlTaskManagerInstance.CreateAndRun <SqlTask>(metadata);
await requestContext.SendResult(new DacFxResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = string.Empty
});
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
/// <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)
{
ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
var jobs = dataContainer.Server.JobServer.Jobs;
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;
// Send Steps, Alerts and Schedules with job history in background
JobStepCollection steps = jobs[jobName].JobSteps;
JobScheduleCollection schedules = jobs[jobName].JobSchedules;
List <Alert> alerts = new List <Alert>();
foreach (Alert alert in dataContainer.Server.JobServer.Alerts)
{
if (alert.JobID == jobId && alert.JobName == jobName)
{
alerts.Add(alert);
}
}
jobHistories = AgentUtilities.ConvertToAgentJobHistoryInfo(logEntries, job, steps, schedules, alerts);
tlog.CloseReader();
}
result.Jobs = jobHistories.ToArray();
result.Success = true;
connection.Disconnect();
await requestContext.SendResult(result);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
});
}
/// <summary>
/// Handle request to start a profiling session
/// </summary>
internal async Task HandleCreateXEventSessionRequest(CreateXEventSessionParams parameters, RequestContext <CreateXEventSessionResult> requestContext)
{
await Task.Run(async() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo == null)
{
throw new Exception(SR.ProfilerConnectionNotFound);
}
else if (parameters.SessionName == null)
{
throw new ArgumentNullException("SessionName");
}
else if (parameters.Template == null)
{
throw new ArgumentNullException("Template");
}
else
{
IXEventSession xeSession = null;
// first check whether the session with the given name already exists.
// if so skip the creation part. An exception will be thrown if no session with given name can be found,
// and it can be ignored.
try
{
xeSession = this.XEventSessionFactory.GetXEventSession(parameters.SessionName, connInfo);
}
catch { }
if (xeSession == null)
{
// create a new XEvent session and Profiler session
xeSession = this.XEventSessionFactory.CreateXEventSession(parameters.Template.CreateStatement, parameters.SessionName, connInfo);
}
// start monitoring the profiler session
monitor.StartMonitoringSession(parameters.OwnerUri, xeSession);
var result = new CreateXEventSessionResult();
await requestContext.SendResult(result);
SessionCreatedNotification(parameters.OwnerUri, parameters.SessionName, parameters.Template.Name);
}
}
catch (Exception e)
{
await requestContext.SendError(new Exception(SR.CreateSessionFailed(e.Message)));
}
});
}
/// <summary>
/// Handles schema compare request
/// </summary>
/// <returns></returns>
public async Task HandleSchemaCompareRequest(SchemaCompareParams parameters, RequestContext <SchemaCompareResult> requestContext)
{
try
{
ConnectionInfo sourceConnInfo;
ConnectionInfo targetConnInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.SourceEndpointInfo.OwnerUri,
out sourceConnInfo);
ConnectionServiceInstance.TryFindConnection(
parameters.TargetEndpointInfo.OwnerUri,
out targetConnInfo);
CurrentSchemaCompareTask = Task.Run(async() =>
{
SchemaCompareOperation operation = null;
try
{
operation = new SchemaCompareOperation(parameters, sourceConnInfo, targetConnInfo);
currentComparisonCancellationAction.Value[operation.OperationId] = operation.Cancel;
operation.Execute(parameters.TaskExecutionMode);
// add result to dictionary of results
schemaCompareResults.Value[operation.OperationId] = operation.ComparisonResult;
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = operation.ErrorMessage,
AreEqual = operation.ComparisonResult.IsEqual,
Differences = operation.Differences
});
// clean up cancellation action now that the operation is complete (using try remove to avoid exception)
Action cancelAction = null;
currentComparisonCancellationAction.Value.TryRemove(operation.OperationId, out cancelAction);
}
catch (Exception e)
{
Logger.Write(TraceEventType.Error, "Failed to compare schema. Error: " + e);
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
/// <summary>
/// Handle request to get the alerts list
/// </summary>
internal async Task HandleAgentAlertsRequest(AgentAlertsParams parameters, RequestContext <AgentAlertsResult> requestContext)
{
await Task.Run(async() =>
{
var result = new AgentAlertsResult();
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
int alertsCount = dataContainer.Server.JobServer.Alerts.Count;
var alerts = new AgentAlertInfo[alertsCount];
for (int i = 0; i < alertsCount; ++i)
{
var alert = dataContainer.Server.JobServer.Alerts[i];
alerts[i] = new AgentAlertInfo
{
Id = alert.ID,
Name = alert.Name,
DelayBetweenResponses = alert.DelayBetweenResponses,
EventDescriptionKeyword = alert.EventDescriptionKeyword,
EventSource = alert.EventSource,
HasNotification = alert.HasNotification,
IncludeEventDescription = (Contracts.NotifyMethods)alert.IncludeEventDescription,
IsEnabled = alert.IsEnabled,
JobId = alert.JobID.ToString(),
JobName = alert.JobName,
LastOccurrenceDate = alert.LastOccurrenceDate.ToString(),
LastResponseDate = alert.LastResponseDate.ToString(),
MessageId = alert.MessageID,
NotificationMessage = alert.NotificationMessage,
OccurrenceCount = alert.OccurrenceCount,
PerformanceCondition = alert.PerformanceCondition,
Severity = alert.Severity,
DatabaseName = alert.DatabaseName,
CountResetDate = alert.CountResetDate.ToString(),
CategoryName = alert.CategoryName,
AlertType = (Contracts.AlertType)alert.AlertType,
WmiEventNamespace = alert.WmiEventNamespace,
WmiEventQuery = alert.WmiEventQuery
};
}
result.Alerts = alerts;
result.Success = true;
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.ToString();
}
await requestContext.SendResult(result);
});
}
/// <summary>
/// Handle request to Run a Job
/// </summary>
internal async Task HandleJobActionRequest(AgentJobActionParams parameters, RequestContext <ResultStatus> requestContext)
{
await Task.Run(async() =>
{
var result = new ResultStatus();
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
var sqlConnection = ConnectionService.OpenSqlConnection(connInfo);
var serverConnection = new ServerConnection(sqlConnection);
var jobHelper = new JobHelper(serverConnection);
jobHelper.JobName = parameters.JobName;
switch (parameters.Action)
{
case "run":
jobHelper.Start();
break;
case "stop":
jobHelper.Stop();
break;
case "delete":
jobHelper.Delete();
break;
case "enable":
jobHelper.Enable(true);
break;
case "disable":
jobHelper.Enable(false);
break;
default:
break;
}
result.Success = true;
await requestContext.SendResult(result);
}
}
catch (Exception e)
{
result.Success = false;
result.ErrorMessage = e.Message;
await requestContext.SendResult(result);
}
});
}
/// <summary>
/// Handles schema compare request
/// </summary>
/// <returns></returns>
public async Task HandleSchemaCompareRequest(SchemaCompareParams parameters, RequestContext <SchemaCompareResult> requestContext)
{
try
{
ConnectionInfo sourceConnInfo;
ConnectionInfo targetConnInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.SourceEndpointInfo.OwnerUri,
out sourceConnInfo);
ConnectionServiceInstance.TryFindConnection(
parameters.TargetEndpointInfo.OwnerUri,
out targetConnInfo);
Task schemaCompareTask = Task.Run(async() =>
{
SchemaCompareOperation operation = null;
try
{
operation = new SchemaCompareOperation(parameters, sourceConnInfo, targetConnInfo);
operation.Execute(parameters.TaskExecutionMode);
// add result to dictionary of results
schemaCompareResults.Value[operation.OperationId] = operation.ComparisonResult;
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation.OperationId,
Success = true,
ErrorMessage = operation.ErrorMessage,
AreEqual = operation.ComparisonResult.IsEqual,
Differences = operation.Differences
});
}
catch (Exception e)
{
await requestContext.SendResult(new SchemaCompareResult()
{
OperationId = operation != null ? operation.OperationId : null,
Success = false,
ErrorMessage = operation == null ? e.Message : operation.ErrorMessage,
});
}
});
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
private ServerConnection ValidateAndCreateConnection(string ownerUri)
{
ServerConnection serverConn = null;
if (ownerUri != null)
{
ConnectionInfo connInfo = null;
if (ConnectionServiceInstance.TryFindConnection(ownerUri, out connInfo))
{
serverConn = ConnectionService.OpenServerConnection(connInfo);
}
}
return(serverConn);
}
internal async Task HandleAgentOperatorsRequest(AgentOperatorsParams parameters, RequestContext <AgentOperatorsResult> requestContext)
{
await Task.Run(async() =>
{
var result = new AgentOperatorsResult();
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
int operatorCount = dataContainer.Server.JobServer.Operators.Count;
var operators = new AgentOperatorInfo[operatorCount];
for (int i = 0; i < operatorCount; ++i)
{
var item = dataContainer.Server.JobServer.Operators[i];
operators[i] = new AgentOperatorInfo
{
Name = item.Name,
Id = item.ID,
EmailAddress = item.EmailAddress,
Enabled = item.Enabled,
LastEmailDate = item.LastEmailDate.ToString(),
LastNetSendDate = item.LastNetSendDate.ToString(),
LastPagerDate = item.LastPagerDate.ToString(),
PagerAddress = item.PagerAddress,
CategoryName = item.CategoryName,
PagerDays = (Contracts.WeekDays)item.PagerDays,
SaturdayPagerEndTime = item.SaturdayPagerEndTime.ToString(),
SaturdayPagerStartTime = item.SaturdayPagerEndTime.ToString(),
SundayPagerEndTime = item.SundayPagerEndTime.ToString(),
SundayPagerStartTime = item.SundayPagerStartTime.ToString(),
NetSendAddress = item.NetSendAddress,
WeekdayPagerStartTime = item.WeekdayPagerStartTime.ToString(),
WeekdayPagerEndTime = item.WeekdayPagerEndTime.ToString()
};
}
result.Operators = operators;
result.Success = true;
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.ToString();
}
await requestContext.SendResult(result);
});
}
/// <summary>
/// Handle request to update an alert
/// </summary>
internal async Task HandleUpdateAgentAlertRequest(UpdateAgentAlertParams parameters, RequestContext <UpdateAgentAlertResult> requestContext)
{
await Task.Run(async() =>
{
var result = new UpdateAgentAlertResult();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
CreateOrUpdateAgentAlert(connInfo, parameters.Alert);
await requestContext.SendResult(result);
});
}
internal async Task HandleAgentSchedulesRequest(AgentSchedulesParams parameters, RequestContext <AgentSchedulesResult> requestContext)
{
await Task.Run(async() =>
{
var result = new AgentSchedulesResult();
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
int scheduleCount = dataContainer.Server.JobServer.SharedSchedules.Count;
var schedules = new AgentScheduleInfo[scheduleCount];
for (int i = 0; i < scheduleCount; ++i)
{
var schedule = dataContainer.Server.JobServer.SharedSchedules[i];
var scheduleData = new JobScheduleData(schedule);
schedules[i] = new AgentScheduleInfo();
schedules[i].Id = schedule.ID;
schedules[i].Name = schedule.Name;
schedules[i].IsEnabled = schedule.IsEnabled;
schedules[i].FrequencyTypes = (Contracts.FrequencyTypes)schedule.FrequencyTypes;
schedules[i].FrequencySubDayTypes = (Contracts.FrequencySubDayTypes)schedule.FrequencySubDayTypes;
schedules[i].FrequencySubDayInterval = schedule.FrequencySubDayInterval;
schedules[i].FrequencyRelativeIntervals = (Contracts.FrequencyRelativeIntervals)schedule.FrequencyRelativeIntervals;
schedules[i].FrequencyRecurrenceFactor = schedule.FrequencyRecurrenceFactor;
schedules[i].FrequencyInterval = schedule.FrequencyInterval;
schedules[i].DateCreated = schedule.DateCreated;
schedules[i].ActiveStartTimeOfDay = schedule.ActiveStartTimeOfDay;
schedules[i].ActiveStartDate = schedule.ActiveStartDate;
schedules[i].ActiveEndTimeOfDay = schedule.ActiveEndTimeOfDay;
schedules[i].JobCount = schedule.JobCount;
schedules[i].ActiveEndDate = schedule.ActiveEndDate;
schedules[i].ScheduleUid = schedule.ScheduleUid;
schedules[i].Description = scheduleData.Description;
}
result.Schedules = schedules;
result.Success = true;
}
catch (Exception ex)
{
result.Success = false;
result.ErrorMessage = ex.ToString();
}
await requestContext.SendResult(result);
});
}
private async Task <ServerConnection> ValidateAndCreateConnection(ConnectParams connectionParams)
{
// Validate Parameters and Create Connection
ConnectionCompleteParams connectionCompleteParams = await ConnectionServiceInstance.Connect(connectionParams);
if (!string.IsNullOrEmpty(connectionCompleteParams.Messages))
{
throw new Exception(connectionCompleteParams.Messages);
}
// Get Connection
ConnectionInfo connectionInfo = ConnectionServiceInstance.OwnerToConnectionMap[connectionParams.OwnerUri];
ServerConnection serverConn = ConnectionService.OpenServerConnection(connectionInfo);
return(serverConn);
}
internal async Task <bool> ConfigureAgentProxy(
string ownerUri,
string accountName,
AgentProxyInfo proxy,
AgentConfigAction configAction)
{
return(await Task <bool> .Run(() =>
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
ownerUri,
out connInfo);
CDataContainer dataContainer = AdminService.CreateDataContainer(connInfo, databaseExists: true);
STParameters param = new STParameters(dataContainer.Document);
param.SetParam("proxyaccount", accountName);
using (AgentProxyAccount agentProxy = new AgentProxyAccount(dataContainer, proxy))
{
if (configAction == AgentConfigAction.Create)
{
return agentProxy.Create();
}
else if (configAction == AgentConfigAction.Update)
{
return agentProxy.Update();
}
else if (configAction == AgentConfigAction.Drop)
{
return agentProxy.Drop();
}
else
{
return false;
}
}
}
catch (Exception)
{
// log exception here
return false;
}
}));
}
/// <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>
/// Handle request to get the alerts list
/// </summary>
internal async Task HandleAgentAlertsRequest(AgentAlertsParams parameters, RequestContext <AgentAlertsResult> requestContext)
{
await Task.Run(async() =>
{
var result = new AgentAlertsResult();
result.Alerts = new List <AgentAlertInfo>().ToArray();
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(parameters.OwnerUri, out connInfo);
if (connInfo != null)
{
CDataContainer dataContainer = CDataContainer.CreateDataContainer(connInfo, databaseExists: true);
AlertCollection alerts = dataContainer.Server.JobServer.Alerts;
}
await requestContext.SendResult(result);
});
}
/// <summary>
/// Handles request to import a bacpac
/// </summary>
/// <returns></returns>
public async Task HandleImportRequest(ImportParams parameters, RequestContext <DacFxResult> requestContext)
{
try
{
ConnectionInfo connInfo;
ConnectionServiceInstance.TryFindConnection(
parameters.OwnerUri,
out connInfo);
if (connInfo != null)
{
ImportOperation operation = new ImportOperation(parameters, connInfo);
ExecuteOperation(operation, parameters, SR.ImportBacpacTaskName, requestContext);
}
}
catch (Exception e)
{
await requestContext.SendError(e);
}
}
