/// <summary> /// Retrieve metric data /// </summary> /// <remarks> /// Gets metric values for a single metric /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='appId'> /// ID of the application. This is Application ID from the API Access settings /// blade in the Azure portal. /// </param> /// <param name='metricId'> /// ID of the metric. This is either a standard AI metric, or an /// application-specific custom metric. Possible values include: /// 'requests/count', 'requests/duration', 'requests/failed', 'users/count', /// 'users/authenticated', 'pageViews/count', 'pageViews/duration', /// 'client/processingDuration', 'client/receiveDuration', /// 'client/networkDuration', 'client/sendDuration', 'client/totalDuration', /// 'dependencies/count', 'dependencies/failed', 'dependencies/duration', /// 'exceptions/count', 'exceptions/browser', 'exceptions/server', /// 'sessions/count', 'performanceCounters/requestExecutionTime', /// 'performanceCounters/requestsPerSecond', /// 'performanceCounters/requestsInQueue', /// 'performanceCounters/memoryAvailableBytes', /// 'performanceCounters/exceptionsPerSecond', /// 'performanceCounters/processCpuPercentage', /// 'performanceCounters/processIOBytesPerSecond', /// 'performanceCounters/processPrivateBytes', /// 'performanceCounters/processorCpuPercentage', /// 'availabilityResults/availabilityPercentage', /// 'availabilityResults/duration', 'billing/telemetryCount', /// 'customEvents/count' /// </param> /// <param name='timespan'> /// The timespan over which to retrieve metric values. This is an ISO8601 time /// period value. If timespan is omitted, a default time range of `PT12H` /// ("last 12 hours") is used. The actual timespan that is queried may be /// adjusted by the server based. In all cases, the actual time span used for /// the query is included in the response. /// </param> /// <param name='interval'> /// The time interval to use when retrieving metric values. This is an ISO8601 /// duration. If interval is omitted, the metric value is aggregated across the /// entire timespan. If interval is supplied, the server may adjust the /// interval to a more appropriate size based on the timespan used for the /// query. In all cases, the actual interval used for the query is included in /// the response. /// </param> /// <param name='aggregation'> /// The aggregation to use when computing the metric values. To retrieve more /// than one aggregation at a time, separate them with a comma. If no /// aggregation is specified, then the default aggregation for the metric is /// used. /// </param> /// <param name='segment'> /// The name of the dimension to segment the metric values by. This dimension /// must be applicable to the metric you are retrieving. To segment by more /// than one dimension at a time, separate them with a comma (,). In this case, /// the metric data will be segmented in the order the dimensions are listed in /// the parameter. /// </param> /// <param name='top'> /// The number of segments to return. This value is only valid when segment is /// specified. /// </param> /// <param name='orderby'> /// The aggregation function and direction to sort the segments by. This value /// is only valid when segment is specified. /// </param> /// <param name='filter'> /// An expression used to filter the results. This value should be a valid /// OData filter expression where the keys of each clause should be applicable /// dimensions for the metric you are retrieving. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <MetricsResult> GetAsync(this IMetrics operations, string appId, string metricId, string timespan = default(string), System.TimeSpan?interval = default(System.TimeSpan?), IList <string> aggregation = default(IList <string>), IList <string> segment = default(IList <string>), int?top = default(int?), string orderby = default(string), string filter = default(string), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.GetWithHttpMessagesAsync(appId, metricId, timespan, interval, aggregation, segment, top, orderby, filter, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Initializes a new instance of the MetricAvailability class. /// </summary> /// <param name="timeGrain">the time grain specifies the aggregation /// interval for the metric. Expressed as a duration 'PT1M', 'P1D', /// etc.</param> /// <param name="retention">the retention period for the metric at the /// specified timegrain. Expressed as a duration 'PT1M', 'P1D', /// etc.</param> public MetricAvailability(System.TimeSpan?timeGrain = default(System.TimeSpan?), System.TimeSpan?retention = default(System.TimeSpan?)) { TimeGrain = timeGrain; Retention = retention; CustomInit(); }
public static System.TimeSpan? DateAdd(System.String datePartArg, System.Double? number, System.TimeSpan? time) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionDirectCall); }
/// <summary> /// Initializes a new instance of the DurationWrapper class. /// </summary> public DurationWrapper(System.TimeSpan?field = default(System.TimeSpan?)) { Field = field; CustomInit(); }
/// <summary> /// Initializes a new instance of the JobPropertiesConstraints class. /// </summary> /// <param name="maxWallClockTime">Max wall clock time.</param> public JobPropertiesConstraints(System.TimeSpan?maxWallClockTime = default(System.TimeSpan?)) { MaxWallClockTime = maxWallClockTime; CustomInit(); }
/// <summary> /// Initializes a new instance of the PoolResizeParameter class. /// </summary> /// <param name="targetDedicated">The desired number of compute nodes /// in the pool.</param> /// <param name="resizeTimeout">The timeout for allocation of compute /// nodes to the pool or removal of compute nodes from the /// pool.</param> /// <param name="nodeDeallocationOption">When nodes may be removed /// from the pool, if the pool size is decreasing.</param> public PoolResizeParameter(int targetDedicated, System.TimeSpan?resizeTimeout = default(System.TimeSpan?), ComputeNodeDeallocationOption?nodeDeallocationOption = default(ComputeNodeDeallocationOption?)) { TargetDedicated = targetDedicated; ResizeTimeout = resizeTimeout; NodeDeallocationOption = nodeDeallocationOption; }
/// <summary> /// Initializes a new instance of the Response class. /// </summary> /// <param name="timespan">The timespan for which the data was /// retrieved. Its value consists of two datetimes concatenated, /// separated by '/'. This may be adjusted in the future and returned /// back from what was originally requested.</param> /// <param name="value">the value of the collection.</param> /// <param name="cost">The integer value representing the relative cost /// of the query.</param> /// <param name="interval">The interval (window size) for which the /// metric data was returned in. This may be adjusted in the future /// and returned back from what was originally requested. This is not /// present if a metadata request was made.</param> /// <param name="namespaceProperty">The namespace of the metrics being /// queried</param> /// <param name="resourceregion">The region of the resource being /// queried for metrics.</param> public Response(string timespan, IList <Metric> value, double?cost = default(double?), System.TimeSpan?interval = default(System.TimeSpan?), string namespaceProperty = default(string), string resourceregion = default(string)) { Cost = cost; Timespan = timespan; Interval = interval; NamespaceProperty = namespaceProperty; Resourceregion = resourceregion; Value = value; CustomInit(); }
/// <summary> /// Initializes a new instance of the /// DefaultRolloutSpecificationMediumTraffic class. /// </summary> public DefaultRolloutSpecificationMediumTraffic(IList <string> regions = default(IList <string>), System.TimeSpan?waitDuration = default(System.TimeSpan?)) : base(regions, waitDuration) { CustomInit(); }
/// <summary> /// Initializes a new instance of the HeaderResponseDurationHeaders /// class. /// </summary> /// <param name="value">response with header values /// "P123DT22H14M12.011S"</param> public HeaderResponseDurationHeaders(System.TimeSpan?value = default(System.TimeSpan?)) { Value = value; CustomInit(); }
public void StartAdvertising(string name, System.Collections.Generic.List <string> appIdentifiers, System.TimeSpan?advertisingDuration, System.Action <AdvertisingResult> resultCallback, System.Action <ConnectionRequest> connectionRequestCallback) { AdvertisingResult obj = new AdvertisingResult(ResponseStatus.LicenseCheckFailed, string.Empty); resultCallback.Invoke(obj); }
public void StartDiscovery(string serviceId, System.TimeSpan?advertisingTimeout, IDiscoveryListener listener) { Debug.LogError("StartDiscovery in dummy implementation called"); }
/// <summary> /// Initializes a new instance of the ContentKeyPolicyPlayReadyLicense /// class. /// </summary> /// <param name="allowTestDevices">A flag indicating whether test /// devices can use the license.</param> /// <param name="licenseType">The license type. Possible values /// include: 'Unknown', 'NonPersistent', 'Persistent'</param> /// <param name="contentKeyLocation">The content key location.</param> /// <param name="contentType">The PlayReady content type. Possible /// values include: 'Unknown', 'Unspecified', 'UltraVioletDownload', /// 'UltraVioletStreaming'</param> /// <param name="beginDate">The begin date of license</param> /// <param name="expirationDate">The expiration date of /// license.</param> /// <param name="relativeBeginDate">The relative begin date of /// license.</param> /// <param name="relativeExpirationDate">The relative expiration date /// of license.</param> /// <param name="gracePeriod">The grace period of license.</param> /// <param name="playRight">The license PlayRight</param> public ContentKeyPolicyPlayReadyLicense(bool allowTestDevices, string licenseType, ContentKeyPolicyPlayReadyContentKeyLocation contentKeyLocation, string contentType, System.DateTime?beginDate = default(System.DateTime?), System.DateTime?expirationDate = default(System.DateTime?), System.TimeSpan?relativeBeginDate = default(System.TimeSpan?), System.TimeSpan?relativeExpirationDate = default(System.TimeSpan?), System.TimeSpan?gracePeriod = default(System.TimeSpan?), ContentKeyPolicyPlayReadyPlayRight playRight = default(ContentKeyPolicyPlayReadyPlayRight)) { AllowTestDevices = allowTestDevices; BeginDate = beginDate; ExpirationDate = expirationDate; RelativeBeginDate = relativeBeginDate; RelativeExpirationDate = relativeExpirationDate; GracePeriod = gracePeriod; PlayRight = playRight; LicenseType = licenseType; ContentKeyLocation = contentKeyLocation; ContentType = contentType; CustomInit(); }
/// <summary> /// Initializes a new instance of the CacheConfiguration class. /// </summary> /// <param name="queryParameterStripDirective">Treatment of URL query /// terms when forming the cache key. Possible values include: /// 'StripNone', 'StripAll', 'StripOnly', 'StripAllExcept'</param> /// <param name="queryParameters">query parameters to include or /// exclude (comma separated).</param> /// <param name="dynamicCompression">Whether to use dynamic compression /// for cached content. Possible values include: 'Enabled', /// 'Disabled'</param> /// <param name="cacheDuration">The duration for which the content /// needs to be cached. Allowed format is in ISO 8601 format /// (http://en.wikipedia.org/wiki/ISO_8601#Durations). HTTP requires /// the value to be no more than a year</param> public CacheConfiguration(string queryParameterStripDirective = default(string), string queryParameters = default(string), string dynamicCompression = default(string), System.TimeSpan?cacheDuration = default(System.TimeSpan?)) { QueryParameterStripDirective = queryParameterStripDirective; QueryParameters = queryParameters; DynamicCompression = dynamicCompression; CacheDuration = cacheDuration; CustomInit(); }
/// <summary> /// Retrieve metric data /// </summary> /// <remarks> /// Gets metric values for a single metric /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='appId'> /// ID of the application. This is Application ID from the API Access settings /// blade in the Azure portal. /// </param> /// <param name='metricId'> /// ID of the metric. This is either a standard AI metric, or an /// application-specific custom metric. Possible values include: /// 'requests/count', 'requests/duration', 'requests/failed', 'users/count', /// 'users/authenticated', 'pageViews/count', 'pageViews/duration', /// 'client/processingDuration', 'client/receiveDuration', /// 'client/networkDuration', 'client/sendDuration', 'client/totalDuration', /// 'dependencies/count', 'dependencies/failed', 'dependencies/duration', /// 'exceptions/count', 'exceptions/browser', 'exceptions/server', /// 'sessions/count', 'performanceCounters/requestExecutionTime', /// 'performanceCounters/requestsPerSecond', /// 'performanceCounters/requestsInQueue', /// 'performanceCounters/memoryAvailableBytes', /// 'performanceCounters/exceptionsPerSecond', /// 'performanceCounters/processCpuPercentage', /// 'performanceCounters/processIOBytesPerSecond', /// 'performanceCounters/processPrivateBytes', /// 'performanceCounters/processorCpuPercentage', /// 'availabilityResults/availabilityPercentage', /// 'availabilityResults/duration', 'billing/telemetryCount', /// 'customEvents/count' /// </param> /// <param name='timespan'> /// The timespan over which to retrieve metric values. This is an ISO8601 time /// period value. If timespan is omitted, a default time range of `PT12H` /// ("last 12 hours") is used. The actual timespan that is queried may be /// adjusted by the server based. In all cases, the actual time span used for /// the query is included in the response. /// </param> /// <param name='interval'> /// The time interval to use when retrieving metric values. This is an ISO8601 /// duration. If interval is omitted, the metric value is aggregated across the /// entire timespan. If interval is supplied, the server may adjust the /// interval to a more appropriate size based on the timespan used for the /// query. In all cases, the actual interval used for the query is included in /// the response. /// </param> /// <param name='aggregation'> /// The aggregation to use when computing the metric values. To retrieve more /// than one aggregation at a time, separate them with a comma. If no /// aggregation is specified, then the default aggregation for the metric is /// used. /// </param> /// <param name='segment'> /// The name of the dimension to segment the metric values by. This dimension /// must be applicable to the metric you are retrieving. To segment by more /// than one dimension at a time, separate them with a comma (,). In this case, /// the metric data will be segmented in the order the dimensions are listed in /// the parameter. /// </param> /// <param name='top'> /// The number of segments to return. This value is only valid when segment is /// specified. /// </param> /// <param name='orderby'> /// The aggregation function and direction to sort the segments by. This value /// is only valid when segment is specified. /// </param> /// <param name='filter'> /// An expression used to filter the results. This value should be a valid /// OData filter expression where the keys of each clause should be applicable /// dimensions for the metric you are retrieving. /// </param> public static MetricsResult Get(this IMetrics operations, string appId, string metricId, string timespan = default(string), System.TimeSpan?interval = default(System.TimeSpan?), IList <string> aggregation = default(IList <string>), IList <string> segment = default(IList <string>), int?top = default(int?), string orderby = default(string), string filter = default(string)) { return(operations.GetAsync(appId, metricId, timespan, interval, aggregation, segment, top, orderby, filter).GetAwaiter().GetResult()); }
public static System.IDisposable CreateServiceTimeoutScope(System.TimeSpan?timeout) { throw null; }
/// <summary> /// Initializes a new instance of the CollectionItemUpdateConfiguration /// class. /// </summary> /// <param name="azureVirtualMachines">List of azure resource Ids for /// azure virtual machines targeted by the software update /// configuration.</param> /// <param name="duration">Maximum time allowed for the software update /// configuration run. Duration needs to be specified using the format /// PT[n]H[n]M[n]S as per ISO8601</param> public CollectionItemUpdateConfiguration(IList <string> azureVirtualMachines = default(IList <string>), System.TimeSpan?duration = default(System.TimeSpan?)) { AzureVirtualMachines = azureVirtualMachines; Duration = duration; CustomInit(); }
/// <summary> /// **Gets the baseline values for a specific metric**. /// </summary> /// <param name='resourceUri'> /// The identifier of the resource. It has the following structure: /// subscriptions/{subscriptionName}/resourceGroups/{resourceGroupName}/providers/{providerName}/{resourceName}. /// For example: /// subscriptions/b368ca2f-e298-46b7-b0ab-012281956afa/resourceGroups/vms/providers/Microsoft.Compute/virtualMachines/vm1 /// </param> /// <param name='metricName'> /// The name of the metric to retrieve the baseline for. /// </param> /// <param name='timespan'> /// The timespan of the query. It is a string with the following format /// 'startDateTime_ISO/endDateTime_ISO'. /// </param> /// <param name='interval'> /// The interval (i.e. timegrain) of the query. /// </param> /// <param name='aggregation'> /// The aggregation type of the metric to retrieve the baseline for. /// </param> /// <param name='sensitivities'> /// The list of sensitivities (comma separated) to retrieve. /// </param> /// <param name='resultType'> /// Allows retrieving only metadata of the baseline. On data request all /// information is retrieved. Possible values include: 'Data', 'Metadata' /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorResponseException"> /// Thrown when the operation returned an invalid status code /// </exception> /// <exception cref="SerializationException"> /// Thrown when unable to deserialize the response /// </exception> /// <exception cref="ValidationException"> /// Thrown when a required parameter is null /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <AzureOperationResponse <BaselineResponse> > GetWithHttpMessagesAsync(string resourceUri, string metricName, string timespan = default(string), System.TimeSpan?interval = default(System.TimeSpan?), string aggregation = default(string), string sensitivities = default(string), ResultType?resultType = default(ResultType?), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (resourceUri == null) { throw new ValidationException(ValidationRules.CannotBeNull, "resourceUri"); } if (metricName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "metricName"); } string apiVersion = "2017-11-01-preview"; // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceUri", resourceUri); tracingParameters.Add("metricName", metricName); tracingParameters.Add("timespan", timespan); tracingParameters.Add("interval", interval); tracingParameters.Add("aggregation", aggregation); tracingParameters.Add("sensitivities", sensitivities); tracingParameters.Add("resultType", resultType); tracingParameters.Add("apiVersion", apiVersion); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "Get", tracingParameters); } // Construct URL var _baseUrl = Client.BaseUri.AbsoluteUri; var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "{resourceUri}/providers/microsoft.insights/baseline/{metricName}").ToString(); _url = _url.Replace("{resourceUri}", resourceUri); _url = _url.Replace("{metricName}", System.Uri.EscapeDataString(metricName)); List <string> _queryParameters = new List <string>(); if (timespan != null) { _queryParameters.Add(string.Format("timespan={0}", System.Uri.EscapeDataString(timespan))); } if (interval != null) { _queryParameters.Add(string.Format("interval={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(interval, Client.SerializationSettings).Trim('"')))); } if (aggregation != null) { _queryParameters.Add(string.Format("aggregation={0}", System.Uri.EscapeDataString(aggregation))); } if (sensitivities != null) { _queryParameters.Add(string.Format("sensitivities={0}", System.Uri.EscapeDataString(sensitivities))); } if (resultType != null) { _queryParameters.Add(string.Format("resultType={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(resultType, Client.SerializationSettings).Trim('"')))); } if (apiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", System.Uri.EscapeDataString(apiVersion))); } if (_queryParameters.Count > 0) { _url += (_url.Contains("?") ? "&" : "?") + string.Join("&", _queryParameters); } // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("GET"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (Client.GenerateClientRequestId != null && Client.GenerateClientRequestId.Value) { _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", System.Guid.NewGuid().ToString()); } if (Client.AcceptLanguage != null) { if (_httpRequest.Headers.Contains("accept-language")) { _httpRequest.Headers.Remove("accept-language"); } _httpRequest.Headers.TryAddWithoutValidation("accept-language", Client.AcceptLanguage); } if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; // Set Credentials if (Client.Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new ErrorResponseException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); ErrorResponse _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <ErrorResponse>(_responseContent, Client.DeserializationSettings); if (_errorBody != null) { ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new AzureOperationResponse <BaselineResponse>(); _result.Request = _httpRequest; _result.Response = _httpResponse; if (_httpResponse.Headers.Contains("x-ms-request-id")) { _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <BaselineResponse>(_responseContent, Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
/// <summary> /// Initializes a new instance of the AzureStorageJob class. /// </summary> /// <param name="entityFriendlyName">Friendly name of the entity on /// which the current job is executing.</param> /// <param name="backupManagementType">Backup management type to /// execute the current job. Possible values include: 'Invalid', /// 'AzureIaasVM', 'MAB', 'DPM', 'AzureBackupServer', 'AzureSql', /// 'AzureStorage', 'AzureWorkload', 'DefaultBackup'</param> /// <param name="operation">The operation name.</param> /// <param name="status">Job status.</param> /// <param name="startTime">The start time.</param> /// <param name="endTime">The end time.</param> /// <param name="activityId">ActivityId of job.</param> /// <param name="duration">Time elapsed during the execution of this /// job.</param> /// <param name="actionsInfo">Gets or sets the state/actions applicable /// on this job like cancel/retry.</param> /// <param name="errorDetails">Error details on execution of this /// job.</param> /// <param name="storageAccountName">Specifies friendly name of the /// storage account.</param> /// <param name="storageAccountVersion">Specifies whether the Storage /// account is a Classic or an Azure Resource Manager Storage /// account.</param> /// <param name="extendedInfo">Additional information about the /// job.</param> public AzureStorageJob(string entityFriendlyName = default(string), string backupManagementType = default(string), string operation = default(string), string status = default(string), System.DateTime?startTime = default(System.DateTime?), System.DateTime?endTime = default(System.DateTime?), string activityId = default(string), System.TimeSpan?duration = default(System.TimeSpan?), IList <JobSupportedAction?> actionsInfo = default(IList <JobSupportedAction?>), IList <AzureStorageErrorInfo> errorDetails = default(IList <AzureStorageErrorInfo>), string storageAccountName = default(string), string storageAccountVersion = default(string), AzureStorageJobExtendedInfo extendedInfo = default(AzureStorageJobExtendedInfo)) : base(entityFriendlyName, backupManagementType, operation, status, startTime, endTime, activityId) { Duration = duration; ActionsInfo = actionsInfo; ErrorDetails = errorDetails; StorageAccountName = storageAccountName; StorageAccountVersion = storageAccountVersion; ExtendedInfo = extendedInfo; CustomInit(); }
/// <summary> /// Initializes a new instance of the AzureIaaSVMJob class. /// </summary> /// <param name="entityFriendlyName">Friendly name of the entity on /// which the current job is executing.</param> /// <param name="backupManagementType">Backup management type to /// execute the current job. Possible values include: 'Invalid', /// 'AzureIaasVM', 'MAB', 'DPM', 'AzureBackupServer', 'AzureSql', /// 'AzureStorage', 'AzureWorkload', 'DefaultBackup'</param> /// <param name="operation">The operation name.</param> /// <param name="status">Job status.</param> /// <param name="startTime">The start time.</param> /// <param name="endTime">The end time.</param> /// <param name="activityId">ActivityId of job.</param> /// <param name="duration">Time elapsed during the execution of this /// job.</param> /// <param name="actionsInfo">Gets or sets the state/actions applicable /// on this job like cancel/retry.</param> /// <param name="errorDetails">Error details on execution of this /// job.</param> /// <param name="virtualMachineVersion">Specifies whether the backup /// item is a Classic or an Azure Resource Manager VM.</param> /// <param name="extendedInfo">Additional information for this /// job.</param> /// <param name="containerName">Container name of the entity on which /// the current job is executing.</param> /// <param name="isUserTriggered">Indicated that whether the job is /// adhoc(true) or scheduled(false)</param> public AzureIaaSVMJob(string entityFriendlyName = default(string), string backupManagementType = default(string), string operation = default(string), string status = default(string), System.DateTime?startTime = default(System.DateTime?), System.DateTime?endTime = default(System.DateTime?), string activityId = default(string), System.TimeSpan?duration = default(System.TimeSpan?), IList <JobSupportedAction?> actionsInfo = default(IList <JobSupportedAction?>), IList <AzureIaaSVMErrorInfo> errorDetails = default(IList <AzureIaaSVMErrorInfo>), string virtualMachineVersion = default(string), AzureIaaSVMJobExtendedInfo extendedInfo = default(AzureIaaSVMJobExtendedInfo), string containerName = default(string), bool?isUserTriggered = default(bool?)) : base(entityFriendlyName, backupManagementType, operation, status, startTime, endTime, activityId) { Duration = duration; ActionsInfo = actionsInfo; ErrorDetails = errorDetails; VirtualMachineVersion = virtualMachineVersion; ExtendedInfo = extendedInfo; ContainerName = containerName; IsUserTriggered = isUserTriggered; CustomInit(); }
/// <summary> /// Put complex types with duration properties /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='field'> /// </param> public static void PutDuration(this IPrimitive operations, System.TimeSpan?field = default(System.TimeSpan?)) { operations.PutDurationAsync(field).GetAwaiter().GetResult(); }
/// <summary> /// Initializes a new instance of the AzurePowerShellScript class. /// </summary> /// <param name="identity">Managed identity to be used for this /// deployment script. Currently, only user-assigned MSI is /// supported.</param> /// <param name="location">The location of the ACI and the storage /// account for the deployment script.</param> /// <param name="retentionInterval">Interval for which the service /// retains the script resource after it reaches a terminal state. /// Resource will be deleted when this duration expires. Duration is /// based on ISO 8601 pattern (for example P7D means one week).</param> /// <param name="azPowerShellVersion">Azure PowerShell module version /// to be used.</param> /// <param name="id">String Id used to locate any resource on /// Azure.</param> /// <param name="name">Name of this resource.</param> /// <param name="type">Type of this resource.</param> /// <param name="tags">Resource tags.</param> /// <param name="cleanupPreference">The clean up preference when the /// script execution gets in a terminal state. Default setting is /// 'Always'. Possible values include: 'Always', 'OnSuccess', /// 'OnExpiration'</param> /// <param name="provisioningState">State of the script execution. This /// only appears in the response. Possible values include: 'Creating', /// 'ProvisioningResources', 'Running', 'Succeeded', 'Failed', /// 'Canceled', 'Expiring'</param> /// <param name="status">Contains the results of script /// execution.</param> /// <param name="outputs">List of script outputs.</param> /// <param name="primaryScriptUri">Uri for the script. This is the /// entry point for the external script.</param> /// <param name="supportingScriptUris">Supporting files for the /// external script.</param> /// <param name="scriptContent">Script body.</param> /// <param name="arguments">Command line arguments to pass to the /// script. Arguments are separated by spaces. ex: -Name blue* /// -Location 'West US 2' </param> /// <param name="environmentVariables">The environment variables to /// pass over to the script.</param> /// <param name="forceUpdateTag">Gets or sets how the deployment script /// should be forced to execute even if the script resource has not /// changed. Can be current time stamp or a GUID.</param> /// <param name="timeout">Maximum allowed script execution time /// specified in ISO 8601 format. Default value is PT1H</param> public AzurePowerShellScript(ManagedServiceIdentity identity, string location, System.TimeSpan retentionInterval, string azPowerShellVersion, string id = default(string), string name = default(string), string type = default(string), IDictionary <string, string> tags = default(IDictionary <string, string>), string cleanupPreference = default(string), string provisioningState = default(string), ScriptStatus status = default(ScriptStatus), IDictionary <string, object> outputs = default(IDictionary <string, object>), string primaryScriptUri = default(string), IList <string> supportingScriptUris = default(IList <string>), string scriptContent = default(string), string arguments = default(string), IList <EnvironmentVariable> environmentVariables = default(IList <EnvironmentVariable>), string forceUpdateTag = default(string), System.TimeSpan?timeout = default(System.TimeSpan?)) : base(identity, location, id, name, type, tags) { CleanupPreference = cleanupPreference; ProvisioningState = provisioningState; Status = status; Outputs = outputs; PrimaryScriptUri = primaryScriptUri; SupportingScriptUris = supportingScriptUris; ScriptContent = scriptContent; Arguments = arguments; EnvironmentVariables = environmentVariables; ForceUpdateTag = forceUpdateTag; RetentionInterval = retentionInterval; Timeout = timeout; AzPowerShellVersion = azPowerShellVersion; CustomInit(); }
/// <summary> /// Put complex types with duration properties /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='field'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task PutDurationAsync(this IPrimitive operations, System.TimeSpan?field = default(System.TimeSpan?), CancellationToken cancellationToken = default(CancellationToken)) { (await operations.PutDurationWithHttpMessagesAsync(field, null, cancellationToken).ConfigureAwait(false)).Dispose(); }
/// <summary> /// Initializes a new instance of the VideoOverlay class. /// </summary> /// <param name="inputLabel">The label of the job input which is to be /// used as an overlay. The Input must specify exactly one file. You /// can specify an image file in JPG, PNG, GIF or BMP format, or an /// audio file (such as a WAV, MP3, WMA or M4A file), or a video file. /// See https://aka.ms/mesformats for the complete list of supported /// audio and video file formats.</param> /// <param name="start">The start position, with reference to the input /// video, at which the overlay starts. The value should be in ISO 8601 /// format. For example, PT05S to start the overlay at 5 seconds into /// the input video. If not specified the overlay starts from the /// beginning of the input video.</param> /// <param name="end">The end position, with reference to the input /// video, at which the overlay ends. The value should be in ISO 8601 /// format. For example, PT30S to end the overlay at 30 seconds into /// the input video. If not specified or the value is greater than the /// input video duration, the overlay will be applied until the end of /// the input video if the overlay media duration is greater than the /// input video duration, else the overlay will last as long as the /// overlay media duration.</param> /// <param name="fadeInDuration">The duration over which the overlay /// fades in onto the input video. The value should be in ISO 8601 /// duration format. If not specified the default behavior is to have /// no fade in (same as PT0S).</param> /// <param name="fadeOutDuration">The duration over which the overlay /// fades out of the input video. The value should be in ISO 8601 /// duration format. If not specified the default behavior is to have /// no fade out (same as PT0S).</param> /// <param name="audioGainLevel">The gain level of audio in the /// overlay. The value should be in the range [0, 1.0]. The default is /// 1.0.</param> /// <param name="position">The location in the input video where the /// overlay is applied.</param> /// <param name="opacity">The opacity of the overlay. This is a value /// in the range [0 - 1.0]. Default is 1.0 which mean the overlay is /// opaque.</param> /// <param name="cropRectangle">An optional rectangular window used to /// crop the overlay image or video.</param> public VideoOverlay(string inputLabel, System.TimeSpan?start = default(System.TimeSpan?), System.TimeSpan?end = default(System.TimeSpan?), System.TimeSpan?fadeInDuration = default(System.TimeSpan?), System.TimeSpan?fadeOutDuration = default(System.TimeSpan?), double?audioGainLevel = default(double?), Rectangle position = default(Rectangle), double?opacity = default(double?), Rectangle cropRectangle = default(Rectangle)) : base(inputLabel, start, end, fadeInDuration, fadeOutDuration, audioGainLevel) { Position = position; Opacity = opacity; CropRectangle = cropRectangle; CustomInit(); }
/// <summary> /// Initializes a new instance of the ResourceProviderEndpoint class. /// </summary> public ResourceProviderEndpoint(bool?enabled = default(bool?), IList <string> apiVersions = default(IList <string>), string endpointUri = default(string), IList <string> locations = default(IList <string>), IList <string> requiredFeatures = default(IList <string>), ResourceProviderEndpointFeaturesRule featuresRule = default(ResourceProviderEndpointFeaturesRule), System.TimeSpan?timeout = default(System.TimeSpan?)) { Enabled = enabled; ApiVersions = apiVersions; EndpointUri = endpointUri; Locations = locations; RequiredFeatures = requiredFeatures; FeaturesRule = featuresRule; Timeout = timeout; CustomInit(); }
/// <summary> /// Initializes a new instance of the DpmJob class. /// </summary> /// <param name="entityFriendlyName">Friendly name of the entity on /// which the current job is executing.</param> /// <param name="backupManagementType">Backup management type to /// execute the current job. Possible values include: 'Invalid', /// 'AzureIaasVM', 'MAB', 'DPM', 'AzureBackupServer', 'AzureSql', /// 'AzureStorage', 'AzureWorkload', 'DefaultBackup'</param> /// <param name="operation">The operation name.</param> /// <param name="status">Job status.</param> /// <param name="startTime">The start time.</param> /// <param name="endTime">The end time.</param> /// <param name="activityId">ActivityId of job.</param> /// <param name="duration">Time elapsed for job.</param> /// <param name="dpmServerName">DPM server name managing the backup /// item or backup job.</param> /// <param name="containerName">Name of cluster/server protecting /// current backup item, if any.</param> /// <param name="containerType">Type of container.</param> /// <param name="workloadType">Type of backup item.</param> /// <param name="actionsInfo">The state/actions applicable on this job /// like cancel/retry.</param> /// <param name="errorDetails">The errors.</param> /// <param name="extendedInfo">Additional information for this /// job.</param> public DpmJob(string entityFriendlyName = default(string), string backupManagementType = default(string), string operation = default(string), string status = default(string), System.DateTime?startTime = default(System.DateTime?), System.DateTime?endTime = default(System.DateTime?), string activityId = default(string), System.TimeSpan?duration = default(System.TimeSpan?), string dpmServerName = default(string), string containerName = default(string), string containerType = default(string), string workloadType = default(string), IList <JobSupportedAction?> actionsInfo = default(IList <JobSupportedAction?>), IList <DpmErrorInfo> errorDetails = default(IList <DpmErrorInfo>), DpmJobExtendedInfo extendedInfo = default(DpmJobExtendedInfo)) : base(entityFriendlyName, backupManagementType, operation, status, startTime, endTime, activityId) { Duration = duration; DpmServerName = dpmServerName; ContainerName = containerName; ContainerType = containerType; WorkloadType = workloadType; ActionsInfo = actionsInfo; ErrorDetails = errorDetails; ExtendedInfo = extendedInfo; CustomInit(); }
/// <summary> /// Initializes a new instance of the ResizeOperationStatus class. /// </summary> /// <param name="targetDedicatedNodes">The desired number of dedicated /// compute nodes in the pool.</param> /// <param name="targetLowPriorityNodes">The desired number of /// low-priority compute nodes in the pool.</param> /// <param name="resizeTimeout">The timeout for allocation of compute /// nodes to the pool or removal of compute nodes from the /// pool.</param> /// <param name="nodeDeallocationOption">Determines what to do with a /// node and its running task(s) if the pool size is /// decreasing.</param> /// <param name="startTime">The time when this resize operation was /// started.</param> /// <param name="errors">Details of any errors encountered while /// performing the last resize on the pool.</param> public ResizeOperationStatus(int?targetDedicatedNodes = default(int?), int?targetLowPriorityNodes = default(int?), System.TimeSpan?resizeTimeout = default(System.TimeSpan?), ComputeNodeDeallocationOption?nodeDeallocationOption = default(ComputeNodeDeallocationOption?), System.DateTime?startTime = default(System.DateTime?), IList <ResizeError> errors = default(IList <ResizeError>)) { TargetDedicatedNodes = targetDedicatedNodes; TargetLowPriorityNodes = targetLowPriorityNodes; ResizeTimeout = resizeTimeout; NodeDeallocationOption = nodeDeallocationOption; StartTime = startTime; Errors = errors; CustomInit(); }
public static System.Int32? Checksum(System.TimeSpan? arg1, System.TimeSpan? arg2, System.TimeSpan? arg3) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionDirectCall); }
/// <summary> /// Initializes a new instance of the MessagingEndpointProperties /// class. /// </summary> /// <param name="lockDurationAsIso8601">The lock duration. See: /// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-file-upload.</param> /// <param name="ttlAsIso8601">The period of time for which a message /// is available to consume before it is expired by the IoT hub. See: /// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-file-upload.</param> /// <param name="maxDeliveryCount">The number of times the IoT hub /// attempts to deliver a message. See: /// https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-file-upload.</param> public MessagingEndpointProperties(System.TimeSpan?lockDurationAsIso8601 = default(System.TimeSpan?), System.TimeSpan?ttlAsIso8601 = default(System.TimeSpan?), int?maxDeliveryCount = default(int?)) { LockDurationAsIso8601 = lockDurationAsIso8601; TtlAsIso8601 = ttlAsIso8601; MaxDeliveryCount = maxDeliveryCount; CustomInit(); }
public static System.Int32? DateDiff(System.String datePartArg, System.TimeSpan? startDate, System.String endDate) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.ELinq_EdmFunctionDirectCall); }
/// <summary> /// Initializes a new instance of the PoolSpecification class. /// </summary> /// <param name="vmSize">The size of the virtual machines in the Pool. /// All virtual machines in a Pool are the same size.</param> /// <param name="displayName">The display name for the Pool.</param> /// <param name="cloudServiceConfiguration">The cloud service /// configuration for the Pool.</param> /// <param name="virtualMachineConfiguration">The virtual machine /// configuration for the Pool.</param> /// <param name="taskSlotsPerNode">The number of task slots that can be /// used to run concurrent tasks on a single compute node in the /// pool.</param> /// <param name="taskSchedulingPolicy">How Tasks are distributed across /// Compute Nodes in a Pool.</param> /// <param name="resizeTimeout">The timeout for allocation of Compute /// Nodes to the Pool.</param> /// <param name="targetDedicatedNodes">The desired number of dedicated /// Compute Nodes in the Pool.</param> /// <param name="targetLowPriorityNodes">The desired number of /// low-priority Compute Nodes in the Pool.</param> /// <param name="enableAutoScale">Whether the Pool size should /// automatically adjust over time.</param> /// <param name="autoScaleFormula">The formula for the desired number /// of Compute Nodes in the Pool.</param> /// <param name="autoScaleEvaluationInterval">The time interval at /// which to automatically adjust the Pool size according to the /// autoscale formula.</param> /// <param name="enableInterNodeCommunication">Whether the Pool permits /// direct communication between Compute Nodes.</param> /// <param name="networkConfiguration">The network configuration for /// the Pool.</param> /// <param name="startTask">A Task to run on each Compute Node as it /// joins the Pool. The Task runs when the Compute Node is added to the /// Pool or when the Compute Node is restarted.</param> /// <param name="certificateReferences">A list of Certificates to be /// installed on each Compute Node in the Pool.</param> /// <param name="applicationPackageReferences">The list of Packages to /// be installed on each Compute Node in the Pool.</param> /// <param name="applicationLicenses">The list of application licenses /// the Batch service will make available on each Compute Node in the /// Pool.</param> /// <param name="userAccounts">The list of user Accounts to be created /// on each Compute Node in the Pool.</param> /// <param name="metadata">A list of name-value pairs associated with /// the Pool as metadata.</param> /// <param name="mountConfiguration">A list of file systems to mount on /// each node in the pool.</param> public PoolSpecification(string vmSize, string displayName = default(string), CloudServiceConfiguration cloudServiceConfiguration = default(CloudServiceConfiguration), VirtualMachineConfiguration virtualMachineConfiguration = default(VirtualMachineConfiguration), int?taskSlotsPerNode = default(int?), TaskSchedulingPolicy taskSchedulingPolicy = default(TaskSchedulingPolicy), System.TimeSpan?resizeTimeout = default(System.TimeSpan?), int?targetDedicatedNodes = default(int?), int?targetLowPriorityNodes = default(int?), bool?enableAutoScale = default(bool?), string autoScaleFormula = default(string), System.TimeSpan?autoScaleEvaluationInterval = default(System.TimeSpan?), bool?enableInterNodeCommunication = default(bool?), NetworkConfiguration networkConfiguration = default(NetworkConfiguration), StartTask startTask = default(StartTask), IList <CertificateReference> certificateReferences = default(IList <CertificateReference>), IList <ApplicationPackageReference> applicationPackageReferences = default(IList <ApplicationPackageReference>), IList <string> applicationLicenses = default(IList <string>), IList <UserAccount> userAccounts = default(IList <UserAccount>), IList <MetadataItem> metadata = default(IList <MetadataItem>), IList <MountConfiguration> mountConfiguration = default(IList <MountConfiguration>)) { DisplayName = displayName; VmSize = vmSize; CloudServiceConfiguration = cloudServiceConfiguration; VirtualMachineConfiguration = virtualMachineConfiguration; TaskSlotsPerNode = taskSlotsPerNode; TaskSchedulingPolicy = taskSchedulingPolicy; ResizeTimeout = resizeTimeout; TargetDedicatedNodes = targetDedicatedNodes; TargetLowPriorityNodes = targetLowPriorityNodes; EnableAutoScale = enableAutoScale; AutoScaleFormula = autoScaleFormula; AutoScaleEvaluationInterval = autoScaleEvaluationInterval; EnableInterNodeCommunication = enableInterNodeCommunication; NetworkConfiguration = networkConfiguration; StartTask = startTask; CertificateReferences = certificateReferences; ApplicationPackageReferences = applicationPackageReferences; ApplicationLicenses = applicationLicenses; UserAccounts = userAccounts; Metadata = metadata; MountConfiguration = mountConfiguration; CustomInit(); }