git.roojs.org Git - roobuilder/blob - src/Palete/LanguageClientVala.vala

   1
   2 namespace Palete {
   3         public class LanguageClientVala : LanguageClient {
   4                 int countdown = 0;
   5                 protected bool initialized = false;
   6                 bool sent_shutdown = false;
   7                 uint change_queue_id = 0;
   8
   9
  10                 private bool _closed = false;
  11                 private bool closed {
  12                         get { return this._closed ; }
  13                         set {
  14                                 GLib.debug("closed has been set? to %s" , value ? "TRUE" : "FALSE" );
  15                                 this._closed = value;
  16                         }
  17                 }
  18                 private GLib.SubprocessLauncher launcher = null;
  19                 private GLib.Subprocess? subprocess = null;
  20                 private IOStream? subprocess_stream = null;
  21             public Jsonrpc.Client? jsonrpc_client = null;
  22
  23                 Gee.ArrayList<JsRender.JsRender> open_files;
  24                 private JsRender.JsRender? _change_queue_file = null;
  25                 private string change_queue_file_source = "";
  26
  27                 JsRender.JsRender? change_queue_file {
  28                         set {
  29                                 this.change_queue_file_source = value == null ? "" : value.toSource();
  30                                 this._change_queue_file = value;
  31                         }
  32                         get {
  33                                 return this._change_queue_file;
  34                         }
  35                 }
  36                 void startServer()
  37                 {
  38                         this.initProcess("/usr/bin/vala-language-server");
  39                 }
  40
  41
  42                 public LanguageClientVala(Project.Project project)
  43                 {
  44                         // extend versions will proably call initialize to start and connect to server.
  45                         base(project);
  46                         this.open_files = new   Gee.ArrayList<JsRender.JsRender>();
  47                         this.change_queue_id = GLib.Timeout.add_seconds(1, () => {
  48                                 if (this.change_queue_file == null) {
  49                                         return true;
  50                                 }
  51                                 this.countdown--;
  52                                 if (this.countdown < 0){
  53                                         this.document_change_force.begin(this.change_queue_file,  this.change_queue_file_source, (o, res) => {
  54                                                 this.document_change_force.end(res);
  55                                         });
  56                                         this.change_queue_file = null;
  57
  58                                 }
  59                                 return true;
  60                         });
  61                         this.startServer();
  62
  63                 }
  64
  65
  66                 public bool initProcess(string process_path)
  67                 {
  68                         this.onClose();
  69                         this.log(LanguageClientAction.LAUNCH, process_path);
  70                         GLib.debug("Launching %s", process_path);
  71                         this.launcher = new GLib.SubprocessLauncher (SubprocessFlags.STDIN_PIPE | SubprocessFlags.STDOUT_PIPE);
  72                         this.launcher.set_environ(GLib.Environ.get());
  73                         try {
  74
  75
  76                                 this.subprocess = launcher.spawnv ({ process_path });
  77
  78                                 this.subprocess.wait_async.begin( null, ( obj,res ) => {
  79                                         try {
  80                                                 this.subprocess.wait_async.end(res);
  81                                         } catch (GLib.Error e) {
  82                                                 this.log(LanguageClientAction.ERROR_START, e.message);
  83                                                 GLib.debug("subprocess startup error %s", e.message);
  84                                         }
  85                                         this.log(LanguageClientAction.EXIT, "process ended");
  86                                         GLib.debug("Subprocess ended %s", process_path);
  87                                         this.onClose();
  88
  89                                 });
  90                                 var input_stream = this.subprocess.get_stdout_pipe ();
  91                                 var output_stream = this.subprocess.get_stdin_pipe ();
  92
  93                                 if (input_stream is GLib.UnixInputStream && output_stream is GLib.UnixOutputStream) {
  94                                         // set nonblocking
  95                                         if (!GLib.Unix.set_fd_nonblocking(((GLib.UnixInputStream)input_stream).fd, true)
  96                                          || !GLib.Unix.set_fd_nonblocking (((GLib.UnixOutputStream)output_stream).fd, true))
  97                                          {
  98                                                 GLib.debug("could not set pipes to nonblocking");
  99                                                 this.onClose();
 100                                             return false;
 101                                     }
 102                             }
 103                             this.subprocess_stream = new GLib.SimpleIOStream (input_stream, output_stream);
 104                         this.accept_io_stream ( this.subprocess_stream);
 105                         } catch (GLib.Error e) {
 106                                 this.log(LanguageClientAction.ERROR_START, e.message);
 107                                 GLib.debug("subprocess startup error %s", e.message);
 108                                 this.onClose();
 109                                 return false;
 110                 }
 111             return true;
 112         }
 113         bool in_close = false;
 114                 public override void client_accepted (Jsonrpc.Client client)
 115                 {
 116                         if (this.jsonrpc_client == null) {
 117                                 this.jsonrpc_client = client;
 118
 119                                 GLib.debug("client accepted connection - calling init server");
 120                                 this.log(LanguageClientAction.ACCEPT, "client accepted");
 121
 122                                 this.jsonrpc_client.notification.connect((method, paramz) => {
 123                                         this.onNotification(method, paramz);
 124                                 });
 125
 126                                 this.jsonrpc_client.failed.connect(() => {
 127                                         this.log(LanguageClientAction.ERROR_RPC, "client failed");
 128                                         this.onClose();
 129
 130                                         GLib.debug("language server server has failed");
 131                                 });
 132
 133                                 this.initialize_server ();
 134                         }
 135
 136
 137                 }
 138
 139
 140                 public override   void  initialize_server()   {
 141                         try {
 142                                 Variant? return_value;
 143                                     this.jsonrpc_client.call (
 144                                     "initialize",
 145                                     this.buildDict (
 146                                         processId: new Variant.int32 ((int32) Posix.getpid ()),
 147                                         rootPath: new Variant.string (this.project.path),
 148                                         rootUri: new Variant.string (File.new_for_path (this.project.path).get_uri ())
 149                                     ),
 150                                     null,
 151                                     out return_value
 152                                 );
 153                                 GLib.debug ("LS replied with %s", Json.to_string (Json.gvariant_serialize (return_value), true));
 154                                 this.initialized = true;
 155                                 return;
 156                         } catch (GLib.Error e) {
 157                                 GLib.debug ("LS replied with error %s", e.message);
 158                                 this.onClose();
 159                         }
 160
 161                 }
 162                 void onClose()
 163                 {
 164                         if (this.in_close) {
 165                                 return;
 166                         }
 167                         if (this.launcher == null) {
 168                                 return;
 169                         }
 170                         this.in_close = true;
 171                         GLib.debug("onClose called");
 172
 173                         if (this.jsonrpc_client != null) {
 174                                 try {
 175                                         this.jsonrpc_client.close();
 176                                 } catch (GLib.Error e) {
 177                                         GLib.debug("rpc Error close error %s", e.message);
 178                                 }
 179                         }
 180                         if (this.subprocess_stream != null) {
 181                                 try {
 182                                         this.subprocess_stream.close();
 183                                 } catch (GLib.Error e) {
 184                                         GLib.debug("stream Error close  %s", e.message);
 185                                 }
 186                         }
 187                         if (this.subprocess != null) {
 188                                 this.subprocess.force_exit();
 189                         }
 190                         if (this.launcher != null) {
 191                                 this.launcher.close();
 192                         }
 193
 194                         this.launcher = null;
 195                         this.subprocess = null;
 196                         this.jsonrpc_client = null;
 197                         this.closed = true;
 198                         this.in_close = false;
 199                 }
 200
 201                 public async void restartServer()
 202                 {
 203                         this.startServer();
 204                         foreach(var f in this.open_files) {
 205                                 this.document_open(f);
 206                         }
 207                 }
 208
 209                 public bool isReady()
 210                 {
 211                         if (this.closed) {
 212                                 this.log(LanguageClientAction.RESTART,"closed is set - restarting");
 213                                 GLib.debug("server stopped = restarting");
 214                                 this.initialized = false;
 215                                 this.closed = false;
 216                                 GLib.MainLoop loop = new GLib.MainLoop ();
 217                                 this.restartServer.begin ((obj, async_res) => {
 218                                         this.restartServer.end(async_res);
 219                                         loop.quit ();
 220                                 });
 221                                 return false; // can't do an operation yet?
 222
 223                         }
 224
 225                         if (!this.initialized) {
 226                                 GLib.debug("Server has not been initialized");
 227                                 return false;
 228                         }
 229                         if (this.sent_shutdown) {
 230                                 GLib.debug("Server has been started its shutting down process");
 231                                 return false;
 232                         }
 233                         // restart server..
 234
 235
 236
 237                         return true;
 238                 }
 239
 240                 public void onNotification(string method, Variant? return_value)
 241                 {
 242                         switch (method) {
 243                                 case "textDocument/publishDiagnostics":
 244                                         GLib.debug("got notification %s : %s",  method , Json.to_string (Json.gvariant_serialize (return_value), true));
 245                                         this.onDiagnostic(return_value);
 246                                         return;
 247                                 default:
 248                                         break;
 249
 250                         }
 251                         GLib.debug("got notification %s : %s",  method , Json.to_string (Json.gvariant_serialize (return_value), true));
 252
 253                 }
 254
 255                 /***
 256
 257                 */
 258                 public void onDiagnostic(Variant? return_value)
 259                 {
 260                         GLib.debug ("LS replied with %s", Json.to_string (Json.gvariant_serialize (return_value), true));
 261                         var dg = Json.gobject_deserialize (typeof (Lsp.Diagnostics), Json.gvariant_serialize (return_value)) as Lsp.Diagnostics;
 262                         this.log(LanguageClientAction.DIAG, dg.filename);
 263                         var f = this.project.getByPath(dg.filename);
 264                         if (f == null) {
 265                                 //GLib.debug("no file %s", dg.uri);
 266                                 //this.project.updateErrorsforFile(null);
 267                                 return;
 268                         }
 269                         f.updateErrors( dg.diagnostics );
 270
 271
 272                 }
 273
 274                 public override void document_open (JsRender.JsRender file)
 275                 {
 276                         if (!this.isReady()) {
 277                                 return;
 278                         }
 279                         if (!this.open_files.contains(file)) {
 280                                 this.open_files.add(file);
 281                         }
 282
 283                         GLib.debug ("LS sent open");
 284                         try {
 285                                 this.jsonrpc_client.send_notification (
 286                                         "textDocument/didOpen",
 287                                         this.buildDict (
 288                                                 textDocument : this.buildDict (
 289                                                         uri: new Variant.string (file.to_url()),
 290                                                         languageId :  new Variant.string (file.language_id()),
 291                                                         version :  new GLib.Variant.uint64 ( (uint64) file.version),
 292                                                         text : new Variant.string (file.toSource())
 293                                                 )
 294                                         ),
 295                                         null
 296                                 );
 297                                 this.log(LanguageClientAction.OPEN, file.path);
 298                         } catch( GLib.Error  e) {
 299                                 this.log(LanguageClientAction.ERROR_RPC, e.message);
 300                                 this.onClose();
 301                                 GLib.debug ("LS sent open err %s", e.message);
 302                         }
 303
 304                 }
 305
 306                 public override  async void document_save (JsRender.JsRender file)
 307         {
 308                         if (!this.isReady()) {
 309                                 return;
 310                         }
 311                         // save only really flags the file on the server - to actually force a change update - we need to
 312                         // flag it as changed.
 313                         yield this.document_change_force(file, file.toSource());
 314
 315                         this.change_queue_file = null;
 316                         GLib.debug ("LS send save");
 317                          try {
 318
 319                                 var args = this.buildDict (
 320                                         textDocument : this.buildDict (    ///TextDocumentItem;
 321                                                 uri: new GLib.Variant.string (file.to_url()),
 322                                                 version :  new GLib.Variant.uint64 ( (uint64) file.version)
 323                                         )
 324                                 );
 325
 326                                 //GLib.debug ("textDocument/save send with %s", Json.to_string (Json.gvariant_serialize (args), true));
 327
 328
 329
 330                                   yield this.jsonrpc_client.send_notification_async  (
 331                                         "textDocument/didSave",
 332                                         args,
 333                                         null
 334                                 );
 335                                 this.log(LanguageClientAction.SAVE, file.path);
 336                         } catch( GLib.Error  e) {
 337                                 this.log(LanguageClientAction.ERROR_RPC, e.message);
 338                                 GLib.debug ("LS   save err %s", e.message);
 339                                 this.onClose();
 340                         }
 341
 342
 343         }
 344                 public override  void document_close (JsRender.JsRender file)
 345         {
 346                         if (!this.isReady()) {
 347                                 return;
 348                         }
 349                         this.change_queue_file = null;
 350
 351                         if (this.open_files.contains(file)) {
 352                                 this.open_files.remove(file);
 353                         }
 354                         this.log(LanguageClientAction.CLOSE, file.path);
 355                         GLib.debug ("LS send close");
 356                         try {
 357                                   this.jsonrpc_client.send_notification  (
 358                                         "textDocument/didChange",
 359                                         this.buildDict (
 360                                                 textDocument : this.buildDict (    ///TextDocumentItem;
 361                                                         uri: new GLib.Variant.string (file.to_url())
 362
 363                                                 )
 364                                         ),
 365                                         null
 366                                 );
 367                         } catch( GLib.Error  e) {
 368                                 this.log(LanguageClientAction.ERROR_RPC, e.message);
 369                                 GLib.debug ("LS close err %s", e.message);
 370                                 this.onClose();
 371                         }
 372
 373
 374         }
 375
 376
 377                 public override void document_change (JsRender.JsRender file )
 378                 {
 379                         if (this.change_queue_file != null && this.change_queue_file.path != file.path) {
 380                                 this.document_change_force.begin(this.change_queue_file, this.change_queue_file_source, (o, res) => {
 381                                         this.document_change_force.end(res);
 382                                 });
 383                         }
 384
 385                         this.countdown = 3;
 386                         this.change_queue_file = file;
 387
 388
 389
 390                 }
 391
 392
 393                 public override async void document_change_force (JsRender.JsRender file, string contents)
 394         {
 395                         if (!this.isReady()) {
 396                                 return;
 397                         }
 398
 399
 400                         GLib.debug ("LS send change");
 401                         var ar = new Json.Array();
 402                         var obj = new Json.Object();
 403                         obj.set_string_member("text", contents);
 404                         ar.add_object_element(obj);
 405                         var node = new Json.Node(Json.NodeType.ARRAY);
 406                         node.set_array(ar);
 407                         this.log(LanguageClientAction.CHANGE, file.path);
 408                          try {
 409                                 yield this.jsonrpc_client.send_notification_async (
 410                                         "textDocument/didChange",
 411                                         this.buildDict (
 412                                                 textDocument : this.buildDict (    ///TextDocumentItem;
 413                                                         uri: new GLib.Variant.string (file.to_url()),
 414                                                         version :  new GLib.Variant.uint64 ( (uint64) file.version)
 415                                                 ),
 416                                                 contentChanges : Json.gvariant_deserialize (node, null)
 417
 418                                         ),
 419                                         null
 420                                 );
 421                         } catch( GLib.Error  e) {
 422                                 this.log(LanguageClientAction.ERROR_RPC, e.message);
 423                                 GLib.debug ("LS change err %s", e.message);
 424                                 this.onClose();
 425                         }
 426
 427
 428         }
 429         // called by close window (on last window)...
 430                 public override  void exit () throws GLib.Error
 431                 {
 432                         if (!this.isReady()) {
 433
 434                                 return;
 435                         }
 436                         this.log(LanguageClientAction.TERM, "SEND exit");
 437
 438                           this.jsonrpc_client.send_notification (
 439                                 "exit",
 440                                 null,
 441                                 null
 442                         );
 443                         this.onClose();
 444
 445                 }
 446                 // not used currently..
 447                 public override async void shutdown () throws GLib.Error
 448                 {
 449                         if (!this.isReady()) {
 450                                 return;
 451                         }
 452                         this.log(LanguageClientAction.TERM, "SEND shutodwn");
 453                         this.sent_shutdown  = true;
 454                         Variant? return_value;
 455                         yield this.jsonrpc_client.call_async (
 456                                 "shutdown",
 457                                 null,
 458                                 null,
 459                                 out return_value
 460                         );
 461                         GLib.debug ("LS replied with %s", Json.to_string (Json.gvariant_serialize (return_value), true));
 462                 }
 463                 //public async  ??/symbol (string symbol) throws GLib.Error {
 464
 465                 // and now for the important styff..
 466
 467                 /*
 468
 469                 @triggerType 1 = typing or ctl-spac, 2 = tiggercharactres?  3= inside completion?
 470                 */
 471                  public override async Lsp.CompletionList?  completion(JsRender.JsRender file, int line, int offset , int triggerType = 1) throws GLib.Error
 472                  {
 473                         /* partial_result_token ,  work_done_token   context = null) */
 474                         GLib.debug("%s get completion %s @ %d:%d", this.get_type().name(),  file.relpath, line, offset);
 475
 476                         var ret = new Lsp.CompletionList();
 477
 478                     if (!this.isReady()) {
 479                         GLib.debug("completion - language server not ready");
 480                                 return ret;
 481                         }
 482                         // make sure completion has the latest info..
 483                         //if (this.change_queue_file != null && this.change_queue_file.path != file.path) {
 484                         //      this.document_change_real(this.change_queue_file, this.change_queue_file_source);
 485                         //      this.change_queue_file != null;
 486                         //}
 487                         this.log(LanguageClientAction.COMPLETE, "SEND complete  %s @ %d:%d".printf(file.relpath, line, offset) );
 488
 489                         Variant? return_value;
 490
 491                         var args = this.buildDict (
 492                                         context : this.buildDict (    ///CompletionContext;
 493                                                 triggerKind: new GLib.Variant.int32 (triggerType)
 494                                         //      triggerCharacter :  new GLib.Variant.string ("")
 495                                         ),
 496                                         textDocument : this.buildDict (    ///TextDocumentItem;
 497                                                 uri: new GLib.Variant.string (file.to_url()),
 498                                                 version :  new GLib.Variant.uint64 ( (uint64) file.version)
 499                                         ),
 500                                         position :  this.buildDict (
 501                                                 line :  new GLib.Variant.uint64 ( (uint) line) ,
 502                                                 character :  new GLib.Variant.uint64 ( uint.max(0,  (offset -1)))
 503                                         )
 504                                 );
 505
 506                         GLib.debug ("textDocument/completion send with %s", Json.to_string (Json.gvariant_serialize (args), true));
 507
 508                         yield this.jsonrpc_client.call_async (
 509                                 "textDocument/completion",
 510                                 args,
 511                                 null,
 512                                 out return_value
 513                         );
 514
 515
 516                         //GLib.debug ("LS replied with %s", Json.to_string (Json.gvariant_serialize (return_value), true));
 517                         var json = Json.gvariant_serialize (return_value);
 518
 519
 520                         if (json.get_node_type() == Json.NodeType.OBJECT) {
 521                                 ret = Json.gobject_deserialize (typeof (Lsp.CompletionList), json) as Lsp.CompletionList;
 522                                 this.log(LanguageClientAction.COMPLETE_REPLY, "GOT complete  %d items".printf(ret.items.size) );
 523                                 GLib.debug ("LS replied with Object");
 524                                 return ret;
 525                         }
 526
 527                         if (json.get_node_type() != Json.NodeType.ARRAY) {
 528                                 GLib.debug ("LS replied with %s", Json.to_string (Json.gvariant_serialize (return_value), true));
 529                                 this.log(LanguageClientAction.ERROR_REPLY, "GOT something else??");
 530                                 return ret;
 531
 532                         }
 533                         var ar = json.get_array();
 534
 535                         for(var i = 0; i < ar.get_length(); i++ ) {
 536                                 var add= Json.gobject_deserialize ( typeof (Lsp.CompletionItem),  ar.get_element(i)) as Lsp.CompletionItem;
 537                                 ret.items.add( add);
 538
 539                         }
 540                         this.log(LanguageClientAction.COMPLETE_REPLY, "GOT array %d items".printf(ret.items.size) );
 541                         GLib.debug ("LS replied with Array");
 542                         return ret;
 543
 544
 545                 }
 546                 //CompletionListInfo.itmems.parse_varient  or CompletionListInfo.parsevarient
 547                 public override async Gee.ArrayList<Lsp.DocumentSymbol> syntax (JsRender.JsRender file) throws GLib.Error
 548                  {
 549                         /* partial_result_token ,  work_done_token   context = null) */
 550                         GLib.debug("get syntax %s", file.relpath);
 551                         var ret = new Gee.ArrayList<Lsp.DocumentSymbol>();
 552                         //ret = null;
 553                     if (!this.isReady()) {
 554                                 return ret;
 555                         }
 556                         Variant? return_value;
 557                         yield this.jsonrpc_client.call_async (
 558                                 "textDocument/documentSymbol",
 559                                 this.buildDict (
 560
 561                                         textDocument : this.buildDict (    ///TextDocumentItem;
 562                                                 uri: new GLib.Variant.string (file.to_url()),
 563                                                 version :  new GLib.Variant.uint64 ( (uint64) file.version)
 564                                         )
 565
 566                                 ),
 567                                 null,
 568                                 out return_value
 569                         );
 570
 571
 572                         GLib.debug ("LS replied with %s", Json.to_string (Json.gvariant_serialize (return_value), true));
 573                         var json = Json.gvariant_serialize (return_value);
 574
 575
 576
 577                         var ar = json.get_array();
 578                         for(var i = 0; i < ar.get_length(); i++ ) {
 579                                 var add= Json.gobject_deserialize ( typeof (Lsp.DocumentSymbol),  ar.get_element(i)) as Lsp.DocumentSymbol;
 580                                 ret.add( add);
 581
 582                         }
 583                                 return ret ;
 584
 585
 586
 587                 }
 588
 589         }
 590
 591 }