Repository navigation
9.0: Resolve Grails formats through Spring MVC's content negotiation - #16996
Conversation
…ndler UrlMappingsHandlerMapping now sets HandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE to the UrlMappingInfo it returns, as Spring MVC's own handler mappings set it for the handler they find, and takes it off the request once the dispatch completes, with an interceptor first in the chain so that it completes last, whichever interceptor stops the request. A dispatch another handler mapping handles in the meantime, such as a forward to a Spring MVC endpoint, keeps the attribute it set. Content negotiation can then tell a request a URL mapping handles from one a Spring MVC endpoint handles, and from what Spring Security negotiates after the dispatch. The version lookup no longer fails for a request whose response type resolves to none.
…he#16698) The opt-in grails.mime.negotiation.spring (default false in Grails 10) resolves request.format, response.format, withFormat and the format respond writes in with Spring MVC's ContentNegotiationManager, as the formats grails.mime.types gives the media types it resolves: - The Accept header is read by Spring MVC's manager, with its strategies and spring.mvc.contentnegotiation.*, in its order: quality, then specificity, then the order of the header. The text/xml merge and the +xml preference are gone. - A type with the +json or +xml suffix that no configured type names is the json or xml format, as Spring MVC's converters write such types; this extends the rule Grails 9 had for the problem types of RFC 9457. - */* is the all format, also where it is not configured. Another wildcard, such as text/*, is a type of the all format that withFormat answers with its first block, and respond with the first of the action's formats, whose format has a type compatible with it. - A request that accepts no configured type, or whose Accept header Spring cannot read, has no format: response.format is null, respond answers 406 and withFormat runs its * block or none. - The format parameter and URL extensions are kept, ahead of Spring MVC's strategies; an unknown format is not acceptable and all leaves the format to the Accept header. request.format reads Content-Type with Spring's parser. The format parameter, URL extensions and the grails.mime Accept header settings are installed into Spring MVC's manager, by a post-processor that replaces the mvcContentNegotiationManager bean with the setting only, as strategies that apply while a URL mapping handles the request, so that what Spring MVC writes for an action, such as a ResponseEntity or a ProblemDetail, is negotiated as Grails resolves its format. Spring MVC endpoints and Spring Security, before a mapping has matched the request, negotiate as before, and GrailsContentNegotiationStrategy is still no Spring ContentNegotiationStrategy bean. A web unit test marks the request of the action it calls as handled by a URL mapping, as in an application. Without the setting, every answer is that of Grails 9.
…type ReflectionUtils.matchAllUrlMappings read the version of the response type, which grails.mime.negotiation.spring resolves to none for a request that accepts no configured type, such as one that sends only Accept: image/png, so every such request failed in the security filter with a NullPointerException. It now matches any version, as for a type without one.
FormatNegotiationComparisonSpec runs a matrix of requests a URL mapping handles through both policies, with and without grails.mime.negotiation.spring, under several grails.mime.types and Accept header configurations: Accept headers with qualities, wildcards and +json/+xml types, browser and XHR user agents, the format parameter, and Content-Type. It records each answer that differs, from response.format, withFormat, request.format and the media types Spring MVC's manager resolves for what it writes, so that a change to either policy that changes an answer fails it, and checks that with the setting the first type the manager resolves is of the format Grails resolves.
app1 answers the same requests with and without grails.mime.negotiation.spring: a ResponseEntity an action returns is written in the format of its URL extension, or not acceptable where no converter writes it so, an unknown format is not acceptable, the formats Grails resolves follow Spring MVC's order, a +json body is of the json format, and a Spring MVC endpoint keeps its negotiation.
The content negotiation guide describes how the setting resolves formats with Spring MVC's manager and what becomes of each Grails rule: kept, extended or dropped. The new Upgrading from Grails 9 to Grails 10 section lists the answers that change, which FormatNegotiationComparisonSpec records, and the built-in properties list the setting.
The setting is opt-in in Grails 9, and Grails 10 makes it the default, as it does for the other migration settings in grails.config.Settings: the new API is @SInCE 9.0, the upgrade notes are section 22 of Upgrading from Grails 8 to Grails 9, which the content negotiation guide and What's New point to, and the settings documentation gives its default as false in Grails 9 and true from Grails 10.
A forward an action makes is a dispatch of its own, which Spring MVC's handler mappings match after the URL mappings, while the mapping of the forwarding dispatch was still the request's best matching handler. With grails.mime.negotiation.spring, the produces condition of an endpoint was then matched on the format the action was asked for: /book/forward?format=xml to an endpoint that produces JSON answered 406 for a client that accepts JSON. The URL mappings now take a mapping an earlier dispatch left off the request when they match no handler for the dispatch.
The post-processor that replaces Spring MVC's content negotiation manager read the setting from the Spring Environment, while the strategy that resolves Grails formats read it from the application's configuration. A configuration that is not the environment, as one a test builds by hand or one code changes, could then enable one half of the setting without the other: Grails formats resolved with Spring MVC's manager while what Spring MVC writes ignored the Grails rules, or the other way round. Both now read the application's configuration.
The functional spec with grails.mime.negotiation.spring ran in app1 with @TestPropertySource, which starts a second application context in the test JVM. GORM's static API then answered for that context, so the GORM specs of app1 that ran after it failed with "No Session found for current thread". The spec moves to grails-test-examples/spring-format-negotiation, whose application.yml sets the setting, with the Spring MVC endpoint and the actions it calls; app1 keeps the spec of the Grails rules, which runs in its own context.
With grails.mime.negotiation.spring and a grails.mime.types that does not list all, a client that accepts any type resolves to the all format, which reading response.format saves as the response format. respond then resolved that saved format to no type, and answered 406: the all format is now */*, any type, as Spring MVC reads it, whether or not grails.mime.types lists it. ?format=all then leaves the format to the Accept header there too, for Grails formats and for what Spring MVC writes.
grails.mime.negotiation.spring took the types of the Accept header in Spring MVC's order alone, so Accept: application/xml, application/atom+xml resolved to xml where the Grails rules resolve it to atom. A type with the +xml suffix of the quality of the first application/xml or text/xml now comes ahead of it, each one later in the header in front of those before it, as the Grails rules order them, for Grails formats and, for a request a URL mapping handles, for what Spring MVC writes. The comparison record loses the atom answers, and the guide and upgrade notes list the rule as kept; they also describe the all format of the previous commit.
|
…otiation With spring.mvc.contentnegotiation.favor-parameter, Spring MVC's parameter negotiation reads the format parameter, as Grails does. Grails left the all format to the Accept header, and the parameter strategy then read the same parameter again and found all not acceptable: ?format=all with Accept: application/json answered 406 to respond and to what Spring MVC writes for the action. For a request a URL mapping handles, Grails now reads the format parameter in place of that strategy, so all is left to the Accept header; a Spring MVC endpoint still reads it with Spring MVC's parameter negotiation.
jamesfredley
left a comment
There was a problem hiding this comment.
The items this review found have been addressed. format=all is left to the Accept header, a more specific xml type stays ahead of xml, and an accept-all header does not make a later respond fail.
…-negotiation-9.0.x # Conflicts: # grails-doc/src/en/guide/upgrading/upgrading90x.adoc
jamesfredley
left a comment
There was a problem hiding this comment.
Requested changes. A format registered only with Spring MVC is rejected when the request asks for it by name.
For a request a URL mapping handles, Grails reads the format parameter and the URL extension in place of Spring MVC's parameter strategy, and rejected a format grails.mime.types does not list before Spring MVC could map it: with spring.mvc.contentnegotiation.media-types.plain: text/plain, ?format=plain or .plain with Accept: application/json answered 406 for a ResponseEntity the action returns. A format grails.mime.types does not list is now the type Spring MVC's content negotiation manager maps it to, with or without favor-parameter, and only a format neither maps is not acceptable. A format Grails configures keeps its own types, and respond still answers 406 for a format only Spring MVC maps, since Grails has no type of it to render. The guide, the upgrade notes and the grails-upgrade skill say so.
sbglasius
left a comment
There was a problem hiding this comment.
This is an AI assisted review
Approving. The earlier threads (atom/+xml order, ?format=all, Spring-only formats) are resolved, and the comparison spec plus upgrade-guide section 26 document the behaviour well. A few non-blocking points:
UrlMappingsHandlerMappingandGrailsWebUnitTestnow setHandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTEeven whengrails.mime.negotiation.springis off. Only the new strategies read it, so setting it only when the setting is on would keep the default fully as in Grails 9.HttpServletRequestExtension.getMimeTypescallsGrailsContentNegotiationStrategy.forRequest()before it checks the setting, andRestResponder.respondcalls it on everyrespond. Storing the strategy, or just the flag, on the request would avoid the repeated lookups.- The post-processor and the strategy each read the setting on their own. Having the post-processor read it from the strategy would keep the two from ever disagreeing.
jamesfredley
left a comment
There was a problem hiding this comment.
The items this review found have been addressed. A format registered only with Spring MVC is written in the type Spring MVC maps it to.
GrailsContentNegotiationStrategy.forRequest looked the strategy up in the application context on every call, and, in a context without MimeTypesConfiguration, such as one a test builds by hand, built a new one each time. request.format, response.format, response.mimeType, withFormat and respond each call it, also without grails.mime.negotiation.spring, since the setting is only known through the strategy. The strategy is now kept as an attribute of the request it was resolved for, so each request looks it up once, for every caller, and the RestResponder trait gets no field.
…tion.spring UrlMappingsHandlerMapping set BEST_MATCHING_HANDLER_ATTRIBUTE to the mapping it matched, and put an interceptor that takes it off first in every handler chain, and a web unit test set it for the action it calls, whatever the setting said. Only the content negotiation strategies the setting installs read it. The handler mapping now does both only where markHandledRequests is set, which the URL mappings plugin sets from grails.mime.negotiation.spring in the Grails configuration, as the negotiation reads it, and a web unit test sets the attribute only with the setting. Without it, the handler chain and the request attributes are those of 9.0.x.
|
…-negotiation-9.0.x # Conflicts: # grails-doc/src/en/guide/upgrading/upgrading90x.adoc
jdaugherty
left a comment
There was a problem hiding this comment.
Reviewed at 66e1fae against 9.0.x. No blocking code findings; one non-blocking documentation correction below.
The earlier fixes for +xml ordering, accept-all format caching, format=all with Spring parameter negotiation, and formats registered only with Spring MVC are present and covered by passing tests. The latest changes also gate the handler marker on the setting and retain the negotiation strategy per request.
Validation on Java 21, with --offline --no-configuration-cache:
- Full test tasks for grails-mimetypes, grails-web-url-mappings, grails-url-mappings and grails-rest-transforms: 934 passed, 1 skipped, no failures (including the URL-mapping CLI tests).
- grails-test-suite-web negotiation specs and MigrationSettingsMetadataSpec: 36 passed.
- grails-test-examples-spring-format-negotiation integration tests: 12 passed.
The Groovy Snapshot Canary failure log shows static type-checking errors in unchanged code, including GrailsApplicationPostProcessor, RxPromiseFactory and Tenants; those are separate from this change.
| `grails.mime` settings of the `Accept` header decide what Spring MVC writes for an action too, such as a | ||
| `ResponseEntity` it returns. See <<springFormatNegotiation,Resolving Formats with Spring MVC Content Negotiation>>. | ||
|
|
||
| See xref:upgrading#upgrading90x[Upgrading from Grails 8 to Grails 9], sections 4 to 11, 13 to 16 and 26. |
There was a problem hiding this comment.
[P3] Link the content-negotiation upgrade note by its anchor. This still sends readers to section 26, which now covers domain-class events in unit tests. The content-negotiation note is numbered 29 in the current head. Please use the new upgradingSpringFormatNegotiation anchor for this reference, or update the number; using the anchor would avoid another stale reference after a merge renumbers the guide.
There was a problem hiding this comment.
9.0.x numbered the notes of JLine 4 and of the command lines of application commands 29 and 30, so the upgrade notes of grails.mime.negotiation.spring are now section 31.
What's New still named section 26 for the upgrade notes of grails.mime.negotiation.spring, which 9.0.x has renumbered twice since; they are now section 31. It links them by their anchor, upgradingSpringFormatNegotiation, so a renumbering cannot leave the reference stale again. The other sections the sentence lists moved by two when 9.0.x added the Spring Boot 4.2 and graphql-java 26 notes as sections 2 and 3, so they are now 6 to 13 and 15 to 18.
🚨 TestLens detected 56 failed tests 🚨Failed Jobs without Test Failures❌ CI / Hibernate7 Functional Tests (Java 25, indy=false) Test SummaryTip Inspect all details with the TestLens CLI: CI / Functional Tests (Java 21, indy=false) > :grails-test-examples-issue-11102:integrationTest
CI / Functional Tests (Java 21, indy=false, shard 1) > :grails-test-examples-jetty:integrationTest
CI / Functional Tests (Java 21, indy=false, shard 1) > :grails-test-examples-undertow:integrationTest
CI / Functional Tests (Java 21, indy=true) > :grails-test-examples-issue-11102:integrationTest
CI / Functional Tests (Java 21, indy=true, shard 1) > :grails-test-examples-jetty:integrationTest
CI / Functional Tests (Java 21, indy=true, shard 1) > :grails-test-examples-undertow:integrationTest
CI / Functional Tests (Java 25, indy=false) > :grails-test-examples-issue-11102:integrationTest
CI / Functional Tests (Java 25, indy=false, shard 1) > :grails-test-examples-jetty:integrationTest
CI / Functional Tests (Java 25, indy=false, shard 1) > :grails-test-examples-undertow:integrationTest
SiteMesh 2 Compatibility / SiteMesh 2 Functional Tests (Java 21, indy=false) > :grails-test-examples-issue-11102:integrationTest
SiteMesh 2 Compatibility / SiteMesh 2 Functional Tests (Java 21, indy=false) > :grails-test-examples-jetty:integrationTest
SiteMesh 2 Compatibility / SiteMesh 2 Functional Tests (Java 21, indy=false) > :grails-test-examples-undertow:integrationTest
🏷️ Commit: 5065b39 Test Failures (first 10 of 56)FailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, after an asynchronous forward from Spring MVC is reported once with its own exception and route (:grails-test-examples-issue-11102:integrationTest in CI / Functional Tests (Java 21, indy=false))
FailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, after an asynchronous forward from an action is reported once with its own exception and route (:grails-test-examples-issue-11102:integrationTest in CI / Functional Tests (Java 21, indy=false))
FailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, after starting async is reported once with its own exception and route (:grails-test-examples-issue-11102:integrationTest in CI / Functional Tests (Java 21, indy=false))FailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, asynchronously is reported once with its own exception and route (:grails-test-examples-issue-11102:integrationTest in CI / Functional Tests (Java 21, indy=false))
FailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by the error view, after starting async is reported once with its own exception and route (:grails-test-examples-issue-11102:integrationTest in CI / Functional Tests (Java 21, indy=false))JettyFailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, after an asynchronous forward from Spring MVC is reported once with its own exception and route (:grails-test-examples-jetty:integrationTest in CI / Functional Tests (Java 21, indy=false, shard 1))
JettyFailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, after an asynchronous forward from an action is reported once with its own exception and route (:grails-test-examples-jetty:integrationTest in CI / Functional Tests (Java 21, indy=false, shard 1))
JettyFailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, after starting async is reported once with its own exception and route (:grails-test-examples-jetty:integrationTest in CI / Functional Tests (Java 21, indy=false, shard 1))
JettyFailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by an error controller, asynchronously is reported once with its own exception and route (:grails-test-examples-jetty:integrationTest in CI / Functional Tests (Java 21, indy=false, shard 1))
JettyFailedActionObservationSpec > a failed action answered by #handler is reported once with its own exception and route > a failed action answered by the error view, after starting async is reported once with its own exception and route (:grails-test-examples-jetty:integrationTest in CI / Functional Tests (Java 21, indy=false, shard 1))Rerun Controls (first 20 of 56)Select tests to mute in this pull request:
Reuse successful test results:
Click the checkbox to trigger a rerun:
Learn more about TestLens at testlens.app/docs. |
matrei
left a comment
There was a problem hiding this comment.
Reviewed again at 5065b39 (base 9.0.x, merge base c4d4c59). 9.0.x has moved on to fdde94a since, which touches none of the files of this PR.
Both points of my first review are fixed:
- e17f652 and 5065b39: What's New and the content negotiation section link the upgrade notes by the
upgradingSpringFormatNegotiationanchor, and What's New links the guide section with<<springFormatNegotiation,...>>. In the built guide, every link to the two sections stays on the page insingle.html, and on the chapter pages they point attheWebLayer.html#springFormatNegotiationandupgrading.html#upgradingSpringFormatNegotiation. I missed in my first review that the other numbers in that sentence were stale too, since 9.0.x added sections 2 and 3. 6 to 13 and 15 to 18 are the right ones. - c903885: the spec requests
/springWritten/text.textwithAccept: application/jsonand expectstext/plain.
What I ran at 5065b39, with the build cache off:
- The unit tests of the modules this touches: grails-mimetypes (202), grails-web-url-mappings (533), grails-url-mappings (22), grails-test-suite-web (3442), grails-spring-security (327) and grails-rest-transforms (176). All pass.
:grails-test-examples-spring-format-negotiation:integrationTest(12) and app1'sfunctionaltests.contentneg.*(26). All pass.- With
GRAILS_MIME_NEGOTIATION_SPRING=true: app1's full integration suite (728), views-functional-tests (60) and the spring-security core integration-test-app (65). As before, only the three features of app1'sGrailsFormatNegotiationSpecthat pin the default rules fail. So the setting still turns the marker on when it comes from the environment, now that the URL mappings plugin reads it as well. :grails-doc:publishGuidebuilds.
The Functional Tests and SiteMesh 2 jobs fail with the same tests in 9.0.x's own run at fdde94a. The Hibernate7 job fails only on five DB2 rows, from the DB2 container, and the canary jobs fail on 9.0.x too.
Optional
- a7ae6fc: the guide, the upgrade notes, the skill and the Javadoc of
springMediaTypesOfsay the fallback takes a format thatspring.mvc.contentnegotiation.media-typesmaps. It takes any format Spring MVC's manager maps, and the manager also holds the defaultsWebMvcConfigurationSupportregisters for the converters present:json, andxml,atom,rss,smile,cborandyamlwhere their libraries are on the classpath. The lookup also ignores case, while a format ofgrails.mime.typeshas to match exactly. So with nomedia-typesconfigured,?format=JSONis written asapplication/jsonthrough Spring MVC'sjsondefault, whilerespondanswers it with 406. I checked both with temporary features inSpringFormatNegotiationSpecandSpringFormatNegotiationParameterRespondSpec. Spring MVC's parameter strategy does the same withfavor-parameter, so I think the behaviour is fine. Only the wording undersells it: "a format Spring MVC's content negotiation manager maps, such as onespring.mvc.contentnegotiation.media-typesadds" would cover it.
Verified as correct
- c960808: without the setting, the handler mapping neither sets
BEST_MATCHING_HANDLER_ATTRIBUTEnor adds the interceptor that removes it, and a web unit test does not set it, so the handler chain and the request attributes are those of 9.0.x.UrlMappingsBeanDefinitionsPostProcessoris the only place that registers the handler mapping, so no other path builds one without the flag. The URL mappings plugin,MimeTypesConfigurationandGrailsWebUnitTestall read the setting fromgrailsApplication.config. - d083eda: the kept strategy is the application's own, or one built from the same settings, so a forward, include or asynchronous dispatch that finds it on the request gets the answer a fresh lookup would give.
- a7ae6fc:
mediaTypesOfreturnsnullrather than an empty list, so the?:falls back only for a formatgrails.mime.typeshas no type for, and a format Grails configures keeps its own types. The manager holds its mappings withfavor-parameteroff too, which the new spec rows cover.
preferringSuffixedXml took each +xml type behind the XML type out of the list with remove(Object), which removes the first equal type. Where the header lists a type twice, that was the one ahead of the XML type, so the first pass, which decides what Spring MVC writes, left the type behind it, and the second, when Grails resolves its formats, moved it again: with the default grails.mime.types, Accept: application/atom+xml, application/xml, application/atom+xml had Spring MVC write application/xml while the format was atom, and application/xml, application/atom+xml, application/atom+xml was the xml format. With problem+xml mapped in Spring MVC only, the same happened with an unconfigured problem+xml as the XML type. apache#16996 brought the method in on 9.0.x. Each type is now removed from its own index. After one pass no +xml type of the quality of the XML type is left behind it, so a second pass changes nothing, and the format and the type Spring MVC writes agree. SpringFormatNegotiationSpec covers the repeated type with the default types and with the Spring-only problem mapping, and FormatNegotiationComparisonSpec sends application/atom+xml, application/xml, application/atom+xml under every configuration, where only what Spring MVC writes differs.
Fixes #16698
Summary
Grails resolves
request.format,response.format,withFormatand the formatrespondwrites in with its owngrails.mimerules, while Spring MVC'sContentNegotiationManagerdecides the type of what Spring MVC writes for an action: aResponseEntityorProblemDetailan action returns, a problemrespondwrites, and the JSONrespondwrites with Spring MVC. The two can answer the same request differently.The opt-in
grails.mime.negotiation.springresolves the Grails formats with Spring MVC's manager too, as the formatsgrails.mime.typesgives the media types it resolves. Grails 9 keeps its own rules by default; the plan is for Grails 10 to make the setting the default, as for the other migration settings ingrails.config.Settings.What becomes of each Grails rule
grails.mime.negotiation.springformatparameter and URL extensions select the formatgrails.mime.typesdoes not list is the typespring.mvc.contentnegotiation.media-typesmaps it to for what Spring MVC writes, whilerespondanswers it with 406; a format neither maps is not acceptable.all, any type whether or not it is configured, leaves the format to theAcceptheader.grails.mime.use.accept.headerandgrails.mime.disable.accept.header.*ignore theAcceptheadertext/xmlandapplication/xmlare merged into onexmltypexmlformat, in Spring MVC's order.+xmltype comes ahead ofapplication/xmlof equal qualityjsonandxmlformats+json/+xmltype no configured type names, as Spring MVC's converters write them.Acceptheader Spring cannot read.A request that accepts no configured type has no format:
response.formatandresponse.mimeTypearenull,respondanswers406 Not Acceptable, andwithFormatruns its*block, or none. Code that reads them allows fornull, as the plugins in this repository do.The kept rules are strategies installed into Spring MVC's manager (
mvcContentNegotiationManager), which apply only while a URL mapping handles the request. With the setting, the URL mappings set the mapping as the request'sHandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE, as Spring MVC's own handler mappings set theirs, and take it off when the dispatch completes, or when a forward the action makes is to a handler no mapping matches; a web unit test sets it for the action it calls. Spring MVC endpoints, and Spring Security outside a Grails dispatch, negotiate as before, andGrailsContentNegotiationStrategyis still noContentNegotiationStrategybean.Usage
An action whose
ResponseEntityfollows its URL extension, as its views do:withFormatandrespondnow answer in Spring MVC's order, and a wildcard such astext/*with the first block or format compatible with it:A format mapped only in Spring MVC still decides what Spring MVC writes for an action:
A body sent as
application/merge-patch+jsonis of thejsonformat, so data binding reads it as JSON.Evidence
FormatNegotiationComparisonSpecruns a matrix of requests (Acceptwith qualities, wildcards and+json/+xmltypes, browser and XHR user agents,?format=,Content-Type) through both policies under five configurations and records every answer that differs; the upgrade guide's new section 31 summarizes it.Behaviour without the setting
Every negotiation answer is that of Grails 9, and the URL mappings' handler chain and request attributes are those of 9.0.x. Other changes that apply regardless:
NullPointerExceptionfor it.MimeTypesConfiguration.grailsMimeTypesWebMvcConfigurer, a static@Beanmethod of an internal package, takes the content negotiation manager as a third parameter.