G/Pea/Pearch

   1 # proxy Search, plumbing updates -> elvis
   2 # could map all P to all Q and R,
   3 #  showing Q are sometimes recycling,
   4 #  any of them may zombie, Atime?
   5
   6 # this way for a J
   7 R.t != "Pearch" and throw "notinR"
   8 # out of Wayout/Pearch, both having %Inn=R
   9 $to = me.cbu(R,'Utilis');
  10 Rs&Inn = R;
  11 $Search = me&Rsc,to,'^^Inn';
  12 $upting = Searchs&_ting;
  13 !upting and throw "^^Inn!_ting", Search
  14 4s&Pearch = R;
  15
  16 # with of:w notifies via the Ghost of GhodigWap
  17 $Ghodig = 4s&Ghodig;
  18 Rs&Ghodigup = &QP{
  19     # from Ghodig/sub/...c&ready()
  20     # towards Qc&ready() via refresh
  21     # < many Q thing, many P thing...
  22     Qs&notsync = Qs&Want_Check = 1;
  23     Searchs&_ting(Q);
  24     Qs&P != P and ~>5 QP:
  25 }
  26 # Q updated or ready after async
  27 Rs&Qready = &Q{
  28     # potentially from ancient Qc&ready capturing ancient R
  29     #  zombies in Ghost/sub/...%Ps_Q,
  30     #  if you don't recycle your Qs
  31     #   unpacke will flatten it
  32     $r = me&yfuture,R;
  33     r != R and return rs&Qready && rs&Qready(Q);
  34     ac(R,'Qu',Q);
  35     # delay to allow batching
  36     $cb = me&sccb,R,'Quping',&{Rs&Qup()};
  37     G&delay,0.03,cb;
  38 };
  39 # Rs&Qu (Q updated) -> elvis to reality
  40 Rs&Qup = &{
  41     $Qz = delete Rs&Qu;
  42     !Qz and debugger
  43     $wake = [];
  44     each iQ Qz {
  45         $P = Qs&P;
  46         $s = Qc&s || Pc&s;
  47         #!s and throw "Qup!s"
  48         #~>6 WayQup: Qc&of, Q.t
  49         # tell by the args if it emits me
  50         $isme = Qc&of == 'wjs' &&
  51             ss&args.match(/\bme\b/);
  52         if (isme) {
  53             # < e to Pearch to set things up
  54             Rs&dropRcache();
  55             me&way,R,Q.t,{me};
  56             $meing = 1
  57         }
  58         else {
  59             wake.push(P)
  60         }
  61     }
  62     # redisable feta
  63     meing && me.hacks and me&hacks;
  64     if (wake.length) {
  65         $JRoms = [];
  66         each iP wake {
  67             # one P many Q, one of whom found the news
  68             each i,Pring Ps&Prings {
  69                 $J = me&yfuture,Prings&R;
  70                 JRoms.includes(J) and continue
  71                 # b-give it pairs of [Q,r] of interest (to %Yingu)
  72                 # < on the e, deeply, plan with
  73                 each in Prings&z {
  74                     # < check bunch of P are ready, wait max 2s
  75                     #   is a &ting but not &t interfacability,
  76                     #   not really being the client, but asking if its ready,
  77                     #   allowing time to Decode etc,
  78                     #    which has to be domed for error conductivity
  79                     # not el9 sense:
  80                     #!ns&P.c.s and ~>3 prematuero: ns&P.t
  81                     ns&P != P and continue
  82                     each iz ns&z {
  83                         $Q = zs&Q;
  84                         # W el=8 get here
  85                         Qs&dige == Ps&dige and continue
  86                         ac(J,'Intere',Cye(['Qupe',1,{},{Q,R:zs&R}]))
  87                     }
  88                 }
  89                 !Js&Intere and continue
  90                 JRoms.push(J);
  91             }
  92         }
  93         !JRoms.length and return
  94     }
  95    // and
  96     # elQups pack from Pearch, like elvoids from JRom
  97     $E = Cye(['elQups',8,{Qz,pack:R}])
  98
  99     each iJ JRoms {
 100         $tz = {};
 101         $Intere = Js&Intere;
 102         each iq Intere {
 103             $z = tz[qs&R.t] ||= [];
 104             z.push(q)
 105         }
 106         $names = [];
 107         each tz tz {
 108             names.push( (t != J.t ? qs&R.t : "")+"<-"
 109                 + uniq(z.map(q => qs&Q.c.of+':'+qs&Q.t)).join(',') )
 110         }
 111         names = J.t+": "+names.join(" ");
 112         ~>6 elQueps: names
 113
 114         $e = Cye(['elQup',1,{wake:J}]);
 115         Intere and ec&Intere = Intere
 116         ac(E,'z',e);
 117     }
 118
 119     if (!me&ioty,E) {
 120         # no more accurate path, send to main
 121         Es&generally = 1
 122         ~>6 Qup generally: Qz.length, ki(wake,2)
 123         Ec&wake = 4s&mainthing
 124         !Ec&wake and throw "!main"
 125     }
 126
 127     # (used to) unpause JRom since slow
 128     $N = 4s&unplugbugcb || [];
 129     4s&unplugbugcb = [];
 130     N.map(cb => cb());
 131
 132     4s&noelQups and return 4s&noelQups(E)
 133     me&elvis,R,E;
 134 }
 135 # maintain P -> r^^%Jrom%Pring/n%P/z%Q -> r
 136 Rs&Pring = &Q{
 137     $P = Qs&P;
 138     $r = Qy&R;
 139     !(P && r) and throw "noPr"
 140     $J = me.cbu(r,'JRom');
 141     !J and return ~>4 nonjrom: r.t, 'ting:'+Q.t
 142     $Pring = Js&Pring ||= Cye(["Pring:"+J.t,1])
 143     Prings&R = J;
 144     $N = Prings&z ||= [];
 145     # unique %Pring/n%P
 146     $n = N.filter(n => ns&P == P)[0];
 147     !n and n = Cye([Q.t,1]); N.push(n)
 148     ns&P = P;
 149     $N = ns&z ||= [];
 150     # they might reuse Q
 151     $z = N.filter(z => zs&Q == Q)[0];
 152     # or new Q with R future
 153     z ||= N.filter(z => z.t == R.t && me&yfuture,zs&R == r)[0];
 154     # or leak memory until futures flattened on Qup/tunneling
 155     !z and z = Cye([r.t,1]); N.push(z);
 156     zs&R = r;
 157     zs&Q = Q;
 158     ac(P,'Prings',Pring);
 159 }
 160 # drops Ring's task cache, recompiling me.ruv
 161 Rs&dropRcache = &{
 162     each tw A.5.I.w.y.tw {
 163         delete ws&makesI;
 164         delete ws&makesIw;
 165     }
 166     # and SCAing/Ying cache
 167     me.Yingminds = {};
 168     me.SCminds = {};
 169 }
 170 # bind Q-uestion to r-eason
 171 Rs&_ting = &Qr{
 172     !isC(Q) and throw "ting !C"
 173     # dispatch change, Q<->R:
 174     r and Qy&R = r
 175
 176     $already = Qc&ready;
 177     if (already) {
 178         # use it if we are !ready now
 179         #  if T.non (eg me&way !cb) default to:
 180     }
 181     # from out of time Pull_a completion
 182     #  per Q that we listened up
 183     Qc&ready = &CP{
 184         ~>3 Qcready: Q.t
 185         # !!!!
 186
 187         if (Ps&error && Ps&error.includes('nocompile') && Pc&of == 'wjs') {
 188             # gets stuck
 189             if (!Ps&error.includes(Ps&dige)) {
 190                 ~>3 becomes compilable: P.t
 191                 delete Ps&error
 192             }
 193             else {
 194                 ~>5 !!!! non-compilable: P.t
 195
 196             }
 197         }
 198         $cb = Qc&ready_also
 199         cb and cb(Q)
 200         $cb = Qc&ready_instead
 201         cb and cb(Q)
 202         else Rs&Qready(Q)
 203     }
 204
 205     $s = upting(Q);
 206     $P = Qs&P;
 207     !P and ~>5 upting!P: Q.t
 208     !P and return
 209     4s&Pringit and Rs&Pring(Q);
 210
 211     #!s and ~>5 upting!s: Q.t
 212     !s || !P and return
 213
 214     # as found things go by, listen them
 215     # c&of is containing, s&of is having
 216     # < GhodigWap know $t c&of=w|wjs|ghost are all one
 217     #   currently loads a w for every wjs|ghost subscribed...
 218     if (ss&of == 'w' && !Ps&listened) {
 219         # GhodigWap subscribes w.t
 220         Ghodigy&subscribe(s);
 221         # finds us here:
 222         i $Ghodig/sub/#Q.t/#R.t:s
 223         # < hist crunch,
 224         #   the w < Ps pulling dialect < Qs using it
 225         # the last P, Q will work for now
 226         $r = me&Rsc,ya,'R';
 227         ac(ya,'Ps',P,"Q",Q);
 228         yas&R = R;
 229         #yas&P && yas&P != P and debugger
 230         yas&P = P;
 231         yas&ein = &w{
 232             # dispatch ready() on all these:
 233             yas&Ps_Q.map(Q => ac(P,'readyingC',Q))
 234             # dispatching the request on one:
 235             Rs&Ghodigup(Q,P)
 236         };
 237         Ps&listened = 1;
 238     }
 239     # < use a new G&way that _tings
 240     #   its Wayc&chin is creating the sub!!
 241     # < Searches may trust upstream,
 242     return s
 243 }