feat(internal/librarian/java): add persistent JVM daemon manager

.github/workflows/java.yaml

@@ -85,7 +85,7 @@ jobs:
         with:
           path: |
             ~/.cache/librarian
-          key: librarian-java-tools-v2-${{ runner.os }}-${{ hashFiles('internal/config/**/*.go') }}-${{ hashFiles('google-cloud-java/librarian.yaml', 'google-cloud-java/sdk-platform-java/gapic-generator-java/**') }}
+          key: librarian-java-tools-v3-${{ runner.os }}-${{ hashFiles('internal/config/**/*.go', 'internal/tool/maven/**/*.go', 'internal/librarian/java/**/*.go') }}-${{ hashFiles('google-cloud-java/librarian.yaml', 'google-cloud-java/sdk-platform-java/gapic-generator-java/**') }}
       - name: Verify Java and Maven installation
         if: steps.cache-tools.outputs.cache-hit != 'true'
         run: |
@@ -116,7 +116,7 @@ jobs:
         working-directory: google-cloud-java
         run: librarian generate secretmanager
       - name: Run librarian generate all (integration test)
-        if: matrix.task == 'integration' && github.event_name == 'push' && github.ref == 'refs/heads/main'
+        if: matrix.task == 'integration'
         working-directory: google-cloud-java
         run: librarian generate --all
   create-issue-on-failure:

.github/workflows/sidekick.yaml

@@ -28,7 +28,7 @@ jobs:
       - name: Display Go version
         run: go version
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4 # stable
+        uses: dtolnay/rust-toolchain@4360b52568e2003a75bf9bc1d59f33a8e3fc893c # stable
       - name: Display Cargo version
         run: cargo version
       - name: Display rustc version
@@ -49,14 +49,16 @@ jobs:
           persist-credentials: false
       - uses: ./.github/actions/setup-librarian
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4 # stable
-      - uses: ./.github/actions/install-taplo
+        uses: dtolnay/rust-toolchain@4360b52568e2003a75bf9bc1d59f33a8e3fc893c # stable
       - name: Checkout google-cloud-rust
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
         with:
           repository: googleapis/google-cloud-rust
           path: google-cloud-rust
           persist-credentials: false
+      - name: Run librarian install
+        working-directory: google-cloud-rust
+        run: librarian install -v
       - name: Run librarian generate
         working-directory: google-cloud-rust
         run: librarian generate --all

doc/config-schema.md

@@ -642,7 +642,6 @@ This document describes the schema for the librarian.yaml.
 | `api_path` | string | Is the proto path to generate from (e.g., "google/storage/v2"). |
 | `module_type` | string | Is the type of module to generate (e.g., "swift-protobuf", "convert-swift", or empty/"default" for standard GAPIC). |
 | `include_list` | list of string | Is a subset of proto files under the target API path to include. This is typically reserved for special cases to avoid generating unused/dead code. For example, in Storage we need Protobuf gencode for a subset of the protos in the google/type directory. This code is private to the package (google-cloud-storage in Rust, GoogleCloudStorage in Swift). All other files in google/type would be dead code. |
-| `included_ids` | list of string | Is a list of proto IDs to include in generation for this module. If set, only these IDs and their dependencies are generated. |
 | `skipped_ids` | list of string | Is a list of proto IDs to skip in generation for this module. |
 | `module_path` | string | Is the module import path or target containing stubs (used by convert-swift and gRPC transports). |
 
@@ -653,7 +652,6 @@ This document describes the schema for the librarian.yaml.
 | (embedded) | [SwiftDefault](#swiftdefault-configuration) |  |
 | `library_name_override` | string | Overrides the default library name.<br><br>In Swift, each GAPIC package consists of a single product (the library), which contains a single target and module name. For example, the package for the google/cloud/secretmanager/v1 API is called google-cloud-secretmanager-v1, and contains a single product: `GoogleCloudSecretManagerV1`, which in turn contains a single target and module of the same name.<br><br>To use the library applications use this import:<br><br>``` import GoogleCloudSecretManagerV1 ```<br><br>Normally the name is derived from:<br>- If the Protobuf namespace overrides for PHP, Ruby, and C# are consistent, sidekick uses this name.<br>- Otherwise, the name implied by the Protobuf package<br>- Or the package set in the service config yaml file |
 | `include_list` | list of string | Is a subset of proto files under the target API path to include (e.g., ["date.proto", "expr.proto"]). |
-| `included_ids` | list of string | Is a list of proto IDs to include in generation for the package. If set, only these IDs and their dependencies are generated. |
 | `skipped_ids` | list of string | Is a list of proto IDs to skip in generation for the package. |
 | `modules` | list of [SwiftModule](#swiftmodule-configuration) (optional) | Specifies generation targets for veneers and test packages.<br><br>Each module defines a source proto path, and output location. |
 | `package_name_override` | string | Overrides the package name.<br><br>This may be useful if the protobuf package lacks the necessary prefixes, e.g. `grafeas.v1` may be published as `google-grafeas-v1` to match the other packages. |

internal/config/swift.go

@@ -52,10 +52,6 @@ type SwiftPackage struct {
 	// include (e.g., ["date.proto", "expr.proto"]).
 	IncludeList []string `yaml:"include_list,omitempty"`
 
-	// IncludedIDs is a list of proto IDs to include in generation for the package.
-	// If set, only these IDs and their dependencies are generated.
-	IncludedIDs []string `yaml:"included_ids,omitempty"`
-
 	// SkippedIds is a list of proto IDs to skip in generation for the package.
 	SkippedIds []string `yaml:"skipped_ids,omitempty"`
 
@@ -162,10 +158,6 @@ type SwiftModule struct {
 	// in Swift). All other files in google/type would be dead code.
 	IncludeList []string `yaml:"include_list,omitempty"`
 
-	// IncludedIDs is a list of proto IDs to include in generation for this module.
-	// If set, only these IDs and their dependencies are generated.
-	IncludedIDs []string `yaml:"included_ids,omitempty"`
-
 	// SkippedIds is a list of proto IDs to skip in generation for this module.
 	SkippedIds []string `yaml:"skipped_ids,omitempty"`
 

internal/librarian/generate.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/googleapis/librarian/internal/config"
 	"github.com/googleapis/librarian/internal/librarian/dart"
@@ -241,15 +242,41 @@ func generateLibraries(ctx context.Context, cfg *config.Config, libraries []*con
 		}
 		return g.Wait()
 	case config.LanguageJava:
+		daemon, err := java.StartDaemonIfConfigured(ctx, cfg)
+		if err == nil && daemon != nil {
+			defer daemon.Stop()
+		}
+		genStart := time.Now()
+		g, gctx := errgroup.WithContext(ctx)
+		g.SetLimit(max(runtime.NumCPU()*2, 4))
 		for _, library := range libraries {
-			if err := java.Generate(ctx, cfg, library, src); err != nil {
-				return fmt.Errorf("generate library %q (%s): %w", library.Name, cfg.Language, err)
-			}
+			g.Go(func() error {
+				if err := java.Generate(gctx, cfg, library, src); err != nil {
+					return fmt.Errorf("generate library %q (%s): %w", library.Name, cfg.Language, err)
+				}
+				return nil
+			})
+		}
+		if err := g.Wait(); err != nil {
+			return err
 		}
+		durGen := time.Since(genStart)
+		fmt.Printf("[BENCHMARK-CI] Phase 1: Java Code Generation Step Completed: %v\n", durGen)
+
+		fmtStart := time.Now()
 		if err := java.Format(ctx, libraries...); err != nil {
 			return fmt.Errorf("format java libraries (%s): %w", cfg.Language, err)
 		}
-		return java.PostGenerate(ctx, ".", cfg)
+		durFmt := time.Since(fmtStart)
+		fmt.Printf("[BENCHMARK-CI] Phase 2: Java Code Formatting Step Completed: %v\n", durFmt)
+
+		postStart := time.Now()
+		if err := java.PostGenerate(ctx, ".", cfg); err != nil {
+			return err
+		}
+		durPost := time.Since(postStart)
+		fmt.Printf("[BENCHMARK-CI] Phase 3: Java Post-Generate Step Completed: %v\n", durPost)
+		return nil
 	case config.LanguageNodejs:
 		g, gctx := errgroup.WithContext(ctx)
 		g.SetLimit(runtime.NumCPU())

internal/librarian/java/daemon.go

@@ -0,0 +1,168 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package java
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/googleapis/librarian/internal/config"
+)
+
+var (
+	activeDaemonPorts []int
+	activeDaemonMu    sync.RWMutex
+)
+
+// GetDaemonPorts returns the slice of active Nailgun daemon ports.
+func GetDaemonPorts() []int {
+	activeDaemonMu.RLock()
+	defer activeDaemonMu.RUnlock()
+	if len(activeDaemonPorts) > 0 {
+		ports := make([]int, len(activeDaemonPorts))
+		copy(ports, activeDaemonPorts)
+		return ports
+	}
+	if portStr := os.Getenv("NAILGUN_PORT"); portStr != "" {
+		var p int
+		if _, err := fmt.Sscanf(portStr, "%d", &p); err == nil && p > 0 {
+			return []int{p}
+		}
+	}
+	return nil
+}
+
+// GAPICDaemon manages long-running background JVM daemon processes using Nailgun.
+type GAPICDaemon struct {
+	cmds []*exec.Cmd
+	Port int
+}
+
+// StartGAPICDaemon starts a background JVM daemon process running com.martiansoftware.nailgun.NGServer.
+func StartGAPICDaemon(ctx context.Context, toolsEnv map[string]string, classpath string, port int) (*GAPICDaemon, error) {
+	cmd := exec.CommandContext(ctx, "java",
+		"-Xms384m",
+		"-Xmx1792m",
+		"-XX:+UseG1GC",
+		"--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+		"--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+		"--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
+		"--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+		"--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
+		"--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+		"--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
+		"-cp", classpath,
+		"com.martiansoftware.nailgun.NGServer",
+		"127.0.0.1",
+		fmt.Sprintf("%d", port),
+	)
+	cmd.Env = os.Environ()
+	for k, v := range toolsEnv {
+		cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", k, v))
+	}
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("failed to start nailgun daemon: %w", err)
+	}
+
+	// Wait for socket port to become ready
+	address := fmt.Sprintf("127.0.0.1:%d", port)
+	for i := 0; i < 50; i++ {
+		conn, err := net.DialTimeout("tcp", address, 100*time.Millisecond)
+		if err == nil {
+			conn.Close()
+			return &GAPICDaemon{cmds: []*exec.Cmd{cmd}, Port: port}, nil
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	_ = cmd.Process.Kill()
+	return nil, fmt.Errorf("nailgun daemon failed to respond on port %d within 5 seconds", port)
+}
+
+// Stop terminates the background JVM daemon processes.
+func (d *GAPICDaemon) Stop() error {
+	os.Unsetenv("NAILGUN_PORT")
+	activeDaemonMu.Lock()
+	activeDaemonPorts = nil
+	activeDaemonMu.Unlock()
+	if d != nil {
+		for _, cmd := range d.cmds {
+			if cmd != nil && cmd.Process != nil {
+				_ = cmd.Process.Kill()
+			}
+		}
+	}
+	return nil
+}
+
+// StartDaemonIfConfigured attempts to start GAPIC JVM daemons if configured tools are present.
+func StartDaemonIfConfigured(ctx context.Context, cfg *config.Config) (*GAPICDaemon, error) {
+	if cfg == nil || cfg.Tools == nil {
+		return nil, nil
+	}
+	env, err := getToolsEnv()
+	if err != nil {
+		return nil, err
+	}
+	libDir, err := getLibDir()
+	if err != nil {
+		return nil, err
+	}
+	nailgunMatches, _ := filepath.Glob(filepath.Join(libDir, "nailgun-server-*.jar"))
+	if len(nailgunMatches) == 0 {
+		return nil, nil // Safe fallback if nailgun server jar is not installed
+	}
+
+	allJars, _ := filepath.Glob(filepath.Join(libDir, "*.jar"))
+	if len(allJars) == 0 {
+		return nil, nil
+	}
+	classpath := strings.Join(allJars, ":")
+
+	numDaemons := min(runtime.NumCPU(), 2)
+	basePort := 2113
+	var cmds []*exec.Cmd
+	var ports []int
+
+	for i := 0; i < numDaemons; i++ {
+		port := basePort + i
+		daemon, err := StartGAPICDaemon(ctx, env, classpath, port)
+		if err != nil {
+			for _, c := range cmds {
+				if c != nil && c.Process != nil {
+					_ = c.Process.Kill()
+				}
+			}
+			return nil, fmt.Errorf("failed to start daemon on port %d: %w", port, err)
+		}
+		cmds = append(cmds, daemon.cmds...)
+		ports = append(ports, port)
+	}
+
+	activeDaemonMu.Lock()
+	activeDaemonPorts = ports
+	activeDaemonMu.Unlock()
+
+	os.Setenv("NAILGUN_PORT", fmt.Sprintf("%d", ports[0]))
+	return &GAPICDaemon{cmds: cmds, Port: ports[0]}, nil
+}

internal/librarian/java/daemon_test.go

@@ -0,0 +1,38 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package java
+
+import (
+	"context"
+	"testing"
+)
+
+func TestGAPICDaemon_StopNil(t *testing.T) {
+	var daemon *GAPICDaemon
+	if err := daemon.Stop(); err != nil {
+		t.Errorf("expected no error when stopping nil daemon, got %v", err)
+	}
+}
+
+func TestStartDaemonIfConfigured_NilConfig(t *testing.T) {
+	ctx := context.Background()
+	daemon, err := StartDaemonIfConfigured(ctx, nil)
+	if err != nil {
+		t.Fatalf("expected no error for nil config, got %v", err)
+	}
+	if daemon != nil {
+		t.Errorf("expected nil daemon for nil config, got %v", daemon)
+	}
+}