Add Agent Service configuration request methods (#1608)

* WIP 1

* WIP 2

* Add Agent Service configuration request methods

* Fix typo

* Tabify sqlops.d.ts.

extensions/mssql/src/contracts.ts

@@ -5,9 +5,8 @@
 'use strict';
 
 import { NotificationType, RequestType } from 'vscode-languageclient';
-import * as sqlops from 'sqlops';
-
 import { ITelemetryEventProperties, ITelemetryEventMeasures } from './telemetry';
+import * as sqlops from 'sqlops';
 
 // ------------------------------- < Telemetry Sent Event > ------------------------------------
 
@@ -31,50 +30,207 @@ export class TelemetryParams {
 
 // ------------------------------- </ Telemetry Sent Event > ----------------------------------
 
-
+// ------------------------------- < Agent Management > ------------------------------------
-// Job Management types
+// Job management parameters
 export interface AgentJobsParams {
 	ownerUri: string;
 	jobId: string;
 }
 
-export interface AgentJobsResult {
-	succeeded: boolean;
-	errorMessage: string;
-	jobs: sqlops.AgentJobInfo[];
-}
-
 export interface AgentJobHistoryParams {
 	ownerUri: string;
 	jobId: string;
 }
 
-export interface AgentJobHistoryResult {
-	succeeded: boolean;
-	errorMessage: string;
-	jobs: sqlops.AgentJobHistoryInfo[];
-}
-
 export interface AgentJobActionParams {
 	ownerUri: string;
 	jobName: string;
 	action: string;
 }
 
-export interface AgentJobActionResult {
+export interface CreateAgentJobParams {
-	succeeded: boolean;
+	ownerUri: string;
-	errorMessage: string;
+	job: sqlops.AgentJobInfo;
 }
 
+export interface UpdateAgentJobParams {
+	ownerUri: string;
+	originalJobName: string;
+	job: sqlops.AgentJobInfo;
+}
+
+export interface DeleteAgentJobParams {
+	ownerUri: string;
+	job: sqlops.AgentJobInfo;
+}
+
+// Job Step management parameters
+export interface CreateAgentJobStepParams {
+	ownerUri: string;
+	step: sqlops.AgentJobStepInfo;
+}
+
+export interface UpdateAgentJobStepParams {
+	ownerUri: string;
+	originalJobStepName: string;
+	step: sqlops.AgentJobStepInfo;
+}
+
+export interface DeleteAgentJobStepParams {
+	ownerUri: string;
+	step: sqlops.AgentJobStepInfo;
+}
+
+// Alert management parameters
+export interface AgentAlertsParams {
+	ownerUri: string;
+}
+
+export interface CreateAgentAlertParams {
+	ownerUri: string;
+	alert: sqlops.AgentAlertInfo;
+}
+
+export interface UpdateAgentAlertParams {
+	ownerUri: string;
+	originalAlertName: string;
+	alert: sqlops.AgentAlertInfo;
+}
+
+export interface DeleteAgentAlertParams {
+	ownerUri: string;
+	alert: sqlops.AgentAlertInfo;
+}
+
+// Operator management parameters
+export interface AgentOperatorsParams {
+	ownerUri: string;
+}
+
+export interface CreateAgentOperatorParams {
+	ownerUri: string;
+	operator: sqlops.AgentOperatorInfo;
+}
+
+export interface UpdateAgentOperatorParams {
+	ownerUri: string;
+	originalOperatorName: string;
+	operator: sqlops.AgentOperatorInfo;
+}
+
+export interface DeleteAgentOperatorParams {
+	ownerUri: string;
+	operator: sqlops.AgentOperatorInfo;
+}
+
+// Proxy management parameters
+export interface AgentProxiesParams {
+	ownerUri: string;
+}
+
+export interface CreateAgentProxyParams {
+	ownerUri: string;
+	proxy: sqlops.AgentProxyInfo;
+}
+
+export interface UpdateAgentProxyParams {
+	ownerUri: string;
+	originalProxyName: string;
+	proxy: sqlops.AgentProxyInfo;
+}
+
+export interface DeleteAgentProxyParams {
+	ownerUri: string;
+	proxy: sqlops.AgentProxyInfo;
+}
+
+// Agent Job management requests
 export namespace AgentJobsRequest {
-	export const type = new RequestType<AgentJobsParams, AgentJobsResult, void, void>('agent/jobs');
+	export const type = new RequestType<AgentJobsParams, sqlops.AgentJobsResult, void, void>('agent/jobs');
 }
 
 export namespace AgentJobHistoryRequest {
-	export const type = new RequestType<AgentJobHistoryParams, AgentJobHistoryResult, void, void>('agent/jobhistory');
+	export const type = new RequestType<AgentJobHistoryParams, sqlops.AgentJobHistoryResult, void, void>('agent/jobhistory');
 }
 
-
 export namespace AgentJobActionRequest {
-	export const type = new RequestType<AgentJobActionParams, AgentJobActionResult, void, void>('agent/jobaction');
+	export const type = new RequestType<AgentJobActionParams, sqlops.ResultStatus, void, void>('agent/jobaction');
 }
+
+export namespace CreateAgentJobRequest {
+	export const type = new RequestType<CreateAgentJobParams, sqlops.CreateAgentJobResult, void, void>('agent/createjob');
+}
+
+export namespace UpdateAgentJobRequest {
+	export const type = new RequestType<UpdateAgentJobParams, sqlops.UpdateAgentJobResult, void, void>('agent/updatejob');
+}
+
+export namespace DeleteAgentJobRequest {
+	export const type = new RequestType<DeleteAgentJobParams, sqlops.ResultStatus, void, void>('agent/deletejob');
+}
+
+// Job Step requests
+export namespace CreateAgentJobStepRequest {
+	export const type = new RequestType<CreateAgentJobStepParams, sqlops.CreateAgentJobStepResult, void, void>('agent/createjobstep');
+}
+
+export namespace UpdateAgentJobStepRequest {
+	export const type = new RequestType<UpdateAgentJobStepParams, sqlops.UpdateAgentJobStepResult, void, void>('agent/updatejobstep');
+}
+
+export namespace DeleteAgentJobStepRequest {
+	export const type = new RequestType<DeleteAgentJobStepParams, sqlops.ResultStatus, void, void>('agent/deletejobstep');
+}
+
+// Alerts requests
+export namespace AgentAlertsRequest {
+	export const type = new RequestType<CreateAgentAlertParams, sqlops.AgentAlertsResult, void, void>('agent/alerts');
+}
+
+export namespace CreateAgentAlertRequest {
+	export const type = new RequestType<CreateAgentAlertParams, sqlops.CreateAgentAlertResult, void, void>('agent/createalert');
+}
+
+export namespace UpdateAgentAlertRequest {
+	export const type = new RequestType<UpdateAgentAlertParams, sqlops.UpdateAgentAlertResult, void, void>('agent/updatealert');
+}
+
+export namespace DeleteAgentAlertRequest {
+	export const type = new RequestType<DeleteAgentAlertParams, sqlops.ResultStatus, void, void>('agent/deletealert');
+}
+
+// Operators requests
+export namespace AgentOperatorsRequest {
+	export const type = new RequestType<CreateAgentOperatorParams, sqlops.AgentOperatorsResult, void, void>('agent/operators');
+}
+
+export namespace CreateAgentOperatorRequest {
+	export const type = new RequestType<CreateAgentOperatorParams, sqlops.CreateAgentOperatorResult, void, void>('agent/createoperator');
+}
+
+export namespace UpdateAgentOperatorRequest {
+	export const type = new RequestType<UpdateAgentOperatorParams, sqlops.UpdateAgentOperatorResult, void, void>('agent/updateoperator');
+}
+
+export namespace DeleteAgentOperatorRequest {
+	export const type = new RequestType<DeleteAgentOperatorParams, sqlops.ResultStatus, void, void>('agent/deleteoperator');
+}
+
+// Proxies requests
+export namespace AgentProxiesRequest {
+	export const type = new RequestType<CreateAgentProxyParams, sqlops.AgentProxiesResult, void, void>('agent/proxies');
+}
+
+export namespace CreateAgentProxyRequest {
+	export const type = new RequestType<CreateAgentProxyParams, sqlops.CreateAgentProxyResult, void, void>('agent/createproxy');
+}
+
+export namespace UpdateAgentProxyRequest {
+	export const type = new RequestType<UpdateAgentProxyParams, sqlops.UpdateAgentProxyResult, void, void>('agent/updateproxy');
+}
+
+export namespace DeleteAgentProxyRequest {
+	export const type = new RequestType<DeleteAgentProxyParams, sqlops.ResultStatus, void, void>('agent/deleteproxy');
+}
+
+// ------------------------------- < Agent Management > ------------------------------------

extensions/mssql/src/features.ts

@@ -6,13 +6,12 @@
 
 import { SqlOpsDataClient, SqlOpsFeature } from 'dataprotocol-client';
 import { ClientCapabilities, StaticFeature, RPCMessageType, ServerCapabilities } from 'vscode-languageclient';
-import * as UUID from 'vscode-languageclient/lib/utils/uuid';
 import { Disposable } from 'vscode';
-import * as sqlops from 'sqlops';
-
 import { Telemetry } from './telemetry';
+import * as contracts  from './contracts';
+import * as sqlops from 'sqlops';
 import * as Utils from './utils';
-import { TelemetryNotification, AgentJobsRequest, AgentJobActionRequest, AgentJobHistoryRequest, AgentJobsParams, AgentJobHistoryParams, AgentJobActionParams } from './contracts';
+import * as UUID from 'vscode-languageclient/lib/utils/uuid';
 
 export class TelemetryFeature implements StaticFeature {
 
@@ -23,7 +22,7 @@ export class TelemetryFeature implements StaticFeature {
 	}
 
 	initialize(): void {
-		this._client.onNotification(TelemetryNotification.type, e => {
+		this._client.onNotification(contracts.TelemetryNotification.type, e => {
 			Telemetry.sendTelemetryEvent(e.params.eventName, e.params.properties, e.params.measures);
 		});
 	}
@@ -31,9 +30,9 @@ export class TelemetryFeature implements StaticFeature {
 
 export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 	private static readonly messagesTypes: RPCMessageType[] = [
-		AgentJobsRequest.type,
+		contracts.AgentJobsRequest.type,
-		AgentJobHistoryRequest.type,
+		contracts.AgentJobHistoryRequest.type,
-		AgentJobActionRequest.type
+		contracts.AgentJobActionRequest.type
 	];
 
 	constructor(client: SqlOpsDataClient) {
@@ -55,35 +54,312 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 	protected registerProvider(options: undefined): Disposable {
 		const client = this._client;
 
+		// Job management methods
 		let getJobs = (ownerUri: string): Thenable<sqlops.AgentJobsResult> => {
-			let params: AgentJobsParams = { ownerUri: ownerUri, jobId: null };
+			let params: contracts.AgentJobsParams = { ownerUri: ownerUri, jobId: null };
-			return client.sendRequest(AgentJobsRequest.type, params).then(
+			return client.sendRequest(contracts.AgentJobsRequest.type, params).then(
 				r => r,
 				e => {
-					client.logFailedRequest(AgentJobsRequest.type, e);
+					client.logFailedRequest(contracts.AgentJobsRequest.type, e);
 					return Promise.resolve(undefined);
 				}
 			);
 		};
 
-		let getJobHistory = (connectionUri: string, jobID: string): Thenable<sqlops.AgentJobHistoryResult> => {
+		let getJobHistory = (ownerUri: string, jobID: string): Thenable<sqlops.AgentJobHistoryResult> => {
-			let params: AgentJobHistoryParams = { ownerUri: connectionUri, jobId: jobID };
+			let params: contracts.AgentJobHistoryParams = { ownerUri: ownerUri, jobId: jobID };
 
-			return client.sendRequest(AgentJobHistoryRequest.type, params).then(
+			return client.sendRequest(contracts.AgentJobHistoryRequest.type, params).then(
 				r => r,
 				e => {
-					client.logFailedRequest(AgentJobHistoryRequest.type, e);
+					client.logFailedRequest(contracts.AgentJobHistoryRequest.type, e);
 					return Promise.resolve(undefined);
 				}
 			);
 		};
 
-		let jobAction = (connectionUri: string, jobName: string, action: string): Thenable<sqlops.AgentJobActionResult> => {
+		let jobAction = (ownerUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> => {
-			let params: AgentJobActionParams = { ownerUri: connectionUri, jobName: jobName, action: action };
+			let params: contracts.AgentJobActionParams = { ownerUri: ownerUri, jobName: jobName, action: action };
-			return client.sendRequest(AgentJobActionRequest.type, params).then(
+			return client.sendRequest(contracts.AgentJobActionRequest.type, params).then(
 				r => r,
 				e => {
-					client.logFailedRequest(AgentJobActionRequest.type, e);
+					client.logFailedRequest(contracts.AgentJobActionRequest.type, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let createJob = (ownerUri: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.CreateAgentJobResult> => {
+			let params: contracts.CreateAgentJobParams = {
+				ownerUri: ownerUri,
+				job: jobInfo
+			};
+			let requestType = contracts.CreateAgentJobRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let updateJob = (ownerUri: string, originalJobName: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.UpdateAgentJobResult> => {
+			let params: contracts.UpdateAgentJobParams = {
+				ownerUri: ownerUri,
+				originalJobName: originalJobName,
+				job: jobInfo
+			};
+			let requestType = contracts.UpdateAgentJobRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deleteJob = (ownerUri: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus> => {
+			let params: contracts.DeleteAgentJobParams = {
+				ownerUri: ownerUri,
+				job: jobInfo
+			};
+			let requestType = contracts.DeleteAgentJobRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		// Job Step management methods
+		let createJobStep = (ownerUri: string, stepInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.CreateAgentJobStepResult> => {
+			let params: contracts.CreateAgentJobStepParams = {
+				ownerUri: ownerUri,
+				step: stepInfo
+			};
+			let requestType = contracts.CreateAgentJobStepRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let updateJobStep = (ownerUri: string, originalJobStepName: string, stepInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.UpdateAgentJobStepResult> => {
+			let params: contracts.UpdateAgentJobStepParams = {
+				ownerUri: ownerUri,
+				originalJobStepName: originalJobStepName,
+				step: stepInfo
+			};
+			let requestType = contracts.UpdateAgentJobStepRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deleteJobStep = (ownerUri: string, stepInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.ResultStatus> => {
+			let params: contracts.DeleteAgentJobStepParams = {
+				ownerUri: ownerUri,
+				step: stepInfo
+			};
+			let requestType = contracts.DeleteAgentJobStepRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		// Alert management methods
+		let  getAlerts = (ownerUri: string): Thenable<sqlops.AgentAlertsResult>  => {
+			let params: contracts.AgentAlertsParams = {
+				ownerUri: ownerUri
+			};
+			let requestType = contracts.AgentAlertsRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let createAlert = (ownerUri: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.CreateAgentAlertResult> => {
+			let params: contracts.CreateAgentAlertParams = {
+				ownerUri: ownerUri,
+				alert: alertInfo
+			};
+			let requestType = contracts.CreateAgentAlertRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let updateAlert = (ownerUri: string, originalAlertName: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.UpdateAgentAlertResult> => {
+			let params: contracts.UpdateAgentAlertParams = {
+				ownerUri: ownerUri,
+				originalAlertName: originalAlertName,
+				alert: alertInfo
+			};
+			let requestType = contracts.UpdateAgentAlertRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deleteAlert = (ownerUri: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus> => {
+			let params: contracts.DeleteAgentAlertParams = {
+				ownerUri: ownerUri,
+				alert: alertInfo
+			};
+			let requestType = contracts.DeleteAgentAlertRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		// Operator management methods
+		let  getOperators = (ownerUri: string): Thenable<sqlops.AgentOperatorsResult>  => {
+			let params: contracts.AgentOperatorsParams = {
+				ownerUri: ownerUri
+			};
+			let requestType = contracts.AgentOperatorsRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let createOperator = (ownerUri: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.CreateAgentOperatorResult> => {
+			let params: contracts.CreateAgentOperatorParams = {
+				ownerUri: ownerUri,
+				operator: operatorInfo
+			};
+			let requestType = contracts.CreateAgentOperatorRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let updateOperator = (ownerUri: string, originalOperatorName: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.UpdateAgentOperatorResult> => {
+			let params: contracts.UpdateAgentOperatorParams = {
+				ownerUri: ownerUri,
+				originalOperatorName: originalOperatorName,
+				operator: operatorInfo
+			};
+			let requestType = contracts.UpdateAgentOperatorRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deleteOperator = (ownerUri: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus> => {
+			let params: contracts.DeleteAgentOperatorParams = {
+				ownerUri: ownerUri,
+				operator: operatorInfo
+			};
+			let requestType = contracts.DeleteAgentOperatorRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		// Proxy management methods
+		let  getProxies = (ownerUri: string): Thenable<sqlops.AgentProxiesResult>  => {
+			let params: contracts.AgentProxiesParams = {
+				ownerUri: ownerUri
+			};
+			let requestType = contracts.AgentProxiesRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let createProxy = (ownerUri: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.CreateAgentOperatorResult> => {
+			let params: contracts.CreateAgentProxyParams = {
+				ownerUri: ownerUri,
+				proxy: proxyInfo
+			};
+			let requestType = contracts.CreateAgentProxyRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let updateProxy = (ownerUri: string, originalProxyName: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.UpdateAgentOperatorResult> => {
+			let params: contracts.UpdateAgentProxyParams = {
+				ownerUri: ownerUri,
+				originalProxyName: originalProxyName,
+				proxy: proxyInfo
+			};
+			let requestType = contracts.UpdateAgentProxyRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
+					return Promise.resolve(undefined);
+				}
+			);
+		};
+
+		let deleteProxy = (ownerUri: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus> => {
+			let params: contracts.DeleteAgentProxyParams = {
+				ownerUri: ownerUri,
+				proxy: proxyInfo
+			};
+			let requestType = contracts.DeleteAgentProxyRequest.type;
+			return client.sendRequest(requestType, params).then(
+				r => r,
+				e => {
+					client.logFailedRequest(requestType, e);
 					return Promise.resolve(undefined);
 				}
 			);
@@ -93,7 +369,25 @@ export class AgentServicesFeature extends SqlOpsFeature<undefined> {
 			providerId: client.providerId,
 			getJobs,
 			getJobHistory,
-			jobAction
+			jobAction,
+			createJob,
+			updateJob,
+			deleteJob,
+			createJobStep,
+			updateJobStep,
+			deleteJobStep,
+			getAlerts,
+			createAlert,
+			updateAlert,
+			deleteAlert,
+			getOperators,
+			createOperator,
+			updateOperator,
+			deleteOperator,
+			getProxies,
+			createProxy,
+			updateProxy,
+			deleteProxy
 		});
 	}
 }

src/sql/parts/jobManagement/common/interfaces.ts

@@ -23,7 +23,7 @@ export interface IJobManagementService {
 
 	getJobHistory(connectionUri: string, jobID: string): Thenable<sqlops.AgentJobHistoryResult>;
 
-	jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.AgentJobActionResult>;
+	jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus>;
 
 	addToCache(server: string, cache: JobCacheObject);
 

src/sql/parts/jobManagement/common/jobManagementService.ts

@@ -39,7 +39,7 @@ export class JobManagementService implements IJobManagementService {
 		});
 	}
 
-	public jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.AgentJobActionResult> {
+	public jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> {
 		return this._runAction(connectionUri, (runner) => {
 			return runner.jobAction(connectionUri, jobName, action);
 		});

src/sql/parts/jobManagement/views/jobHistoryActions.ts

@@ -33,7 +33,7 @@ export class RunJobAction extends Action {
 		let ownerUri = context.ownerUri;
 		return new TPromise<boolean>((resolve, reject) => {
 			this.jobManagementService.jobAction(ownerUri, jobName, JobHistoryActions.Run).then(result => {
-				if (result.succeeded) {
+				if (result.success) {
 					var startMsg = nls.localize('jobSuccessfullyStarted', ': The job was successfully started.');
 					this.notificationService.notify({
 						severity: Severity.Info,
@@ -68,7 +68,7 @@ export class StopJobAction extends Action {
 		let ownerUri = context.ownerUri;
 		return new TPromise<boolean>((resolve, reject) => {
 			this.jobManagementService.jobAction(ownerUri, jobName, JobHistoryActions.Stop).then(result => {
-				if (result.succeeded) {
+				if (result.success) {
 						var stopMsg = nls.localize('jobSuccessfullyStopped', ': The job was successfully stopped.');
 						this.notificationService.notify({
 							severity: Severity.Info,

src/sql/sqlops.d.ts

@@ -1025,22 +1025,33 @@ declare module 'sqlops' {
 		getDatabaseInfo(connectionUri: string): Thenable<DatabaseInfo>;
 	}
 
-	// Agent Services interfaces
+	// Agent Services types
-	export interface AgentJobsResult {
+	export enum WeekDays {
-		succeeded: boolean;
+		sunday = 1,
-		errorMessage: string;
+		monday = 2,
-		jobs: AgentJobInfo[];
+		tuesday = 4,
+		wednesday = 8,
+		thursday = 16,
+		friday = 32,
+		weekDays = 62,
+		saturday = 64,
+		weekEnds = 65,
+		everyDay = 127
 	}
 
-	export interface AgentJobHistoryResult {
+	export enum NotifyMethods {
-		succeeded: boolean;
+		none = 0,
-		errorMessage: string;
+		notifyEmail = 1,
-		jobs: AgentJobHistoryInfo[];
+		pager = 2,
+		netSend = 4,
+		notifyAll = 7
 	}
 
-	export interface AgentJobActionResult {
+	export enum AlertType {
-		succeeded: boolean;
+		sqlServerEvent = 1,
-		errorMessage: string;
+		sqlServerPerformanceCondition = 2,
+		nonSqlServerEvent = 3,
+		wmiEvent = 4
 	}
 
 	export interface AgentJobInfo {
@@ -1061,7 +1072,8 @@ declare module 'sqlops' {
 		jobId: string;
 	}
 
-	export interface AgentJobStep {
+	export interface AgentJobStepInfo {
+		jobId: string;
 		stepId: string;
 		stepName: string;
 		message: string;
@@ -1086,13 +1098,168 @@ declare module 'sqlops' {
 		operatorPaged: string;
 		retriesAttempted: string;
 		server: string;
-		steps: AgentJobStep[];
+		steps: AgentJobStepInfo[];
+	}
+
+	export interface AgentProxyInfo {
+		id: number;
+		accountName: string;
+		description: string;
+		credentialName: string;
+		credentialIdentity: string;
+		credentialId: number;
+		isEnabled: boolean;
+	}
+
+	export interface AgentAlertInfo {
+		id: number;
+		delayBetweenResponses: number;
+		eventDescriptionKeyword: string;
+		eventSource: string;
+		hasNotification: number;
+		includeEventDescription: NotifyMethods;
+		isEnabled: boolean;
+		jobId: string;
+		jobName: string;
+		lastOccurrenceDate: string;
+		lastResponseDate: string;
+		messageId: number;
+		notificationMessage: string;
+		occurrenceCount: number;
+		performanceCondition: string;
+		severity: number;
+		databaseName: string;
+		countResetDate: string;
+		categoryName: string;
+		alertType: AlertType;
+		wmiEventNamespace: string;
+		wmiEventQuery: string;
+	}
+
+	export interface AgentOperatorInfo {
+		name: string;
+		id: number;
+		emailAddress: string;
+		enabled: boolean;
+		lastEmailDate: string;
+		lastNetSendDate: string;
+		lastPagerDate: string;
+		pagerAddress: string;
+		categoryName: string;
+		pagerDays: WeekDays;
+		saturdayPagerEndTime: string;
+		saturdayPagerStartTime: string;
+		sundayPagerEndTime: string;
+		sundayPagerStartTime: string;
+		netSendAddress: string;
+		weekdayPagerStartTime: string;
+		weekdayPagerEndTime: string;
+	}
+
+	export interface ResultStatus {
+		success: boolean;
+		errorMessage: string;
+	}
+
+	export interface AgentJobsResult extends ResultStatus {
+		jobs: AgentJobInfo[];
+	}
+
+	export interface AgentJobHistoryResult extends ResultStatus {
+		jobs: AgentJobHistoryInfo[];
+	}
+
+	export interface CreateAgentJobResult extends ResultStatus {
+		job: AgentJobInfo;
+	}
+
+	export interface UpdateAgentJobResult extends ResultStatus  {
+		job: AgentJobInfo;
+	}
+
+	export interface CreateAgentJobStepResult extends ResultStatus {
+		step: AgentJobStepInfo;
+	}
+
+	export interface UpdateAgentJobStepResult extends ResultStatus  {
+		step: AgentJobStepInfo;
+	}
+
+	export interface CreateAgentProxyResult extends ResultStatus {
+		step: AgentJobStepInfo;
+	}
+
+	export interface UpdateAgentProxyResult extends ResultStatus  {
+		step: AgentJobStepInfo;
+	}
+
+	export interface AgentAlertsResult extends ResultStatus {
+		alerts: AgentAlertInfo[];
+	}
+
+	export interface CreateAgentAlertResult extends ResultStatus {
+		alert: AgentJobStepInfo;
+	}
+
+	export interface UpdateAgentAlertResult extends ResultStatus  {
+		alert: AgentJobStepInfo;
+	}
+
+	export interface AgentOperatorsResult extends ResultStatus {
+		operators: AgentOperatorInfo[];
+	}
+
+	export interface CreateAgentOperatorResult extends ResultStatus {
+		operator: AgentOperatorInfo;
+	}
+
+	export interface UpdateAgentOperatorResult extends ResultStatus  {
+		operator: AgentOperatorInfo;
+	}
+
+	export interface AgentProxiesResult extends ResultStatus {
+		operators: AgentOperatorInfo[];
+	}
+
+	export interface CreateAgentProxyResult extends ResultStatus {
+		operator: AgentOperatorInfo;
+	}
+
+	export interface UpdateAgentProxyResult extends ResultStatus  {
+		operator: AgentOperatorInfo;
 	}
 
 	export interface AgentServicesProvider extends DataProvider {
-		getJobs(connectionUri: string): Thenable<AgentJobsResult>;
+		// Job management methods
-		getJobHistory(connectionUri: string, jobId: string): Thenable<AgentJobHistoryResult>;
+		getJobs(ownerUri: string): Thenable<AgentJobsResult>;
-		jobAction(connectionUri: string, jobName: string, action: string): Thenable<AgentJobActionResult>;
+		getJobHistory(ownerUri: string, jobId: string): Thenable<AgentJobHistoryResult>;
+		jobAction(ownerUri: string, jobName: string, action: string): Thenable<ResultStatus>;
+		createJob(ownerUri: string, jobInfo: AgentJobInfo): Thenable<CreateAgentJobResult>;
+		updateJob(ownerUri: string, originalJobName: string, jobInfo: AgentJobInfo): Thenable<UpdateAgentJobResult>;
+		deleteJob(ownerUri: string, jobInfo: AgentJobInfo): Thenable<ResultStatus>;
+
+		// Job Step management methods
+		createJobStep(ownerUri: string, jobInfo: AgentJobStepInfo): Thenable<CreateAgentJobStepResult>;
+		updateJobStep(ownerUri: string, originalJobStepName: string, jobInfo: AgentJobStepInfo): Thenable<UpdateAgentJobStepResult>;
+		deleteJobStep(ownerUri: string, jobInfo: AgentJobStepInfo): Thenable<ResultStatus>;
+
+		// Alert management methods
+		getAlerts(ownerUri: string): Thenable<AgentAlertsResult>;
+		createAlert(ownerUri: string, alertInfo: AgentAlertInfo): Thenable<CreateAgentAlertResult>;
+		updateAlert(ownerUri: string, originalAlertName: string, alertInfo: AgentAlertInfo): Thenable<UpdateAgentAlertResult>;
+		deleteAlert(ownerUri: string, alertInfo: AgentAlertInfo): Thenable<ResultStatus>;
+
+		// Operator management methods
+		getOperators(ownerUri: string): Thenable<AgentOperatorsResult>;
+		createOperator(ownerUri: string, operatorInfo: AgentOperatorInfo): Thenable<CreateAgentOperatorResult>;
+		updateOperator(ownerUri: string, originalOperatorName: string, operatorInfo: AgentOperatorInfo): Thenable<UpdateAgentOperatorResult>;
+		deleteOperator(ownerUri: string, operatorInfo: AgentOperatorInfo): Thenable<ResultStatus>;
+
+		// Proxy management methods
+		getProxies(ownerUri: string): Thenable<AgentProxiesResult>;
+		createProxy(ownerUri: string, proxyInfo: AgentProxyInfo): Thenable<CreateAgentOperatorResult>;
+		updateProxy(ownerUri: string, originalProxyName: string, proxyInfo: AgentProxyInfo): Thenable<UpdateAgentOperatorResult>;
+		deleteProxy(ownerUri: string, proxyInfo: AgentProxyInfo): Thenable<ResultStatus>;
 	}
 
 	// Task service interfaces ----------------------------------------------------------------------------

src/sql/workbench/api/common/sqlExtHostTypes.ts

@@ -63,6 +63,37 @@ export enum ScriptOperation {
 	Alter = 6
 }
 
+export enum WeekDays
+{
+	sunday = 1,
+	monday = 2,
+	tuesday = 4,
+	wednesday = 8,
+	thursday = 16,
+	friday = 32,
+	weekDays = 62,
+	saturday = 64,
+	weekEnds = 65,
+	everyDay = 127
+}
+
+export enum NotifyMethods
+{
+	none = 0,
+	notifyEmail = 1,
+	pager = 2,
+	netSend = 4,
+	notifyAll = 7
+}
+
+export enum AlertType
+{
+	sqlServerEvent = 1,
+	sqlServerPerformanceCondition = 2,
+	nonSqlServerEvent = 3,
+	wmiEvent = 4
+}
+
 export enum ModelComponentTypes {
 	NavContainer,
 	FlexContainer,

src/sql/workbench/api/node/extHostDataProtocol.ts

@@ -532,7 +532,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	/**
 	 * Run an action on a job
 	 */
-	public $jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<sqlops.AgentJobActionResult> {
+	public $jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> {
 		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).jobAction(ownerUri, jobName, action);
 	}
 }

src/sql/workbench/api/node/mainThreadDataProtocol.ts

@@ -339,7 +339,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			getJobHistory(connectionUri: string, jobID: string): Thenable<sqlops.AgentJobHistoryResult> {
 				return self._proxy.$getJobHistory(handle, connectionUri, jobID);
 			},
-			jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.AgentJobActionResult> {
+			jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> {
 				return self._proxy.$jobAction(handle, connectionUri, jobName, action);
 			}
 		});

src/sql/workbench/api/node/sqlExtHost.api.impl.ts

@@ -377,6 +377,9 @@ export function createApiFactory(
 				TaskStatus: sqlExtHostTypes.TaskStatus,
 				TaskExecutionMode: sqlExtHostTypes.TaskExecutionMode,
 				ScriptOperation: sqlExtHostTypes.ScriptOperation,
+				WeekDays: sqlExtHostTypes.WeekDays,
+				NotifyMethods: sqlExtHostTypes.NotifyMethods,
+				AlertType: sqlExtHostTypes.AlertType,
 				window,
 				tasks,
 				dashboard,

src/sql/workbench/api/node/sqlExtHost.protocol.ts

@@ -327,7 +327,7 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Run an action on a Job
 	 */
-	$jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<sqlops.AgentJobActionResult> { throw ni(); }
+	$jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> { throw ni(); }
 }
 
 /**