150 lines
7.1 KiB
Python
150 lines
7.1 KiB
Python
"""Dormant NEW-only publisher boundary. Never invokes a publisher on its own."""
|
|
import hashlib
|
|
import json
|
|
import sqlite3
|
|
import urllib.request
|
|
import urllib.error
|
|
|
|
BASE = '/api/admin/seo-tracking'
|
|
|
|
|
|
class Blocked(RuntimeError):
|
|
pass
|
|
|
|
|
|
def digest(value):
|
|
return hashlib.sha256(json.dumps(value, sort_keys=True, ensure_ascii=False,
|
|
separators=(',', ':')).encode()).hexdigest()
|
|
|
|
|
|
class AdminTransport:
|
|
"""Use approved short-lived bearer supplied by caller; no retry or secret logging."""
|
|
def __init__(self, origin, bearer):
|
|
if not origin.startswith('https://'):
|
|
raise ValueError('HTTPS Admin origin required')
|
|
self.origin, self.bearer = origin.rstrip('/'), bearer
|
|
|
|
def __call__(self, method, path, body=None):
|
|
if path != BASE and not path.startswith(BASE + '/'):
|
|
raise ValueError('Research endpoints only')
|
|
request = urllib.request.Request(
|
|
self.origin + path, method=method,
|
|
data=None if body is None else json.dumps(body).encode(),
|
|
headers={'Authorization': 'Bearer ' + self.bearer,
|
|
'Content-Type': 'application/json'})
|
|
# Never forward Authorization to redirects, even same-origin redirects.
|
|
class NoRedirect(urllib.request.HTTPRedirectHandler):
|
|
def redirect_request(self, *args, **kwargs):
|
|
return None
|
|
try:
|
|
with urllib.request.build_opener(NoRedirect).open(request, timeout=30) as response:
|
|
return json.load(response)
|
|
except urllib.error.HTTPError as error:
|
|
raise Blocked('Admin HTTP ' + str(error.code)) from None
|
|
|
|
|
|
class Consumer:
|
|
def __init__(self, path, api):
|
|
self.path, self.api = path, api
|
|
with self.db() as db:
|
|
db.execute('CREATE TABLE IF NOT EXISTS runs (run TEXT PRIMARY KEY, state TEXT NOT NULL, finding TEXT, packet TEXT, draft_hash TEXT, review TEXT, blog TEXT)')
|
|
|
|
def db(self):
|
|
db = sqlite3.connect(self.path, timeout=10)
|
|
db.row_factory = sqlite3.Row
|
|
return db
|
|
|
|
def row(self, run):
|
|
with self.db() as db:
|
|
row = db.execute('SELECT * FROM runs WHERE run=?', (run,)).fetchone()
|
|
if row is None:
|
|
raise Blocked('Research must be saved before drafting')
|
|
return dict(row)
|
|
|
|
def prepare(self, run, research):
|
|
with self.db() as db:
|
|
try:
|
|
db.execute('INSERT INTO runs(run,state) VALUES (?,?)', (run, 'research_intent'))
|
|
except sqlite3.IntegrityError:
|
|
row = self.row(run)
|
|
if row['state'] == 'prepared':
|
|
return json.loads(row['packet'])
|
|
raise Blocked('Existing research intent/outcome requires reconciliation') from None
|
|
# Persist intent before POST: timeout must never cause duplicate research.
|
|
finding = self.api('POST', BASE, research)
|
|
packet = self.api('GET', BASE + '/' + finding['id'])
|
|
self.check_packet(packet)
|
|
with self.db() as db:
|
|
db.execute('UPDATE runs SET state=?,finding=?,packet=? WHERE run=?',
|
|
('prepared', packet['id'], json.dumps(packet), run))
|
|
return packet
|
|
|
|
@staticmethod
|
|
def check_packet(packet):
|
|
for key in ('version', 'feedbackVersion'):
|
|
if type(packet.get(key)) is not int or packet[key] < 0:
|
|
raise Blocked('Missing directive version')
|
|
if not isinstance(packet.get('id'), str) or not packet['id']:
|
|
raise Blocked('Missing finding identity')
|
|
if packet.get('ceoFeedback') is not None and not isinstance(packet['ceoFeedback'], str):
|
|
raise Blocked('Invalid directive')
|
|
|
|
def publish(self, run, packet, draft, review, publisher_create):
|
|
"""Caller must preserve existing ownership/QA/backup/quota/intent guards.
|
|
|
|
packet is the complete research/directive supplied to Content before drafting.
|
|
review is an independent exact-hash receipt, NOT semantic-compliance proof.
|
|
"""
|
|
row = self.row(run)
|
|
if row['packet'] is None or digest(json.loads(row['packet'])) != digest(packet):
|
|
raise Blocked('Packet differs from saved directive')
|
|
if row['state'] == 'linked':
|
|
return row['blog']
|
|
if row['state'] != 'prepared':
|
|
raise Blocked('In-flight/ambiguous action: reconcile, never recreate')
|
|
self.check_packet(packet)
|
|
if packet.get('ceoFeedback', None):
|
|
if not isinstance(review, dict) or not review.get('reviewer') or not review.get('evidence') or review.get('directiveHash') != digest(packet) or review.get('draftHash') != digest(draft):
|
|
raise Blocked('Exact directive/draft independent review evidence required')
|
|
with self.db() as db:
|
|
changed = db.execute('UPDATE runs SET state=?,draft_hash=?,review=? WHERE run=? AND state=?',
|
|
('claiming', digest(draft), json.dumps(review), run, 'prepared')).rowcount
|
|
if changed != 1:
|
|
raise Blocked('Another consumer owns action')
|
|
# Atomic Backend predicate rejects edits between fetch and claim.
|
|
claim = self.api('PATCH', BASE + '/' + packet['id'] + '/action',
|
|
dict(expectedVersion=packet['version'], feedbackVersion=packet['feedbackVersion'], actionId=run))
|
|
self.check_packet(claim)
|
|
if claim['feedbackVersion'] != packet['feedbackVersion']:
|
|
raise Blocked('Unexpected claim response')
|
|
with self.db() as db:
|
|
db.execute('UPDATE runs SET state=? WHERE run=?', ('publication_intent', run))
|
|
blog = publisher_create(draft) # No retry on exception or uncertain result.
|
|
if not isinstance(blog, str) or not blog:
|
|
raise Blocked('Missing blog identity; reconcile publication intent')
|
|
with self.db() as db:
|
|
db.execute('UPDATE runs SET state=?,blog=? WHERE run=?', ('created', blog, run))
|
|
self.reconcile_link(run)
|
|
return blog
|
|
|
|
def reconcile_link(self, run):
|
|
row = self.row(run)
|
|
if row['state'] == 'linked':
|
|
return row['blog']
|
|
if row['state'] != 'created' or not row['blog']:
|
|
raise Blocked('No confirmed created article; authenticated reconciliation required')
|
|
packet = json.loads(row['packet'])
|
|
current = self.api('GET', BASE + '/' + row['finding'])
|
|
self.check_packet(current)
|
|
if current['feedbackVersion'] != packet['feedbackVersion']:
|
|
raise Blocked('Directive changed after create: retain blog, independent repair required')
|
|
if current.get('blogId') not in (None, row['blog']):
|
|
raise Blocked('Finding already linked to another article')
|
|
if current.get('blogId') != row['blog']:
|
|
self.api('PATCH', BASE + '/' + row['finding'] + '/action',
|
|
dict(expectedVersion=current['version'], feedbackVersion=current['feedbackVersion'],
|
|
actionId=run, blogId=row['blog']))
|
|
with self.db() as db:
|
|
db.execute('UPDATE runs SET state=? WHERE run=?', ('linked', run))
|
|
return row['blog']
|