Connect durable canvas runtime to canonical Foundry protocol
This commit is contained in:
@@ -1,6 +1,33 @@
|
||||
import { createBrowserStorage } from '../../src/lib/canvas-runtime/storage.ts';
|
||||
import { openProjectEngine } from '../../src/lib/canvas-runtime/engine.ts';
|
||||
import { createDocument, createRegistry, builtinComponents, applyChanges } from '../../src/lib/canvas-core/index.ts';
|
||||
import { createFoundryPersistence } from '../../src/lib/canvas-service/foundry.ts';
|
||||
|
||||
async function protocolRecoveryCase(name,assert){
|
||||
const root='10000000-0000-4000-8000-000000000001',workspace='10000000-0000-4000-8000-000000000003',account='10000000-0000-4000-8000-000000000004';
|
||||
const registry=createRegistry(builtinComponents()),document=createDocument(root,[{id:root,parent:null}],[{id:'a',incarnation:1,ownerCanvasId:root,componentId:'text',dataVersion:1,structure:'node',geometry:{x:0,y:0,width:260,height:200,rotation:0},data:{title:'a',text:''}}]);
|
||||
const calls=[],receipts=new Map();let server=document;
|
||||
const transport=async input=>{
|
||||
calls.push(input);
|
||||
if(input.method==='POST'){
|
||||
const batch=JSON.parse(input.body);server=applyChanges(server,batch.operations[0].changes);
|
||||
receipts.set(batch.request_id,{protocol_version:2,request_id:batch.request_id,status:'applied',operation_ids:batch.operations.map(operation=>operation.id),model:{documentFormatVersion:1,projectId:root,canvases:[...server.canvases.values()],elements:[...server.elements.values()],tombstones:{},versions:{[root]:2},complete:false,removedCanvasIds:[]}});
|
||||
return{status:502,body:{error:'upstream_timeout'}};
|
||||
}
|
||||
return{status:200,body:receipts.get(input.path.split('/').at(-1))};
|
||||
};
|
||||
const storage=createBrowserStorage({name:`${name}-protocol`}),persistence=createFoundryPersistence({workspaceId:workspace,rootId:root,registry,transport});
|
||||
const options={scope:{accountId:account,workspaceId:workspace,projectId:root},registry,document,versions:new Map([[root,1]]),storage,persistence};let engine;
|
||||
try{
|
||||
engine=await openProjectEngine(options);engine.editor.dispatch({type:'element.data',target:{id:'a',incarnation:1},patch:{title:'durable-v2'}});await engine.settle();
|
||||
const request=[...engine.getSnapshot().runtime.ledger.requests.values()][0];assert(request.protocolVersion===2,'new protocol metadata was replaced by a legacy default');await engine.close();
|
||||
engine=await openProjectEngine({...options,clock:{now:()=>Date.now()+100000,setTimer:(callback,delay)=>setTimeout(callback,delay),clearTimer:handle=>clearTimeout(handle)}});
|
||||
await new Promise(resolve=>setTimeout(resolve,10));await engine.settle();
|
||||
assert(calls.length===2&&calls[1].method==='GET','protocol 2 recovery must query the original request');
|
||||
assert(engine.getSnapshot().document.elements.get('a').data.title==='durable-v2'&&engine.getSnapshot().history.undo.length===1,'protocol recovery changed working content or duplicated history');
|
||||
const recovered=engine.getSnapshot().runtime.ledger.requests.get(request.id);assert(recovered.body===request.body&&recovered.outcome==='applied','protocol recovery rewrote request bytes or lost the receipt');
|
||||
}finally{await engine?.close();storage.close();indexedDB.deleteDatabase(`${name}-protocol`)}
|
||||
}
|
||||
|
||||
async function engineRecoveryCase(name, assert) {
|
||||
const scope = { accountId: 'account', workspaceId: 'workspace', projectId: 'project' }, registry = createRegistry(builtinComponents());
|
||||
@@ -96,6 +123,8 @@ export async function run() {
|
||||
results.push('journal gap is reported as corruption and never converted to an empty document');
|
||||
await engineRecoveryCase(name, assert);
|
||||
results.push('project engine reopens real IndexedDB with one history unit and the original request; ACK resolves without duplicate edit');
|
||||
await protocolRecoveryCase(name,assert);
|
||||
results.push('protocol 2 service adapter recovers exact frozen bytes and reconciles a lost ACK through real IndexedDB');
|
||||
return results;
|
||||
} finally { await leader?.release(); other?.close(); storage.close(); indexedDB.deleteDatabase(name); }
|
||||
}
|
||||
|
||||
@@ -48,6 +48,21 @@ test('can is pure and command handlers come from the component capability table'
|
||||
assert.equal(ids, 0); assert.strictEqual(editor.getSnapshot(), before);
|
||||
});
|
||||
|
||||
test('connection creation guards endpoint canvases and non-JSON envelopes reject without silent truncation',()=>{
|
||||
const document=createDocument('p',[{id:'root',parent:null},{id:'child',parent:{canvasId:'root',entryElementId:'f'}}],[node('a'),node('f','root','frame'),node('b','child')]);
|
||||
const editor=createEditor({registry:createRegistry(builtinComponents()),document});
|
||||
const edge={id:'e',incarnation:1,ownerCanvasId:'root',componentId:'connection',dataVersion:1,structure:'connection',data:{},source:{elementId:'a'},target:{elementId:'b'},path:null};
|
||||
const result=editor.dispatch({type:'element.create',element:edge});assert.equal(result.status,'applied');assert.deepEqual(editor.getSnapshot().operations.get(result.operationIds[0]).canvasIds,['child','root']);
|
||||
const before=editor.getSnapshot();assert.equal(editor.dispatch({type:'element.create',element:{...node('invalid'),unserializable:()=>42}}).status,'rejected');assert.strictEqual(editor.getSnapshot(),before);
|
||||
});
|
||||
|
||||
test('opaque JSON keys survive unrelated edits while unsafe field setters remain rejected',()=>{
|
||||
const future={...node('opaque'),componentId:'future.plugin',dataVersion:99,data:JSON.parse('{"constructor":{"retain":true},"__proto__":{"ordinary":"json data"}}')};
|
||||
const editor=setup([node('a'),future]);editor.dispatch({type:'element.data',target:target('a'),patch:{title:'edited'}});
|
||||
assert.deepEqual(editor.getSnapshot().document.elements.get('opaque').data,future.data);
|
||||
const before=editor.getSnapshot();assert.equal(editor.dispatch({type:'element.data',target:target('a'),patch:JSON.parse('{"__proto__":{"polluted":true}}')}).status,'rejected');assert.strictEqual(editor.getSnapshot(),before);assert.equal(Object.prototype.polluted,undefined);
|
||||
});
|
||||
|
||||
test('absent and explicit null are distinct history values; view selection follows element deletion', async () => {
|
||||
const editor = setup();
|
||||
editor.dispatch({ type: 'element.data', target: target('a'), patch: { optional: null } });
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
{
|
||||
"protocol_version": 2,
|
||||
"request_id": "90000000-0000-4000-8000-000000000002",
|
||||
"expected_versions": {
|
||||
"10000000-0000-4000-8000-000000000001": 3
|
||||
},
|
||||
"operations": [
|
||||
{
|
||||
"id": "90000000-0000-4000-8000-000000000001",
|
||||
"changes": [
|
||||
{
|
||||
"kind": "field",
|
||||
"target": {
|
||||
"id": "a",
|
||||
"incarnation": 1
|
||||
},
|
||||
"field": "data.title",
|
||||
"before": "a",
|
||||
"after": "renamed",
|
||||
"beforePresent": true,
|
||||
"afterPresent": true
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
/** Compile and exercise the actual Next route in a disposable frontend project. */
|
||||
import assert from 'node:assert/strict';
|
||||
import { createServer } from 'node:http';
|
||||
import { mkdtemp, mkdir, copyFile, writeFile, symlink, rm } from 'node:fs/promises';
|
||||
import { join, resolve } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { spawn } from 'node:child_process';
|
||||
import { setTimeout as pause } from 'node:timers/promises';
|
||||
|
||||
const source=resolve(import.meta.dirname,'../..'),directory=await mkdtemp(join(tmpdir(),'endoleap-proxy-check-')),received=[];
|
||||
const account='10000000-0000-4000-8000-000000000004',key='90000000-0000-4000-8000-000000000002';
|
||||
const responseBytes=' { "protocol_version":2, "request_id":"'+key+'", "status":"not-applied", "terminal":true, "error":"fixture_rejection", "extension":{"retained":true} }\n';
|
||||
const upstream=createServer(async(request,response)=>{
|
||||
const chunks=[];for await(const chunk of request)chunks.push(chunk);
|
||||
received.push({path:request.url,body:Buffer.concat(chunks),headers:request.headers});
|
||||
response.writeHead(request.url.endsWith('/model/operations')?409:200,{'Content-Type':'application/json'});
|
||||
response.end(request.url.endsWith('/model/operations')?responseBytes:'{"id":"fixture"}');
|
||||
});
|
||||
await new Promise(resolve=>upstream.listen(0,'127.0.0.1',resolve));
|
||||
const reservation=createServer();await new Promise(resolve=>reservation.listen(0,'127.0.0.1',resolve));const port=reservation.address().port;await new Promise(resolve=>reservation.close(resolve));
|
||||
let next,logs='',launchError;
|
||||
try{
|
||||
for(const filename of ['package.json','tsconfig.json','src/app/api/foundry/[...path]/route.ts','src/lib/canvas-response.ts','src/lib/session-cookie.ts']){
|
||||
const target=join(directory,filename);await mkdir(resolve(target,'..'),{recursive:true});await copyFile(join(source,filename),target);
|
||||
}
|
||||
await symlink(join(source,'node_modules'),join(directory,'node_modules'));
|
||||
await writeFile(join(directory,'src/app/layout.tsx'),'export default function Layout({children}:{children:React.ReactNode}){return <html><body>{children}</body></html>}');
|
||||
await writeFile(join(directory,'src/app/page.tsx'),'export default function Page(){return <main>Proxy verification fixture</main>}');
|
||||
next=spawn(process.execPath,[join(source,'node_modules/next/dist/bin/next'),'dev','--webpack','--hostname','127.0.0.1','--port',String(port)],{cwd:directory,detached:true,env:{...process.env,NEXT_TELEMETRY_DISABLED:'1',FOUNDRY_API_ORIGIN:`http://127.0.0.1:${upstream.address().port}`,NEXT_PUBLIC_FOUNDRY_PROJECT:'fixture'},stdio:['ignore','pipe','pipe']});
|
||||
next.stdout.on('data',chunk=>{logs=(logs+chunk).slice(-12000)});next.stderr.on('data',chunk=>{logs=(logs+chunk).slice(-12000)});next.on('error',error=>{launchError=error});
|
||||
let ready=false;
|
||||
for(let attempt=0;attempt<90;attempt++){
|
||||
if(launchError)throw launchError;if(next.exitCode!==null)throw new Error('Next exited during startup:\n'+logs);
|
||||
try{const response=await fetch(`http://127.0.0.1:${port}/api/foundry/profile`,{signal:AbortSignal.timeout(1500)});await response.text();if(response.status===200){ready=true;break}}catch{}
|
||||
await pause(250);
|
||||
}
|
||||
if(!ready)throw new Error('Next did not become ready:\n'+logs);
|
||||
const path='workspaces/10000000-0000-4000-8000-000000000003/materials/10000000-0000-4000-8000-000000000001/canvas/model/operations';
|
||||
// More than the generic 1 MiB proxy cap, below the canonical 5 MiB cap.
|
||||
const body=' {\n "protocol_version":2,"request_id":"'+key+'","fixture":"'+ 'x'.repeat(1100000)+'"\n} ';
|
||||
const response=await fetch(`http://127.0.0.1:${port}/api/foundry/${path}`,{method:'POST',body,headers:{'Content-Type':'application/json','Idempotency-Key':key,'X-Expected-Account':account,Cookie:'foundry_session=fixture-session',Origin:`http://127.0.0.1:${port}`},signal:AbortSignal.timeout(20000)});
|
||||
assert.equal(response.status,409);assert.equal(await response.text(),responseBytes);
|
||||
const request=received.find(item=>item.path.endsWith('/model/operations'));
|
||||
assert.ok(request);assert.equal(request.body.toString(),body);assert.equal(request.headers['idempotency-key'],key);assert.equal(request.headers['x-expected-account'],account);assert.equal(request.headers.authorization,'Bearer fixture-session');
|
||||
const before=received.length,invalid=await fetch(`http://127.0.0.1:${port}/api/foundry/${path}/unexpected/extra`,{signal:AbortSignal.timeout(10000)});await invalid.text();assert.equal(invalid.status,404);assert.equal(received.length,before);
|
||||
console.log('PASS actual Next proxy preserves frozen request bytes/key/account and raw terminal receipt above 1 MiB');
|
||||
console.log('PASS canonical route allowlist rejects unexpected paths without contacting the upstream');
|
||||
}finally{
|
||||
if(next?.pid){const exited=new Promise(resolve=>{if(next.exitCode!==null)resolve();else next.once('exit',resolve)});try{process.kill(-next.pid,'SIGTERM')}catch{}await Promise.race([exited,pause(3000)]);if(next.exitCode===null){try{process.kill(-next.pid,'SIGKILL')}catch{}}}
|
||||
upstream.closeAllConnections();await new Promise(resolve=>upstream.close(resolve));await rm(directory,{recursive:true,force:true,maxRetries:5});
|
||||
}
|
||||
@@ -98,3 +98,10 @@ test('missing frozen-request interpreter preserves bytes and claims while unrela
|
||||
assert.equal(restored.ledger().getSnapshot().requests.get(old.id).error, 'request_interpreter_unavailable');
|
||||
assert.equal(restored.scheduler.getClaims().get('canvas'), old.id); restored.scheduler.stop();
|
||||
});
|
||||
|
||||
test('permission/protocol rejection keeps unknown claims without an automatic retry loop', async()=>{
|
||||
const calls=[],state=setup({submit:async request=>{calls.push(request);return{outcome:'unresolved',blocked:true,error:'identity_changed'}}});
|
||||
state.add('create');state.scheduler.start();await state.scheduler.settle();
|
||||
assert.equal(state.ledger().getSnapshot().requests.get('request-1').outcome,'unresolved');assert.equal(state.scheduler.getClaims().size,1);assert.equal(state.timerCount(),0);
|
||||
await state.advance(10000);assert.equal(calls.length,1);state.scheduler.stop();
|
||||
});
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { readFile } from 'node:fs/promises';
|
||||
import { createDocument, createRegistry, builtinComponents } from '../../src/lib/canvas-core/index.ts';
|
||||
import { createLedger } from '../../src/lib/canvas-runtime/ledger.ts';
|
||||
import { createFoundryPersistence, createFoundryTransport, loadFoundryModel } from '../../src/lib/canvas-service/foundry.ts';
|
||||
|
||||
const root='10000000-0000-4000-8000-000000000001',child='10000000-0000-4000-8000-000000000002',workspace='10000000-0000-4000-8000-000000000003',account='10000000-0000-4000-8000-000000000004';
|
||||
const operationId='90000000-0000-4000-8000-000000000001',requestId='90000000-0000-4000-8000-000000000002';
|
||||
const registry=createRegistry(builtinComponents());
|
||||
const node=(id,owner=root)=>({id,incarnation:1,ownerCanvasId:owner,componentId:'text',dataVersion:1,structure:'node',data:{title:id,text:'preserved'},geometry:{x:0,y:0,width:260,height:200,rotation:0}});
|
||||
const a=node('a'),f={...node('f'),componentId:'frame'},future={...node('future',child),componentId:'plugin.future',dataVersion:9,data:{custom:{keep:[1,'x']}},extension:{retained:true}};
|
||||
const canvases=[{id:root,parent:null},{id:child,parent:{canvasId:root,entryElementId:'f'}}];
|
||||
const document=createDocument(root,canvases,[a,f,future]);
|
||||
const snapshot={revision:1,rootRevision:1,document,history:{undo:[],redo:[],entries:new Map()},operations:new Map(),runtime:{acknowledged:document,versions:new Map([[root,3],[child,7]]),ledger:createLedger().getSnapshot(),receipts:new Map(),conflicts:new Map()}};
|
||||
const intent={id:operationId,operationType:'document.change',operationSchemaVersion:1,sequence:1,origin:'user',canvasIds:[root],dependencies:[],changes:[{kind:'field',target:{id:'a',incarnation:1},field:'data.title',before:'a',after:'renamed',beforePresent:true,afterPresent:true}]};
|
||||
const chunk=(complete=true)=>({documentFormatVersion:1,projectId:root,canvases:complete?canvases:[canvases[0]],elements:complete?[a,f,future]:[{...a,data:{...a.data,title:'renamed'}},f],tombstones:{},versions:complete?{[root]:3,[child]:7}:{[root]:4},complete,removedCanvasIds:[]});
|
||||
function setup(transport=async()=>({status:200,body:{protocol_version:2,request_id:requestId,status:'applied',operation_ids:[operationId],model:chunk(false)}})){
|
||||
const port=createFoundryPersistence({workspaceId:workspace,rootId:root,registry,transport});
|
||||
const compiled=port.compile(intent,requestId,snapshot),ledger=createLedger();ledger.add(intent,{a:'exists'});
|
||||
const request=ledger.freeze({id:requestId,operationIds:[operationId],...compiled});return{port,request,compiled};
|
||||
}
|
||||
|
||||
test('initial model read is explicit about migration/coverage and owns opaque records',async()=>{
|
||||
const calls=[];
|
||||
const required=await loadFoundryModel(async request=>{calls.push(request);return{status:409,body:{error:'canonical_migration_required',document_format_version:1,root_id:root,source_versions:{[root]:1}}}},workspace,root,registry);
|
||||
assert.equal(required.status,'migration-required');assert.equal(required.sourceVersions.get(root),1);assert.equal(calls[0].method,'GET');
|
||||
const source=chunk(),loaded=await loadFoundryModel(async()=>({status:200,body:{model:source}}),workspace,child,registry);
|
||||
assert.equal(loaded.document.projectId,root);assert.deepEqual(loaded.document.elements.get('future'),future);
|
||||
assert.equal(Object.isFrozen(source.elements[0]),false);source.elements[0]={...a,data:{title:'caller mutation',text:''}};
|
||||
assert.equal(loaded.document.elements.get('a').data.title,'a');
|
||||
await assert.rejects(()=>loadFoundryModel(async()=>({status:200,body:{model:chunk(false)}}),workspace,root,registry),/incomplete_initial_model/);
|
||||
});
|
||||
|
||||
test('compiler freezes protocol 2 conditional changes and transports the exact original bytes',async()=>{
|
||||
const calls=[],{port,request,compiled}=setup(async input=>{calls.push(input);return{status:200,body:{protocol_version:2,request_id:requestId,status:'applied',operation_ids:[operationId],model:chunk(false)}}});
|
||||
assert.equal(compiled.protocolVersion,2);assert.equal(request.protocolVersion,2);
|
||||
const body=JSON.parse(request.body);assert.deepEqual(body.operations,[{id:operationId,changes:intent.changes}]);assert.equal(Object.hasOwn(body,'document'),false);
|
||||
assert.deepEqual(body,JSON.parse(await readFile(new URL('./fixtures/foundry-model-operation-v2.json',import.meta.url),'utf8')));
|
||||
const originalBytes=' \n'+request.body+' ',frozen={...request,body:originalBytes};
|
||||
assert.equal((await port.submit(frozen,new AbortController().signal)).outcome,'applied');
|
||||
assert.equal(calls[0].body,originalBytes);assert.equal(calls[0].requestId,requestId);
|
||||
await port.query(frozen,new AbortController().signal);assert.equal(calls[1].method,'GET');assert.equal(calls[1].body,undefined);assert.ok(calls[1].path.endsWith('/'+requestId));
|
||||
});
|
||||
|
||||
test('only explicit identity-matched terminal proof is zero-write; bare 4xx stays unresolved and blocked',async()=>{
|
||||
for(const [response,outcome,blocked]of[
|
||||
[{status:409,body:{protocol_version:2,request_id:requestId,status:'not-applied',terminal:true,error:'version_conflict'}},'not-applied',false],
|
||||
[{status:409,body:{error:'idempotency_conflict'}},'unresolved',true],
|
||||
[{status:403,body:{error:'forbidden'}},'unresolved',true],
|
||||
[{status:404,body:{status:'unknown',request_id:requestId}},'unresolved',false],
|
||||
]){
|
||||
const{port,request}=setup(async()=>response);const status=await port.query(request,new AbortController().signal);
|
||||
assert.equal(status.outcome,outcome);assert.equal(!!status.blocked,blocked);
|
||||
}
|
||||
});
|
||||
|
||||
test('partial canonical receipts replace participants and retain unrelated future components and versions',async()=>{
|
||||
const{port,request}=setup();const status=await port.submit(request,new AbortController().signal),proposal=port.canonical(request,status,snapshot);
|
||||
assert.equal(proposal.document.elements.get('a').data.title,'renamed');assert.deepEqual(proposal.document.elements.get('future'),future);assert.equal(proposal.versions.get(child),7);assert.equal(proposal.versions.get(root),4);
|
||||
const broken=structuredClone(status);broken.canonical.model.versions={[root]:4,[child]:8};
|
||||
assert.throws(()=>port.canonical(request,broken,snapshot),/invalid_canonical_response|receipt_coverage_mismatch/);
|
||||
const wrong=structuredClone(status);wrong.canonical.model.elements.push({...future,ownerCanvasId:root});
|
||||
assert.throws(()=>port.canonical(request,wrong,snapshot),/canonical_scope_mismatch/);
|
||||
assert.equal(snapshot.runtime.acknowledged.elements.get('a').data.title,'a');
|
||||
});
|
||||
|
||||
test('missing logical coverage and altered frozen metadata do not masquerade as successful requests',async()=>{
|
||||
const calls=[],{port,request}=setup(async input=>{calls.push(input);return{status:200,body:{protocol_version:2,request_id:requestId,status:'applied',operation_ids:[],model:chunk(false)}}});
|
||||
const incomplete=await port.submit(request,new AbortController().signal);assert.equal(incomplete.outcome,'unresolved');assert.equal(incomplete.blocked,true);assert.equal(incomplete.error,'receipt_coverage_mismatch');
|
||||
const corrupt=await port.submit({...request,expectedVersions:{[root]:99}},new AbortController().signal);
|
||||
assert.equal(corrupt.blocked,true);assert.equal(calls.length,1);assert.equal(corrupt.error,'frozen_request_contract_mismatch');
|
||||
});
|
||||
|
||||
test('new canvases carry an explicit absent version without confusing format/protocol/document clocks',()=>{
|
||||
const canvas='10000000-0000-4000-8000-000000000005',{port}=setup();
|
||||
const create={...intent,canvasIds:[root,canvas],changes:[{kind:'canvas',id:canvas,before:null,after:{id:canvas,parent:{canvasId:root,entryElementId:'f'}}}]};
|
||||
const compiled=port.compile(create,requestId,snapshot);assert.equal(compiled.expectedVersions[canvas],0);assert.equal(compiled.expectedVersions[root],3);assert.equal(compiled.protocolVersion,2);
|
||||
const ledger=createLedger();ledger.add(create,{});assert.equal(ledger.freeze({id:requestId,operationIds:[operationId],...compiled}).expectedVersions[canvas],0);
|
||||
});
|
||||
|
||||
test('browser transport fences identity changes and never rebuilds a frozen body',async()=>{
|
||||
let current=true;const calls=[];
|
||||
const transport=createFoundryTransport({accountId:account,isCurrentIdentity:()=>current,fetch:async(url,init)=>{calls.push([url,init]);return new Response('{"status":"unknown"}',{status:404,headers:{'Content-Type':'application/json'}})}});
|
||||
await transport({path:'fixture',method:'POST',requestId,body:' {"literal":"bytes"} '});
|
||||
assert.equal(calls[0][1].headers['X-Expected-Account'],account);assert.equal(calls[0][1].body,' {"literal":"bytes"} ');assert.equal(calls[0][1].headers['Idempotency-Key'],requestId);
|
||||
current=false;await assert.rejects(()=>transport({path:'fixture',method:'GET'}),/identity_changed/);assert.equal(calls.length,1);
|
||||
const late=createFoundryTransport({accountId:account,isCurrentIdentity:()=>current,fetch:async()=>{current=false;return new Response('{}')}});current=true;
|
||||
await assert.rejects(()=>late({path:'fixture',method:'GET'}),/identity_changed/);
|
||||
});
|
||||
Reference in New Issue
Block a user