"""Publish exact approved listing patches through a tenant-bound, non-retrying transport.""" from __future__ import annotations import base64 import copy import hashlib import json import re import time import urllib.error import urllib.parse import urllib.request from core import amazon_listing_attributes as details ENDPOINTS = { "na": "https://sellingpartnerapi-na.amazon.com", "eu": "https://sellingpartnerapi-eu.amazon.com", "fe": "https://sellingpartnerapi-fe.amazon.com", } PUBLIC_MEDIA_HOST = "fsanyoto-loopable.hf.space" MEDIA_HOSTS = frozenset({PUBLIC_MEDIA_HOST, "m.media-amazon.com"}) IMAGE_ATTRIBUTES = frozenset({"main_product_image_locator"} | { f"other_product_image_locator_{index}" for index in range(1, 9)}) COPY_ATTRIBUTES = frozenset({ "item_name", "title_differentiation", "bullet_point", "product_description", "generic_keyword"}) DETAIL_ATTRIBUTES = details.DETAIL_ATTRIBUTES REPLACE_ATTRIBUTES = COPY_ATTRIBUTES | IMAGE_ATTRIBUTES | DETAIL_ATTRIBUTES SCHEMA_HOSTS = frozenset({ "selling-partner-definitions-prod-iad.s3.amazonaws.com", "selling-partner-definitions-prod-iad.s3.us-east-1.amazonaws.com", "selling-partner-definitions-prod-dub.s3.amazonaws.com", "selling-partner-definitions-prod-dub.s3.eu-west-1.amazonaws.com", "selling-partner-definitions-prod-pdx.s3.amazonaws.com", "selling-partner-definitions-prod-pdx.s3.us-west-2.amazonaws.com", }) STATE_KEY = "amazon_listing_writes" PREVIEW_TTL = 15 * 60 _MAX_BYTES = 16 * 1024 * 1024 _NAME = re.compile(r"[A-Za-z0-9_][A-Za-z0-9_.:-]{0,255}\Z") class ListingWriteFailure(RuntimeError): """Expose fixed failure metadata without provider URLs, payloads or credentials.""" def __init__(self, operation, failure_class="Refused", status=None, *, field=None, allowed_units=()): self.operation = operation self.failure_class = failure_class self.status = status if type(status) is int else None self.field, self.allowed_units = field, list(allowed_units) super().__init__(f"{operation}: {self.status}: {failure_class}") def _text(value, maximum=1024): return (isinstance(value, str) and 0 < len(value) <= maximum and bool(value.strip()) and not any(ord(char) < 32 for char in value)) def _copy_text(value): return (isinstance(value, str) and 0 < len(value) <= _MAX_BYTES and bool(value.strip()) and not any(ord(char) < 32 and char not in "\n\r\t" for char in value)) def _name(value): if not isinstance(value, str) or not _NAME.fullmatch(value): raise ListingWriteFailure("validate", "InvalidIdentifier") return value def _json(value): try: return json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode("utf-8") except (TypeError, ValueError, UnicodeError): raise ListingWriteFailure("validate", "InvalidJSON") from None def _hash(value): return hashlib.sha256(_json(value)).hexdigest() def _tenant(rt): key = getattr(rt, "key", None) if not isinstance(key, str) or not key or key != key.strip().lower(): raise ListingWriteFailure("authorize", "TenantRequired") return key def _document(value, tenant): if value is None or value == {}: return {"tenant_key": tenant, "writes_enabled": False, "switch_history": [], "previews": {}, "receipts": {}} if (not isinstance(value, dict) or value.get("tenant_key") != tenant or type(value.get("writes_enabled")) is not bool or not isinstance(value.get("switch_history"), list) or any(not isinstance(value.get(key), dict) for key in ("previews", "receipts"))): raise ListingWriteFailure("store", "InvalidTenantState") return copy.deepcopy(value) def _read(rt): try: return _document(rt.get(STATE_KEY, fresh=True), _tenant(rt)) except ListingWriteFailure: raise except Exception: raise ListingWriteFailure("store", "StateUnreadable") from None def _change(rt, mutate): tenant = _tenant(rt) def change(value): document = _document(value, tenant) mutate(document) return document try: rt.update(STATE_KEY, change, flush="sync") return _read(rt) except ListingWriteFailure: raise except Exception: # Persistence uncertainty never grants permission to send. raise ListingWriteFailure("store", "PersistenceUnproven") from None def writes_enabled(rt): """Read the tenant's current switch without a cache and fail closed on any read fault.""" try: return _read(rt)["writes_enabled"] is True except Exception: return False def set_writes_enabled(rt, enabled, by, words): """Record a platform administrator's switch setting and exact instruction atomically.""" from core import platform_admin if (type(enabled) is not bool or not platform_admin.is_platform_admin(by) or not _text(by.get("username")) or not _text(words, 16384)): raise ListingWriteFailure("switch", "PlatformAdminAndWordsRequired") event = {"id": _nonce(), "tenant_key": _tenant(rt), "enabled": enabled, "by": by["username"], "words": words, "at": time.time()} def flip(document): document["writes_enabled"] = enabled document["switch_history"].append(event) stored = _change(rt, flip) if stored["writes_enabled"] is not enabled or event not in stored["switch_history"]: raise ListingWriteFailure("switch", "PersistenceUnproven") return copy.deepcopy(event) def _nonce(): import uuid return uuid.uuid4().hex def allowed_media_url(value): """Admit only HTTPS images on the published Space or Amazon's exact image host.""" if not _text(value, 8192) or value != value.strip() or "\\" in value: return False try: parts = urllib.parse.urlsplit(value) return (parts.scheme == "https" and parts.netloc in MEDIA_HOSTS and parts.port is None and not parts.username and not parts.password and not parts.fragment and parts.path.startswith("/") and parts.path != "/") except ValueError: return False def validate_patch(body, marketplace, *, schema=None): """Return detached JSON containing only admitted attribute operations and value shapes.""" body = json.loads(_json(body)) _name(marketplace) if not isinstance(body, dict) or set(body) != {"productType", "patches"}: raise ListingWriteFailure("patchListingsItem", "InvalidPatch") _name(body["productType"]) patches, seen = body["patches"], set() if not isinstance(patches, list) or not patches: raise ListingWriteFailure("patchListingsItem", "InvalidPatch") for patch in patches: if not isinstance(patch, dict): raise ListingWriteFailure("patchListingsItem", "InvalidPatch") attribute = str(patch.get("path", "")).removeprefix("/attributes/") op = patch.get("op") if (patch.get("path") != "/attributes/" + attribute or attribute in seen or attribute not in REPLACE_ATTRIBUTES or not isinstance(op, str) or op not in {"replace", "delete"} or (op == "delete" and attribute not in IMAGE_ATTRIBUTES) or set(patch) not in ({"op", "path", "value"}, {"op", "path"}) or (op == "replace" and "value" not in patch)): raise ListingWriteFailure("patchListingsItem", "AttributeOrOperationRefused") seen.add(attribute) if "value" in patch: if attribute in DETAIL_ATTRIBUTES: if not isinstance(schema, details.DetailsSchema): raise ListingWriteFailure("patchListingsItem", "ProductTypeSchemaRequired") if schema.product_type != body["productType"] or schema.marketplace != marketplace: raise ListingWriteFailure("patchListingsItem", "ProductTypeSchemaMismatch") try: schema.validate_attribute(attribute, patch["value"]) except details.DetailFailure as exc: raise ListingWriteFailure("patchListingsItem", exc.reason, field=exc.field, allowed_units=exc.allowed_units) from None else: _attribute_values(attribute, patch["value"], marketplace, deleting=op == "delete") return body def _attribute_values(attribute, values, marketplace, *, deleting): if not isinstance(values, list) or not values: raise ListingWriteFailure("patchListingsItem", "InvalidAttributeValue") for value in values: if not isinstance(value, dict) or value.get("marketplace_id") != marketplace: raise ListingWriteFailure("patchListingsItem", "AttributeMarketplaceMismatch") if attribute in IMAGE_ATTRIBUTES: expected = {"marketplace_id"} if deleting else {"marketplace_id", "media_location"} if set(value) != expected or (not deleting and not allowed_media_url(value.get("media_location"))): raise ListingWriteFailure("patchListingsItem", "MediaLocationRefused") elif (set(value) - {"marketplace_id", "language_tag", "value"} or not _copy_text(value.get("value")) or ("language_tag" in value and not _text(value["language_tag"], 32))): raise ListingWriteFailure("patchListingsItem", "InvalidAttributeValue") def read_approval(rt, reader, approval_id, binding): """Require a trusted reader's approved record to contain every exact binding field.""" if not callable(reader) or not _text(approval_id) or binding.get("tenant_key") != _tenant(rt): raise ListingWriteFailure("approve", "ApprovalRequired") try: record = reader(_tenant(rt), approval_id) matches = (isinstance(record, dict) and record.get("decision") == "approved" and _text(record.get("approved_by")) and all(key in record and _json(record[key]) == _json(value) for key, value in binding.items())) except Exception: raise ListingWriteFailure("approve", "ApprovalUnreadable") from None if not matches: raise ListingWriteFailure("approve", "ExactApprovalRequired") return copy.deepcopy(record) class _NoRedirect(urllib.request.HTTPRedirectHandler): def redirect_request(self, req, fp, code, msg, headers, newurl): return None def _schema_capability(definition): if not isinstance(definition, dict) or not isinstance(definition.get("schema"), dict): raise ListingWriteFailure("downloadSchema", "SchemaDefinitionRequired") descriptor = definition["schema"] link = descriptor.get("link") url = link.get("resource") if isinstance(link, dict) else None try: parts = urllib.parse.urlsplit(url) allowed = (_text(url, 32768) and url == url.strip() and "\\" not in url and parts.scheme == "https" and parts.hostname in SCHEMA_HOSTS and parts.netloc == parts.hostname and parts.port is None and not parts.username and not parts.password and not parts.fragment and parts.path.startswith("/") and parts.path != "/") except (TypeError, ValueError): allowed = False if not allowed or link.get("verb") != "GET": raise ListingWriteFailure("downloadSchema", "SchemaHostRefused") checksum = descriptor.get("checksum") try: valid = isinstance(checksum, str) and len(base64.b64decode(checksum, validate=True)) == 16 except ValueError: valid = False if not valid: raise ListingWriteFailure("downloadSchema", "SchemaChecksumRequired") return {"url": url, "checksum": checksum} class _KeychainSnapshot: def __init__(self, rt, keychain): self.key = _tenant(rt) self.rows = {name: rt.get(name, fresh=True) or {} for name in (keychain.KEY, keychain.SCOPE_KEY)} if any(not isinstance(value, dict) for value in self.rows.values()): raise ListingWriteFailure("keychain", "InvalidCredentialStore") def get(self, name, fresh=False): return self.rows[name] class _Transport: def __init__(self, rt, *, connection_id=None, timeout=30): from core import keychain from harness import amazon_client self.rt, self.tenant_key = rt, _tenant(rt) self.keychain, self.client = keychain, amazon_client if connection_id is not None and not _text(connection_id): raise ListingWriteFailure("keychain", "ConnectionRequired") self.requested_connection = connection_id self.connection_id, self.fields = self._credential() self.fields = copy.deepcopy(self.fields) self.region = self.fields.get("region", "na") self.marketplace = _name(self.fields.get("marketplace_id")) if self.region not in ENDPOINTS or amazon_client.is_sandbox(self.fields): raise ListingWriteFailure("keychain", "ProductionRegionRequired") self.seller = urllib.parse.quote(self.fields["seller_id"], safe="") self.timeout, self.token, self.issued = timeout, None, 0.0 self.urlopen = urllib.request.build_opener(_NoRedirect()).open self._binding = None self._uploads = {} self._schemas = {} def _credential(self): if _tenant(self.rt) != self.tenant_key: raise ListingWriteFailure("keychain", "TenantChanged") try: snapshot = _KeychainSnapshot(self.rt, self.keychain) connection = self.requested_connection if connection is None: connection = self.keychain.default_connection_id(snapshot, "amazon_sp") fields = self.keychain.amazon_creds(snapshot, connection_id=connection) if connection else None if not isinstance(fields, dict) or not all(_text(fields.get(key)) for key in ( "seller_id", "marketplace_id", "client_id", "client_secret", "refresh_token")): raise ListingWriteFailure("keychain", "CredentialMissing") return connection, fields except ListingWriteFailure: raise except Exception: raise ListingWriteFailure("keychain", "CredentialUnreadable") from None def _current(self): connection, fields = self._credential() if connection != self.connection_id or fields != self.fields: raise ListingWriteFailure("keychain", "CredentialChangedOrRevoked") def _access_token(self): self._current() if self.token is None or time.monotonic() - self.issued >= 2700: try: self.token = self.client.access_token(self.fields, timeout=self.timeout) except Exception: raise ListingWriteFailure("accessToken", "TokenUnavailable") from None self.issued = time.monotonic() if not _text(self.token, 16384): raise ListingWriteFailure("accessToken", "TokenUnavailable") return self.token def _guard_request(self, operation, request): binding = self._binding if (not binding or request is not binding[0] or operation != binding[1] or request.full_url != binding[2] or request.data != binding[3]): raise ListingWriteFailure(operation, "FreshRequestBindingRequired") from harness import amazon_aplus_write as aplus if operation in aplus.OPERATIONS or operation == "uploadAplusImage": aplus.guard_request(self, operation, request, binding) return if operation == "downloadSchema": cap = binding[5] if (not isinstance(cap, dict) or cap != _schema_capability({"schema": { "link": {"verb": "GET", "resource": request.full_url}, "checksum": cap.get("checksum")}}) or request.method != "GET" or request.data is not None or binding[4] is not None or request.has_header("X-amz-access-token") or request.has_header("Authorization")): raise ListingWriteFailure(operation, "RequestRefused") return parts = urllib.parse.urlsplit(request.full_url) params = urllib.parse.parse_qs(parts.query, keep_blank_values=True) allowed = (parts.scheme == "https" and parts.netloc == urllib.parse.urlsplit(ENDPOINTS[self.region]).netloc and not parts.username and not parts.password and not parts.fragment and parts.port is None and request.get_header("X-amz-access-token") == self.token and bool(self.token) and not request.has_header("Authorization") and params.get("marketplaceIds") == [self.marketplace]) prefix = "/listings/2021-08-01/items/" + self.seller + "/" suffix = parts.path.removeprefix(prefix) listing = (parts.path.startswith(prefix) and bool(suffix) and "/" not in suffix and urllib.parse.unquote(suffix) not in {".", ".."}) if operation == "getListingsItem": allowed &= (listing and request.method == "GET" and request.data is None and set(params) == {"marketplaceIds", "includedData"} and params["includedData"] == ["attributes,productTypes,summaries"]) elif operation == "getDefinitionsProductType": definition = parts.path.removeprefix("/definitions/2020-09-01/productTypes/") allowed &= (parts.path.startswith("/definitions/2020-09-01/productTypes/") and bool(_NAME.fullmatch(definition)) and request.method == "GET" and request.data is None and params == {"marketplaceIds": [self.marketplace], "sellerId": [self.fields["seller_id"]], "requirements": ["LISTING"], "requirementsEnforced": ["ENFORCED"], "productTypeVersion": ["LATEST"]}) elif operation == "patchListingsItem": expected = {"marketplaceIds": [self.marketplace]} if binding[4] is None: expected["mode"] = ["VALIDATION_PREVIEW"] elif not callable(binding[4]): allowed = False allowed &= listing and request.method == "PATCH" and params == expected self._validate_patch(json.loads(request.data)) else: allowed = False if not allowed: raise ListingWriteFailure(operation, "RequestRefused") def _perform(self, operation, request): try: self._guard_request(operation, request) except ListingWriteFailure: self._binding = None raise except Exception: self._binding = None raise ListingWriteFailure(operation, "RequestRefused") from None boundary, cap, self._binding = self._binding[4], self._binding[5], None self._current() from harness import amazon_aplus_write as aplus if (operation in aplus.OPERATIONS or operation == "uploadAplusImage") and not writes_enabled(self.rt): raise ListingWriteFailure(operation, "WritesDisabled") if boundary is not None: boundary() status = None try: # This is the only wire owner and its opener refuses redirects and retries. with self.urlopen(request, timeout=self.timeout) as response: status = response.status raw = response.read(_MAX_BYTES + 1) if len(raw) > _MAX_BYTES or not 200 <= status < 300: raise ListingWriteFailure(operation, "InvalidHTTPResponse", status) if (operation == "downloadSchema" and base64.b64encode(hashlib.md5(raw).digest()).decode("ascii") != cap["checksum"]): raise ListingWriteFailure(operation, "SchemaChecksumMismatch", status) got = {"uploaded": True} if operation == "uploadAplusImage" else json.loads(raw) if not isinstance(got, dict): raise ListingWriteFailure(operation, "InvalidResponse", status) return got except ListingWriteFailure: raise except urllib.error.HTTPError as exc: exc.close() raise ListingWriteFailure(operation, "HTTPError", exc.code) from None except Exception: raise ListingWriteFailure(operation, "OutcomeUnknown", status) from None def _request(self, operation, path, params, *, body=None, boundary=None, method=None, image=None, schema=None): from harness import amazon_aplus_write as aplus method = method or ("GET" if body is None else "PATCH") cap = None if operation == "uploadAplusImage": url, raw, headers, cap = aplus.upload_request(self, path, image) elif operation == "downloadSchema": url, raw, headers, cap = path, None, {"Accept": "application/json"}, schema else: raw = None if body is None else _json(body) url = ENDPOINTS[self.region] + path + "?" + urllib.parse.urlencode(params) headers = {"x-amz-access-token": self._access_token(), "Content-Type": "application/json", "Accept": "application/json"} request = urllib.request.Request(url, data=raw, method=method, headers=headers) self._binding = (request, operation, url, raw, boundary, cap) return self._perform(operation, request) def aplus(self, operation, *, reference=None, asin=None, page_token=None, body=None, asins=None, content_md5=None, content_type=None, boundary=None): from harness import amazon_aplus_write as aplus if not writes_enabled(self.rt): raise ListingWriteFailure(operation, "WritesDisabled") path, params, method = aplus.operation_request( self.marketplace, operation, reference, asin, page_token, body, asins, content_md5, content_type) response = self._request(operation, path, params, body=body, boundary=boundary, method=method) if operation == "createUploadDestinationForResource": aplus.register_upload(self, response, content_md5, content_type) return response def upload_aplus_image(self, destination_id, content, *, boundary): return self._request("uploadAplusImage", destination_id, {}, method="POST", boundary=boundary, image=content) def read(self, operation, *, sku=None, product_type=None): params = {"marketplaceIds": self.marketplace} if operation == "getListingsItem" and _text(sku) and sku not in {".", ".."} and product_type is None: path = "/listings/2021-08-01/items/" + self.seller + "/" + urllib.parse.quote(sku, safe="") params["includedData"] = "attributes,productTypes,summaries" elif operation == "getDefinitionsProductType" and sku is None: path = "/definitions/2020-09-01/productTypes/" + _name(product_type) params.update(sellerId=self.fields["seller_id"], requirements="LISTING", requirementsEnforced="ENFORCED", productTypeVersion="LATEST") else: raise ListingWriteFailure("read", "OperationRefused") return self._request(operation, path, params) def _patch(self, sku, body, *, boundary=None): if not _text(sku) or sku in {".", ".."}: raise ListingWriteFailure("patchListingsItem", "InvalidSKU") body = self._validate_patch(body) path = "/listings/2021-08-01/items/" + self.seller + "/" + urllib.parse.quote(sku, safe="") params = {"marketplaceIds": self.marketplace} if boundary is None: params["mode"] = "VALIDATION_PREVIEW" return self._request("patchListingsItem", path, params, body=body, boundary=boundary) def _validate_patch(self, body): return validate_patch(body, self.marketplace, schema=self._schemas.get( body.get("productType") if isinstance(body, dict) else None)) def schema(self, definition): cap = _schema_capability(definition) return self._request("downloadSchema", cap["url"], {}, schema=cap) def product_schema(self, product_type): product_type = _name(product_type) self._current() if product_type not in self._schemas: definition = self.read("getDefinitionsProductType", product_type=product_type) if (definition.get("productType") != product_type or definition.get("marketplaceIds") != [self.marketplace]): raise ListingWriteFailure("getDefinitionsProductType", "DefinitionScopeMismatch") raw = self.schema(definition) self._schemas[product_type] = details.DetailsSchema(product_type, self.marketplace, raw) return self._schemas[product_type] class ListingPublisher: """Use a trusted tenant runtime and a server-owned reader of exact per-listing approvals.""" def __init__(self, rt, approval_reader, *, connection_id=None, timeout=30): self.rt, self.tenant_key, self.approval_reader = rt, _tenant(rt), approval_reader self.transport = _Transport(rt, connection_id=connection_id, timeout=timeout) def read_item(self, sku): return self.transport.read("getListingsItem", sku=sku) def read_definition(self, product_type): return self.transport.read("getDefinitionsProductType", product_type=product_type) def read_schema(self, product_type): return self.transport.product_schema(product_type) def _binding(self, workflow, asin, sku, body): if _tenant(self.rt) != self.tenant_key or not _text(workflow) or not _text(asin) or not _text(sku): raise ListingWriteFailure("publish", "ListingIdentityRequired") body = json.loads(_json(body)) # Refuse unknown paths before a details patch may fetch its named product type schema. paths = {"/attributes/" + name for name in REPLACE_ATTRIBUTES} if (isinstance(body, dict) and isinstance(body.get("patches"), list) and all(isinstance(p, dict) and p.get("path") in paths for p in body["patches"]) and any(p.get("path", "").removeprefix("/attributes/") in DETAIL_ATTRIBUTES for p in body["patches"])): self.read_schema(body.get("productType")) return {"tenant_key": self.tenant_key, "workflow": workflow, "asin": asin, "sku": sku, "body": self.transport._validate_patch(body)} def _scope(self, binding): return {**binding, "connection_id": self.transport.connection_id, "region": self.transport.region, "marketplace_id": self.transport.marketplace, "seller_id": self.transport.fields["seller_id"]} def preview(self, workflow, asin, sku, body): """Persist the exact body's observed preview result without requiring the LIVE switch.""" binding = self._binding(workflow, asin, sku, body) scope = self._scope(binding) key = _hash(scope) _change(self.rt, lambda document: document["previews"].pop(key, None)) response = self.transport._patch(sku, binding["body"]) result = {"binding": scope, "body_sha256": _hash(binding["body"]), "status": response.get("status"), "at": time.time(), "response": response} stored = _change(self.rt, lambda document: document["previews"].update({key: result})) if stored["previews"].get(key) != result: raise ListingWriteFailure("preview", "PersistenceUnproven") return copy.deepcopy(result) def _valid_preview(self, document, binding): scope = self._scope(binding) preview = document["previews"].get(_hash(scope)) now = time.time() if (not isinstance(preview, dict) or preview.get("binding") != scope or preview.get("body_sha256") != _hash(binding["body"]) or preview.get("status") != "VALID" or type(preview.get("at")) not in (int, float) or not 0 <= now - preview["at"] <= PREVIEW_TTL): raise ListingWriteFailure("publish", "RecentIdenticalValidPreviewRequired") def _live_boundary(self, binding, approval_id, receipt=None): approved = read_approval(self.rt, self.approval_reader, approval_id, binding) document = _read(self.rt) self._valid_preview(document, binding) if receipt is not None and document["receipts"].get(receipt["id"]) != receipt: raise ListingWriteFailure("publish", "PendingReceiptRequired") if not writes_enabled(self.rt): raise ListingWriteFailure("publish", "WritesDisabled") return approved def _snapshot(self, binding): item = self.read_item(binding["sku"]) market = self.transport.marketplace summaries, types, attributes = item.get("summaries"), item.get("productTypes"), item.get("attributes") if (not isinstance(attributes, dict) or not isinstance(summaries, list) or not isinstance(types, list) or not any(isinstance(row, dict) and row.get("marketplaceId") == market and row.get("asin") == binding["asin"] for row in summaries) or not any(isinstance(row, dict) and row.get("marketplaceId") == market and row.get("productType") == binding["body"]["productType"] for row in types)): raise ListingWriteFailure("publish", "FreshListingIdentityRequired") return copy.deepcopy(attributes) def _reserve(self, receipt, binding): def reserve(document): if receipt["id"] in document["receipts"]: raise ListingWriteFailure("publish", "AlreadyReserved") identity = ("tenant_key", "workflow", "asin", "sku") if any(row.get("state") in {"pending", "unknown"} and all(row.get("binding", {}).get(key) == binding[key] for key in identity) for row in document["receipts"].values()): raise ListingWriteFailure("publish", "ReconciliationRequired") if document["writes_enabled"] is not True: raise ListingWriteFailure("publish", "WritesDisabled") self._valid_preview(document, binding) document["receipts"][receipt["id"]] = receipt stored = _change(self.rt, reserve) if stored["receipts"].get(receipt["id"]) != receipt: raise ListingWriteFailure("publish", "PersistenceUnproven") def _finish(self, pending, **outcome): receipt = {**pending, **outcome, "finished_at": time.time()} def finish(document): if document["receipts"].get(pending["id"]) != pending: raise ListingWriteFailure("publish", "ReceiptChanged") document["receipts"][pending["id"]] = receipt stored = _change(self.rt, finish) if stored["receipts"].get(pending["id"]) != receipt: raise ListingWriteFailure("publish", "PersistenceUnproven") return copy.deepcopy(receipt) def publish(self, workflow, asin, sku, body, *, approval_id): """Send once after a valid preview, returning an existing receipt on any later invocation.""" binding = self._binding(workflow, asin, sku, body) if not _text(approval_id): raise ListingWriteFailure("approve", "ApprovalRequired") identity = {key: value for key, value in binding.items() if key != "body"} key = _hash({**identity, "approval_id": approval_id}) previous = _read(self.rt)["receipts"].get(key) if previous is not None: if previous.get("binding") != self._scope(binding): raise ListingWriteFailure("publish", "ReservedApprovalMismatch") return copy.deepcopy(previous) approved = self._live_boundary(binding, approval_id) snapshot = self._snapshot(binding) pending = {"id": key, "binding": self._scope(binding), "approval_id": approval_id, "approved_by": approved["approved_by"], "body_sha256": _hash(binding["body"]), "prior_attributes": snapshot, "state": "pending", "sent": False, "at": time.time()} self._reserve(pending, binding) try: response = self.transport._patch(sku, binding["body"], boundary=lambda: self._live_boundary(binding, approval_id, pending)) except ListingWriteFailure as exc: self._finish(pending, state="unknown", failure_class=exc.failure_class) raise status = response.get("status") state = {"ACCEPTED": "accepted", "INVALID": "rejected"}.get(status, "unknown") return self._finish(pending, state=state, sent=state == "accepted", response=response) def publish_listing(rt, workflow, asin, sku, body, *, approval_id, approval_reader, connection_id=None): """Preview first, report disabled sending, or publish the identical approved patch once.""" publisher = ListingPublisher(rt, approval_reader, connection_id=connection_id) preview = publisher.preview(workflow, asin, sku, body) if preview["status"] != "VALID": return {"sent": False, "state": "invalid", "preview": preview} if not writes_enabled(rt): return {"sent": False, "state": "disabled", "preview": preview} return publisher.publish(workflow, asin, sku, body, approval_id=approval_id) class _OfflineFixture: def __init__(self): from types import SimpleNamespace self.key = "listing-fixture" self.data, self.requests, self.reads = {}, [], [] self.fail_read = self.fail_write = self.unclear = self.redirect = False self.preview_status = "VALID" self.before_live = None self.fields = {"seller_id": "fixture-seller", "marketplace_id": "MARKET1", "region": "na", "client_id": "fixture-client", "client_secret": "fixture-secret", "refresh_token": "fixture-refresh"} self.body = {"productType": "VASE", "patches": [{"op": "replace", "path": "/attributes/item_name", "value": [{"value": "fixture title", "language_tag": "en_US", "marketplace_id": "MARKET1"}]}]} self.approval = {"tenant_key": self.key, "workflow": "workflow-1", "asin": "ASIN1", "sku": "sku-1", "body": copy.deepcopy(self.body), "decision": "approved", "approved_by": "fixture-person"} self.admin = {"tenant": "loopable", "platform_admin": True, "username": "fixture-operator"} self.original = {"item_name": [{"value": "original", "marketplace_id": "MARKET1"}], "color": [{"value": "blue"}]} self.rt = SimpleNamespace(key=self.key, get=self.get, update=self.update) def get(self, name, fresh=False): self.reads.append((name, fresh)) if self.fail_read and name == STATE_KEY: raise OSError("fixture store unavailable") return copy.deepcopy(self.data.get(name)) def update(self, name, fn, flush): if self.fail_write: raise OSError("fixture persistence unavailable") if flush != "sync": raise AssertionError("synchronous persistence required") self.data[name] = copy.deepcopy(fn(copy.deepcopy(self.data.get(name)))) def reader(self, tenant, approval_id): if tenant != self.key or not approval_id: raise AssertionError("tenant approval reader") return copy.deepcopy(self.approval) def __enter__(self): from contextlib import ExitStack from types import SimpleNamespace from unittest.mock import patch from core import keychain from harness import amazon_client self.stack = ExitStack() self.stack.enter_context(patch.object(keychain, "default_connection_id", return_value="fixture-connection")) self.stack.enter_context(patch.object(keychain, "amazon_creds", side_effect=lambda *a, **k: copy.deepcopy(self.fields))) self.stack.enter_context(patch.object(amazon_client, "access_token", return_value="fixture-token")) self.stack.enter_context(patch.object(urllib.request, "build_opener", return_value=SimpleNamespace(open=self.wire))) self.stack.enter_context(patch.object(urllib.request, "urlopen", side_effect=AssertionError("real network forbidden"))) self.publisher = ListingPublisher(self.rt, self.reader) return self def __exit__(self, *args): return self.stack.__exit__(*args) def wire(self, request, timeout): import io self.requests.append(request) params = urllib.parse.parse_qs(urllib.parse.urlsplit(request.full_url).query, keep_blank_values=True) if "mode" in params and params["mode"] != ["VALIDATION_PREVIEW"]: raise AssertionError("unsupported listing PATCH mode") if self.redirect: raise urllib.error.HTTPError(request.full_url, 302, "fixture redirect", {}, io.BytesIO()) if request.method == "PATCH": if "mode" not in params: pending = list(self.data[STATE_KEY]["receipts"].values()) if not pending or pending[-1]["prior_attributes"] != self.original or pending[-1]["state"] != "pending": raise AssertionError("durable snapshot and pending receipt before wire") if self.unclear: raise TimeoutError("fixture unclear response") got = {"status": "ACCEPTED"} else: got = {"status": self.preview_status, "issues": []} elif "/definitions/" in request.full_url: got = {"productType": "VASE", "marketplaceIds": ["MARKET1"]} else: got = {"attributes": self.original, "summaries": [{"marketplaceId": "MARKET1", "asin": "ASIN1"}], "productTypes": [{"marketplaceId": "MARKET1", "productType": "VASE"}]} if self.before_live: self.before_live() response = io.BytesIO(_json(got)) response.status = 200 return response def preview(self): return self.publisher.preview("workflow-1", "ASIN1", "sku-1", self.body) def publish(self, approval_id="approval-1"): return self.publisher.publish("workflow-1", "ASIN1", "sku-1", self.body, approval_id=approval_id) def enable(self): return set_writes_enabled(self.rt, True, self.admin, "fixture approved switch instruction") def live_count(self): return sum(request.method == "PATCH" and "mode" not in urllib.parse.parse_qs(urllib.parse.urlsplit(request.full_url).query, keep_blank_values=True) for request in self.requests) def _refused(call): try: call() except ListingWriteFailure: return True return False def _selftest_refusals(): checks = {} with _OfflineFixture() as fixture: fixture.preview() checks["switch_off"] = _refused(fixture.publish) and fixture.live_count() == 0 checks["preview_with_switch_off"] = len(fixture.requests) == 1 for operation in ("putListingsItem", "deleteListingsItem", "createFeed"): before = len(fixture.requests) checks[operation] = (_refused(lambda: fixture.publisher.transport.read(operation)) and len(fixture.requests) == before) fixture.enable() fixture.body["patches"][0]["path"] = "/attributes/price" before = len(fixture.requests) checks["attribute_allowlist"] = _refused(fixture.preview) and len(fixture.requests) == before for case in ("no_preview", "stale_preview", "different_body", "different_approval", "media_host", "invalid_preview"): with _OfflineFixture() as fixture: fixture.enable() if case != "no_preview": fixture.preview() if case == "stale_preview": for row in fixture.data[STATE_KEY]["previews"].values(): row["at"] = time.time() - PREVIEW_TTL - 1 elif case == "different_body": fixture.body["patches"][0]["value"][0]["value"] = "changed" fixture.approval["body"] = copy.deepcopy(fixture.body) elif case == "different_approval": fixture.approval["body"]["patches"][0]["value"][0]["value"] = "not approved" elif case == "media_host": fixture.body["patches"] = [{"op": "replace", "path": "/attributes/main_product_image_locator", "value": [{"marketplace_id": "MARKET1", "media_location": "https://evil.example/image.jpg"}]}] elif case == "invalid_preview": fixture.preview_status = "INVALID" fixture.preview() before = len(fixture.requests) checks[case] = _refused(fixture.publish) and len(fixture.requests) == before return checks def _selftest_persistence(): checks = {} with _OfflineFixture() as fixture: flip = fixture.enable() checks["switch_audit"] = flip in fixture.data[STATE_KEY]["switch_history"] and bool(flip["words"]) fixture.preview() first = fixture.publish() checks["accepted_snapshot"] = (first["state"] == "accepted" and first["sent"] is True and first["prior_attributes"] == fixture.original and fixture.live_count() == 1) checks["accepted_no_resend"] = fixture.publish() == first and fixture.live_count() == 1 checks["fresh_reads"] = bool(fixture.reads) and all(fresh for _, fresh in fixture.reads) with _OfflineFixture() as fixture: fixture.enable() fixture.preview() fixture.unclear = True checks["unknown_failure"] = _refused(fixture.publish) and fixture.live_count() == 1 recovered = fixture.publish() checks["unknown_no_resend"] = recovered["state"] == "unknown" and fixture.live_count() == 1 checks["unknown_new_approval"] = _refused(lambda: fixture.publish("approval-2")) and fixture.live_count() == 1 for fault in ("fail_read", "fail_write"): with _OfflineFixture() as fixture: fixture.enable() fixture.preview() setattr(fixture, fault, True) checks[fault] = _refused(fixture.publish) and fixture.live_count() == 0 if fault == "fail_read": checks["switch_read_failure"] = writes_enabled(fixture.rt) is False with _OfflineFixture() as fixture: fixture.enable() fixture.preview() fixture.before_live = lambda: set_writes_enabled(fixture.rt, False, fixture.admin, "fixture revocation") checks["switch_boundary"] = _refused(fixture.publish) and fixture.live_count() == 0 return checks def selftest(): """Return focused offline behavior controls using in-memory stores and a provider double.""" checks = {**_selftest_refusals(), **_selftest_persistence()} with _OfflineFixture() as fixture: fixture.redirect = True checks["redirect_response"] = _refused(fixture.preview) and len(fixture.requests) == 1 checks["redirect_handler"] = _NoRedirect().redirect_request(None, None, 302, "", {}, "https://evil.example") is None before = len(fixture.requests) forged = urllib.request.Request(ENDPOINTS["na"] + "/unbound", method="PATCH", data=b"{}") checks["unbound_request"] = (_refused(lambda: fixture.publisher.transport._perform("patchListingsItem", forged)) and len(fixture.requests) == before) by = {"username": "tenant-admin", "role": "admin", "tenant": fixture.key} checks["platform_admin_only"] = _refused(lambda: set_writes_enabled(fixture.rt, True, by, "fixture instruction")) return {"selftest": "PASS" if all(checks.values()) else "FAIL", "checks": checks, "network": False, "store_writes": False} if __name__ == "__main__": import sys from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parents[1])) if sys.argv[1:] != ["--selftest"]: raise SystemExit("Only --selftest is supported. Use ListingPublisher from the trusted runtime.") result = selftest() print(json.dumps(result)) raise SystemExit(0 if result["selftest"] == "PASS" else 1)