public void CtorMessageAndInner() { Exception inner = new Exception ("inner"); var ex = new DataServiceException ("message", inner); Assert.AreEqual ("message", ex.Message); Assert.AreEqual (inner, ex.InnerException); }
public void CtorStatusAndErrorMessageLanguageException() { Exception inner = new Exception ("inner"); var ex = new DataServiceException (404, "error", "message", "language", inner); Assert.AreEqual ("message", ex.Message); Assert.AreEqual (404, ex.StatusCode); Assert.AreEqual ("language", ex.MessageLanguage); Assert.AreEqual (inner, ex.InnerException); }
/// <summary>Gets the value for the specified item in the request query string.</summary> /// <param name="item">Item to return.</param> /// <returns> /// The value for the specified item in the request query string; /// null if <paramref name="item"/> is not found. /// </returns> string IDataServiceHost.GetQueryStringItem(string item) { Debug.Assert(item != null, "item != null"); Debug.Assert(item.Trim() == item, "item.Trim() == item - otherwise, there are leading/trailing spaces in the name"); System.Collections.Specialized.NameValueCollection collection = this.operationContext.IncomingRequest.UriTemplateMatch.QueryParameters; string[] values = collection.GetValues(item); if (values == null || values.Length == 0) { // Do a scan of arguments ignoring whitespace (SQLBUDT #555944). string keyFound = null; foreach (string key in collection.Keys) { if (key != null && StringComparer.OrdinalIgnoreCase.Equals(key.Trim(), item)) { if (keyFound != null) { throw DataServiceException.CreateBadRequestError(Strings.HttpContextServiceHost_AmbiguousItemName(item, keyFound, key)); } keyFound = key; values = collection.GetValues(key); } } if (values == null || values.Length == 0) { return(null); } } Debug.Assert(values != null && values.Length > 0, "values != null && values.Length > 0 - otherwise we should have returned already"); if (values.Length == 1) { return(values[0]); } else { throw DataServiceException.CreateSyntaxError(); } }
private static ExpandedProjectionNode ApplyProjectionForProperty(ExpandedProjectionNode parentNode, string propertyName, ResourceProperty property, ResourceType targetResourceType, bool lastPathSegment) { if (property != null) { switch (property.TypeKind) { case ResourceTypeKind.ComplexType: if (!lastPathSegment) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_ComplexPropertyAsInnerSelectSegment(targetResourceType.FullName, propertyName)); } break; case ResourceTypeKind.Primitive: if (!lastPathSegment) { if (property.IsOfKind(ResourcePropertyKind.Stream)) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_NamedStreamMustBeLastSegmentInSelect(propertyName)); } throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_PrimitivePropertyUsedAsNavigationProperty(targetResourceType.FullName, propertyName)); } break; case ResourceTypeKind.Collection: if (!lastPathSegment) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_CollectionPropertyAsInnerSelectSegment(targetResourceType.FullName, propertyName)); } break; } } ExpandedProjectionNode node = parentNode.AddProjectionNode(propertyName, property, targetResourceType, lastPathSegment); if (lastPathSegment && (node != null)) { node.ProjectionFound = true; node.MarkSubtreeAsProjected(); } return(node); }
private Version GetMinDataServiceVersion(Version maxProtocolVersion) { if (this.requestMinVersion == null) { this.TryGetMinDataServiceVersionFromWrappedHost(out this.requestMinVersion); if ((maxProtocolVersion < RequestDescription.Version3Dot0) || (this.requestMinVersion == null)) { this.requestMinVersion = RequestDescription.DataServiceDefaultResponseVersion; } else { if (this.requestMinVersion > maxProtocolVersion) { throw DataServiceException.CreateBadRequestError(Strings.DataService_MinDSVGreaterThanMPV(this.requestMinVersion.ToString(2), maxProtocolVersion.ToString(2))); } if (!RequestDescription.IsKnownRequestVersion(this.requestMinVersion)) { throw DataServiceException.CreateBadRequestError(Strings.DataService_InvalidMinDSV(this.requestMinVersion.ToString(2), KnownDataServiceVersionsToString(GetMaxRequestVersionAllowed(maxProtocolVersion)))); } } } return(this.requestMinVersion); }
private void CheckExpandPaths() { if (this.expandPathsAsText.Count > 0) { if (this.queryExpression == null) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_QueryExpandOptionNotApplicable); } if (this.description.TargetResourceType.ResourceTypeKind == ResourceTypeKind.Collection) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_QueryExpandOptionNotApplicable); } } this.expandPaths = new List <ExpandSegmentCollection>(this.expandPathsAsText.Count); for (int i = this.expandPathsAsText.Count - 1; i >= 0; i--) { ExpandSegmentCollection item = this.CheckSingleExpandPath(this.expandPathsAsText[i]); if (item == null) { this.expandPathsAsText.RemoveAt(i); } else { this.expandPaths.Add(item); ExpandedProjectionNode rootProjectionNode = this.GetRootProjectionNode(); for (int j = 0; j < item.Count; j++) { ExpandSegment segment = item[j]; ExpandedProjectionNode node2 = rootProjectionNode.AddExpandedNode(segment); this.GetRootProjectionNode().ExpansionOnDerivedTypesSpecified |= rootProjectionNode.HasExpandedPropertyOnDerivedType; rootProjectionNode = node2; } this.GetRootProjectionNode().ExpansionsSpecified = true; } } }
private void SerializeXmlError(XmlWriter writer) { string str; string str2; string str3; writer.WriteStartElement("error", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); DataServiceException exception = ExtractErrorValues(this.exceptionArgs.Exception, out str, out str2, out str3); writer.WriteStartElement("code", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); writer.WriteString(str); writer.WriteEndElement(); writer.WriteStartElement("message", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"); writer.WriteAttributeString("xml", "lang", null, str3); writer.WriteString(str2); writer.WriteEndElement(); if (this.exceptionArgs.UseVerboseErrors) { Exception exception2 = (exception == null) ? this.exceptionArgs.Exception : exception.InnerException; SerializeXmlException(writer, exception2); } writer.WriteEndElement(); writer.Flush(); }
/// <summary>create exception when CUD operation is specified in batch</summary> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamOnlyGETOperationsCanBeSpecifiedInBatch() { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_OnlyGETOperationsCanBeSpecifiedInBatch))); }
/// <summary>create exception when content length is not valid</summary> /// <param name="contentLength">content length as specified in the request.</param> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamInvalidContentLengthSpecified(string contentLength) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidContentLengthSpecified(contentLength)))); }
/// <summary>create exception when http method name is not valid</summary> /// <param name="methodName">name of the http method as specified in the request.</param> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamInvalidHttpMethodName(string methodName) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidHttpMethodName(methodName)))); }
/// <summary> /// Parse the given etag value in the If-Match request header. /// </summary> /// <param name="etagProperties">List of etag properties for the type whose etag values we are parsing.</param> /// <param name="ifMatchHeaderValue">value of the If-Match header as specified in the request.</param> /// <returns>returns the etag value as a list containing the property name and its corresponding value. If the If-Match header value is '*', then returns an empty collection.</returns> private static IEnumerable <KeyValuePair <string, object> > ParseETagValue(IList <ResourceProperty> etagProperties, string ifMatchHeaderValue) { Debug.Assert(etagProperties != null && etagProperties.Count != 0, "There must be atleast one etag property specified"); Debug.Assert(!String.IsNullOrEmpty(ifMatchHeaderValue), "IfMatch header cannot be null"); if (ifMatchHeaderValue == XmlConstants.HttpAnyETag) { // if the value is '*', then we return an empty IEnumerable. return(new KeyValuePair <string, object> [0]); } Debug.Assert(ifMatchHeaderValue.StartsWith(XmlConstants.HttpWeakETagPrefix, StringComparison.Ordinal), "If-Match header must be properly formatted - this check is done in DataService.CheckETagValues method"); Debug.Assert(ifMatchHeaderValue.Length >= XmlConstants.HttpWeakETagPrefix.Length + 1, "If-Match header must be properly formatted - this check is done in DataService.CheckETagValues method"); // Just get the etag value - we need to ignore the 'W/"' and the last '"' character from the etag string strippedETag = ifMatchHeaderValue.Substring(XmlConstants.HttpWeakETagPrefix.Length, ifMatchHeaderValue.Length - XmlConstants.HttpWeakETagPrefix.Length - 1); KeyInstance keyInstance = null; bool success; Exception innerException = null; // In V1, when we didn't have IConcurrencyProvider interface, we always used to compute the // latest etag from the entity instance we got from IUpdatable.GetResource and then comparing // it with the If-Match request header. Hence all invalid cases always used to throw // DataServiceException with 412, since the etags didn't match. // In V1.5, we have added the support for IConcurrencyProvider, which means we need to parse // the etag values and parse it to the provider, if it has implement this interface. To avoid // breaking changes, we need to catch all parsing errors and report them as 412 instead of 400 // to avoid it from becoming a breaking change. try { success = KeyInstance.TryParseNullableTokens(Uri.UnescapeDataString(strippedETag), out keyInstance); } catch (DataServiceException e) { success = false; innerException = e; } if (!success) { // We could have throwed BadRequest here since the etag value is not properly formattted. But since // we used to do throw 412 in V1, keeping it that way to avoid breaking change. throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch, innerException); } if (keyInstance.PositionalValues.Count != etagProperties.Count) { // We could have throwed BadRequest here since the etag value is not properly formattted. But since // we used to do throw 412 in V1, keeping it that way to avoid breaking change. throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch); } KeyValuePair <string, object>[] etagPropertyInfo = new KeyValuePair <string, object> [etagProperties.Count]; for (int i = 0; i < etagPropertyInfo.Length; i++) { ResourceProperty etagProperty = etagProperties[i]; object propertyValue = null; string value = (string)keyInstance.PositionalValues[i]; if (value != XmlConstants.NullLiteralInETag) { // The reason we need to catch the Overflow Exception here is because of the Bug #679728. // In V1, when we didn't have IConcurrencyProvider interface, we always used to compute the // latest etag from the entity instance we got from IUpdatable.GetResource and then comparing // it with the If-Match request header. Hence all invalid cases always used to throw // DataServiceException with 412, since the etags didn't match. // In V1.5, we have added the support for IConcurrencyProvider, which means we need to parse // the etag values and parse it to the provider, if it has implement this interface. To avoid // breaking changes, we need to catch all parsing errors and report them as 412 instead of 400 // to avoid it from becoming a breaking change. try { success = System.Data.Services.Parsing.WebConvert.TryKeyStringToPrimitive(value, etagProperty.Type, out propertyValue); } catch (OverflowException e) { success = false; innerException = e; } if (!success) { // We could have throwed BadRequest here since the etag value is not properly formattted. But since // we used to do throw 412 in V1, keeping it that way to avoid breaking change. throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch, innerException); } } etagPropertyInfo[i] = new KeyValuePair <string, object>(etagProperties[i].Name, propertyValue); } return(etagPropertyInfo); }
/// <summary>internal error where the first request header is not of the form: 'MethodName' 'Url' 'Version'</summary> /// <param name="header">actual header value specified in the payload.</param> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamInvalidMethodHeaderSpecified(string header) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidMethodHeaderSpecified(header)))); }
/// <summary>create exception when more data is specified after end of batch delimiter.</summary> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamMoreDataAfterEndOfBatch() { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_MoreDataAfterEndOfBatch))); }
internal static Exception CheckPowershellForException(string cmdletName, CommandType commandType, System.Management.Automation.PowerShell powerShell) { Exception streamException = PSCommand.CheckInvocationStateInfoForException(powerShell.InvocationStateInfo); if (streamException == null) { streamException = PSCommand.GetStreamException(cmdletName, powerShell.Streams); } string commandText = powerShell.Commands.Commands[0].CommandText; if (streamException != null) { if (!(streamException.GetType() == typeof(ItemNotFoundException)) || commandType != CommandType.Read && commandType != CommandType.Delete && commandType != CommandType.Update) { streamException = new CommandInvocationFailedException(commandText, streamException); } else { if (commandType == CommandType.Read || commandType == CommandType.Delete) { string[] str = new string[7]; str[0] = "Cmdlet "; str[1] = cmdletName; str[2] = " generated ItemNotFoundException exception. Command string was "; str[3] = commandText; str[4] = ". But this is a "; str[5] = commandType.ToString(); str[6] = "operation, so suppressing that message"; TraceHelper.Current.DebugMessage(string.Concat(str)); streamException = null; } else { string[] strArrays = new string[5]; strArrays[0] = "Cmdlet "; strArrays[1] = cmdletName; strArrays[2] = " generated ItemNotFoundException exception. Command string was "; strArrays[3] = commandText; strArrays[4] = ". But the operation is Update, so throwing DataServiceException with 404"; TraceHelper.Current.DebugMessage(string.Concat(strArrays)); streamException = new DataServiceException(0x194, null, Resources.ResourceNotFoundException, null, streamException); } } } return streamException; }
/// <summary>Creates a new "Bad Request" exception for recursion limit exceeded.</summary> /// <param name="recursionLimit">Recursion limit that was reaced.</param> /// <returns>A new exception to indicate that the request is rejected.</returns> internal static DataServiceException CreateDeepRecursion(int recursionLimit) { return(DataServiceException.CreateBadRequestError(Strings.BadRequest_DeepRecursion(recursionLimit))); }
/// <summary>internal error when content type header is missing</summary> /// <param name="headerName">name of the missing header</param> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamMissingContentTypeHeader(string headerName) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_MissingContentTypeHeader(headerName)))); }
private ExpandSegmentCollection CheckSingleExpandPath(List <string> path) { ResourceType targetResourceType = this.description.TargetResourceType; ResourceSetWrapper targetContainer = this.description.LastSegmentInfo.TargetContainer; ExpandSegmentCollection segments = new ExpandSegmentCollection(path.Count); bool flag = false; bool previousSegmentIsTypeSegment = false; for (int i = 0; i < path.Count; i++) { string propertyName = path[i]; ResourcePropertyKind stream = ResourcePropertyKind.Stream; ResourceProperty navigationProperty = targetResourceType.TryResolvePropertyName(propertyName, stream); if (navigationProperty == null) { ResourceType type2 = WebUtil.ResolveTypeIdentifier(this.service.Provider, propertyName, targetResourceType, previousSegmentIsTypeSegment); if (type2 == null) { if (targetResourceType.IsOpenType) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(propertyName)); } throw DataServiceException.CreateSyntaxError(System.Data.Services.Strings.RequestUriProcessor_PropertyNotFound(targetResourceType.FullName, propertyName)); } this.description.VerifyProtocolVersion(RequestDescription.Version3Dot0, this.service); targetResourceType = type2; previousSegmentIsTypeSegment = true; } else { previousSegmentIsTypeSegment = false; if (navigationProperty.TypeKind == ResourceTypeKind.EntityType) { targetContainer = this.service.Provider.GetContainer(targetContainer, targetResourceType, navigationProperty); if (targetContainer == null) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.BadRequest_InvalidPropertyNameSpecified(navigationProperty.Name, targetResourceType.FullName)); } bool singleResult = navigationProperty.Kind == ResourcePropertyKind.ResourceReference; DataServiceConfiguration.CheckResourceRightsForRead(targetContainer, singleResult); Expression filter = DataServiceConfiguration.ComposeQueryInterceptors(this.service, targetContainer); if (((targetContainer.PageSize != 0) && !singleResult) && !this.IsCustomPaged) { OrderingInfo orderingInfo = new OrderingInfo(true); ParameterExpression expression = Expression.Parameter(targetContainer.ResourceType.InstanceType, "p"); foreach (ResourceProperty property2 in targetContainer.GetKeyPropertiesForOrderBy()) { Expression expression3; if (property2.CanReflectOnInstanceTypeProperty) { expression3 = Expression.Property(expression, targetContainer.ResourceType.GetPropertyInfo(property2)); } else { expression3 = Expression.Convert(Expression.Call(null, DataServiceProviderMethods.GetValueMethodInfo, expression, Expression.Constant(property2)), property2.Type); } orderingInfo.Add(new OrderingExpression(Expression.Lambda(expression3, new ParameterExpression[] { expression }), true)); } segments.Add(new ExpandSegment(navigationProperty.Name, filter, targetContainer.PageSize, targetContainer, targetResourceType, navigationProperty, orderingInfo)); this.description.VerifyProtocolVersion(RequestDescription.Version2Dot0, this.service); this.description.VerifyAndRaiseResponseVersion(RequestDescription.Version2Dot0, this.service); } else { if (!singleResult && this.IsCustomPaged) { this.CheckAndApplyCustomPaging(null); } segments.Add(new ExpandSegment(navigationProperty.Name, filter, this.service.Configuration.MaxResultsPerCollection, targetContainer, targetResourceType, navigationProperty, null)); } this.description.UpdateAndCheckEpmFeatureVersion(targetContainer, this.service); this.description.UpdateVersions(this.service.OperationContext.Host.RequestAccept, targetContainer, this.service); flag = false; targetResourceType = navigationProperty.ResourceType; } else { flag = true; } } } if (previousSegmentIsTypeSegment) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_QueryParametersPathCannotEndInTypeIdentifier("$expand", targetResourceType.FullName)); } if (!flag) { return(segments); } return(null); }
/// <summary>internal error number of headers at the start of changeset is not correct</summary> /// <param name="header1">First valid header name</param> /// <param name="header2">Second valid header name</param> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamInvalidNumberOfHeadersAtChangeSetStart(string header1, string header2) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidNumberOfHeadersAtChangeSetStart(header1, header2)))); }
/// <summary>internal error Content-Transfer-Encoding is not specified or its value is not 'binary'</summary> /// <param name="headerName">name of the header</param> /// <param name="headerValue">expected value of the header</param> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamMissingOrInvalidContentEncodingHeader(string headerName, string headerValue) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_MissingOrInvalidContentEncodingHeader(headerName, headerValue)))); }
/// <summary>internal error when http version in batching request is not valid</summary> /// <param name="actualVersion">actual version as specified in the payload.</param> /// <param name="expectedVersion">expected version value.</param> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamInvalidHttpVersionSpecified(string actualVersion, string expectedVersion) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidHttpVersionSpecified(actualVersion, expectedVersion)))); }
internal static DataServiceException CreateMethodNotAllowed(string message, string allow) { DataServiceException exception = new DataServiceException(0x195, message); exception.state.ResponseAllowHeader = allow; return exception; }
/// <summary>Creates a new exception to indicate a syntax error.</summary> /// <param name="message">Plain text error message for this exception.</param> /// <returns>A new exception to indicate a syntax error.</returns> internal static DataServiceException CreateSyntaxError(string message) { return(DataServiceException.CreateBadRequestError(message)); }
/// <summary>internal error when content type header value is invalid.</summary> /// <param name="headerName">name of the header whose value is not correct.</param> /// <param name="headerValue">actual value as specified in the payload</param> /// <param name="mime1">expected value 1</param> /// <param name="mime2">expected value 2</param> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamInvalidContentTypeSpecified(string headerName, string headerValue, string mime1, string mime2) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidContentTypeSpecified(headerName, headerValue, mime1, mime2)))); }
/// <summary>internal error where batch stream does do look ahead when read request is smaller than boundary delimiter</summary> /// <returns>exception to throw</returns> internal static InvalidOperationException BatchStreamInternalBufferRequestTooSmall() { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InternalBufferRequestTooSmall))); }
private void ApplyProjectionsToExpandTree(List <List <string> > selectPathsAsText) { for (int i = selectPathsAsText.Count - 1; i >= 0; i--) { List <string> list = selectPathsAsText[i]; ExpandedProjectionNode rootProjectionNode = this.GetRootProjectionNode(); ResourceType type = null; for (int j = 0; j < list.Count; j++) { bool flag2; string containerQualifiedName = list[j]; bool lastPathSegment = j == (list.Count - 1); rootProjectionNode.ProjectionFound = true; if (containerQualifiedName == "*") { rootProjectionNode.ProjectAllImmediateProperties = true; break; } if (this.service.Provider.GetNameFromContainerQualifiedName(containerQualifiedName, out flag2) == "*") { rootProjectionNode.ProjectAllImmediateOperations = true; break; } ResourceType previousSegmentResourceType = type ?? rootProjectionNode.ResourceType; ResourceProperty property = previousSegmentResourceType.TryResolvePropertyName(containerQualifiedName); if (property == null) { type = WebUtil.ResolveTypeIdentifier(this.service.Provider, containerQualifiedName, previousSegmentResourceType, type != null); if (type != null) { this.description.VerifyProtocolVersion(RequestDescription.Version3Dot0, this.service); continue; } Func <OperationWrapper, bool> predicate = null; string serviceActionName = this.service.Provider.GetNameFromContainerQualifiedName(containerQualifiedName, out flag2); OperationWrapper operation = null; if (!previousSegmentResourceType.IsOpenType || flag2) { if (predicate == null) { predicate = o => o.Name == serviceActionName; } operation = this.service.ActionProvider.GetServiceActionsByBindingParameterType(this.service.OperationContext, previousSegmentResourceType).SingleOrDefault <OperationWrapper>(predicate); } if (operation != null) { rootProjectionNode.AddOperation(operation); if (!lastPathSegment) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_ServiceActionMustBeLastSegmentInSelect(containerQualifiedName)); } continue; } if (!previousSegmentResourceType.IsOpenType) { throw DataServiceException.CreateSyntaxError(System.Data.Services.Strings.RequestUriProcessor_PropertyNotFound(previousSegmentResourceType.FullName, containerQualifiedName)); } if (!lastPathSegment) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(containerQualifiedName)); } } rootProjectionNode = ApplyProjectionForProperty(rootProjectionNode, containerQualifiedName, property, previousSegmentResourceType, lastPathSegment); type = null; } if (type != null) { throw DataServiceException.CreateBadRequestError(System.Data.Services.Strings.RequestQueryProcessor_QueryParametersPathCannotEndInTypeIdentifier("$select", type.FullName)); } } }
/// <summary>create exception when missing an expected batch boundary</summary> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamMissingBoundary() { return(Trace(DataServiceException.CreateBadRequestError(Strings.DataService_InvalidContentTypeForBatchRequest))); }
private void ExecutionCompletionEventHandler(IAsyncResult ar) { Exception dataServiceException; lock (this.syncObject) { this.timer.Stop(); this.isExecutionCompleted = true; if (!this.isExceedsMaxExecutionTime) { dataServiceException = PSCommand.CheckPowershellForException(this.cmdletInfo.CmdletName, this.commandType, this.powerShell); } else { object[] cmdletName = new object[1]; cmdletName[0] = this.cmdletInfo.CmdletName; dataServiceException = new DataServiceException(0x193, ExceptionHelpers.GetDataServiceExceptionMessage(HttpStatusCode.Forbidden, Resources.CmdletExecutionQuotaExceeded, cmdletName)); TraceHelper.Current.CommandExecutionTimeExceeded(this.cmdletInfo.CmdletName, this.runspace.Borrower.Name, DataServiceController.Current.Configuration.PowerShell.Quotas.MaxExecutionTime, 0); DataServiceController.Current.PerfCounters.SystemQuotaViolationsPerSec.Increment(); DataServiceController.Current.QuotaSystem.SystemQuotaViolation.Increment(); } if (this.output != null && dataServiceException == null) { foreach (PSObject pSObject in this.output) { if (pSObject == null) { continue; } DSResource dSResource = SerializerBase.SerializeEntity(pSObject, this.entityType); this.dataStore.Add(dSResource); } } this.dataStore.Completed(dataServiceException); this.powerShell.Trace(); } this.Dispose(); }
/// <summary>create exception when unexpected content is discovered</summary> /// <param name="state">http method operation</param> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamContentUnexpected(BatchStreamState state) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_ContentUnexpected(state.ToString())))); }
/// <summary>Creates a new "Bad Request" exception for recursion limit exceeded.</summary> /// <returns>A new exception to indicate that the request is rejected.</returns> internal static DataServiceException CreateDeepRecursion_General() { return(DataServiceException.CreateBadRequestError(Strings.BadRequest_DeepRecursion_General)); }
/// <summary>create exception when Get operation is specified in changeset</summary> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamGetMethodNotSupportInChangeset() { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_GetMethodNotSupportedInChangeset))); }
public void CtorMessage() { var ex = new DataServiceException ("message"); Assert.AreEqual ("message", ex.Message); Assert.IsNull (ex.InnerException); }
/// <summary>create exception when invalid batch request is specified</summary> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamInvalidBatchFormat() { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidBatchFormat))); }
public void CtorStatusAndMessage() { var ex = new DataServiceException (404, "message"); Assert.AreEqual (404, ex.StatusCode); Assert.AreEqual ("message", ex.Message); }
/// <summary>create exception when boundary delimiter is not valid</summary> /// <param name="delimiter">delimiter specified as specified in the request.</param> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamInvalidDelimiter(string delimiter) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidDelimiter(delimiter)))); }
/// <summary> /// If the provider implements IConcurrencyProvider, then this method passes the etag values /// to the provider, otherwise compares the etag itself. /// </summary> /// <param name="resourceCookie">etag values for the given resource.</param> /// <param name="container">container for the given resource.</param> internal void SetETagValues(object resourceCookie, ResourceSetWrapper container) { Debug.Assert(resourceCookie != null, "resourceCookie != null"); Debug.Assert(container != null, "container != null"); DataServiceHostWrapper host = this.service.OperationContext.Host; Debug.Assert(String.IsNullOrEmpty(host.RequestIfNoneMatch), "IfNoneMatch header cannot be specified for Update/Delete operations"); // Resolve the cookie first to the actual resource type object actualEntity = this.ResolveResource(resourceCookie); Debug.Assert(actualEntity != null, "actualEntity != null"); ResourceType resourceType = WebUtil.GetNonPrimitiveResourceType(this.service.Provider, actualEntity); Debug.Assert(resourceType != null, "resourceType != null"); IList <ResourceProperty> etagProperties = this.service.Provider.GetETagProperties(container.Name, resourceType); if (etagProperties.Count == 0) { if (!String.IsNullOrEmpty(host.RequestIfMatch)) { throw DataServiceException.CreateBadRequestError(Strings.Serializer_NoETagPropertiesForType); } // If the type has no etag properties, then we do not need to do any etag checks return; } // If the provider implements IConcurrencyProvider, then we need to call the provider // and pass the etag values. Else, we need to compare the etag values ourselves. IDataServiceUpdateProvider concurrencyProvider = this.updateProvider as IDataServiceUpdateProvider; if (concurrencyProvider != null) { bool?checkForEquality = null; IEnumerable <KeyValuePair <string, object> > etagValues = null; if (!String.IsNullOrEmpty(host.RequestIfMatch)) { checkForEquality = true; etagValues = ParseETagValue(etagProperties, host.RequestIfMatch); } else { etagValues = new KeyValuePair <string, object> [0]; } concurrencyProvider.SetConcurrencyValues(resourceCookie, checkForEquality, etagValues); } else if (String.IsNullOrEmpty(host.RequestIfMatch)) { throw DataServiceException.CreateBadRequestError(Strings.DataService_CannotPerformOperationWithoutETag(resourceType.FullName)); } else if (host.RequestIfMatch != XmlConstants.HttpAnyETag) { // Compare If-Match header value with the current etag value, if the If-Match header value is not equal to '*' string etagValue = WebUtil.GetETagValue(resourceCookie, resourceType, etagProperties, this.service, false /*getMethod*/); Debug.Assert(!String.IsNullOrEmpty(etagValue), "etag value can never be null"); if (etagValue != host.RequestIfMatch) { throw DataServiceException.CreatePreConditionFailedError(Strings.Serializer_ETagValueDoesNotMatch); } } }
/// <summary>create exception when end changeset boundary delimiter is missing</summary> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamMissingEndChangesetDelimiter() { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_MissingEndChangesetDelimiter))); }
/// <summary>Creates a new "Method Not Allowed" exception.</summary> /// <param name="message">Error message.</param> /// <param name="allow">String value for 'Allow' header in response.</param> /// <returns>A new exception to indicate the requested method is not allowed on the response.</returns> internal static DataServiceException CreateMethodNotAllowed(string message, string allow) { // 405 - Method Not Allowed DataServiceException result = new DataServiceException(405, message); result.responseAllowHeader = allow; return result; }
/// <summary>create exception when header value specified is not valid</summary> /// <param name="headerValue">header value as specified in the request.</param> /// <returns>exception to throw</returns> internal static DataServiceException BatchStreamInvalidHeaderValueSpecified(string headerValue) { return(Trace(DataServiceException.CreateBadRequestError(Strings.BatchStream_InvalidHeaderValueSpecified(headerValue)))); }