Cross-Platform Support

/**
 * An attachment provider is responsible for making the Java attachment API available.
 */
public interface AttachmentProvider {
    /**
     * Attempts the creation of an accessor for a specific JVM's attachment API.
     * @return The accessor this attachment provider can supply for the currently running JVM
     */
    Accessor attempt();
    
    /**
     * The default attachment provider to be used.
     */
    AttachmentProvider DEFAULT = new Compound(
        ForModularizedVm.INSTANCE,
        ForJ9Vm.INSTANCE,
        ForStandardToolsJarVm.JVM_ROOT,
        ForStandardToolsJarVm.JDK_ROOT,
        ForStandardToolsJarVm.MACINTOSH,
        ForUserDefinedToolsJar.INSTANCE,
        ForEmulatedAttachment.INSTANCE
    );
}

/**
 * An attachment provider that locates the attach API directly from the system class loader,
 * as possible since introducing the Java module system via the jdk.attach module.
 */
enum ForModularizedVm implements AttachmentProvider;

/**
 * An attachment provider that locates the attach API directly from the system class loader
 * expecting an IBM J9 VM.
 */
enum ForJ9Vm implements AttachmentProvider;

/**
 * An attachment provider that is dependant on the existence of a tools.jar file on the local file system.
 */
enum ForStandardToolsJarVm implements AttachmentProvider {
    JVM_ROOT("../lib/tools.jar"),
    JDK_ROOT("lib/tools.jar"), 
    MACINTOSH("../Classes/classes.jar");
}

/**
 * An attachment provider that attempts to locate a tools.jar from a custom location set via a system property.
 */
enum ForUserDefinedToolsJar implements AttachmentProvider;

/**
 * An attachment provider that uses Byte Buddy's attachment API emulation. To use this feature, JNA is required.
 */
enum ForEmulatedAttachment implements AttachmentProvider;

/**
 * A compound attachment provider that attempts the attachment by delegation to other providers.
 */
class Compound implements AttachmentProvider;

/**
 * A process provider is responsible for providing the process id of the current VM.
 */
public interface ProcessProvider {
    /**
     * Resolves a process id for the current JVM.
     * @return The resolved process id
     */
    String resolve();
}

/**
 * Supplies the current VM's process id.
 */
enum ForCurrentVm implements ProcessProvider {
    INSTANCE;
}

/**
 * A process provider for a legacy VM that reads the process id from its JMX properties.
 * This strategy is only used prior to Java 9.
 */
protected enum ForLegacyVm implements ProcessProvider {
    INSTANCE;
}

/**
 * A process provider for a Java 9 capable VM with access to the introduced process API.
 */
protected static class ForJava9CapableVm implements ProcessProvider {
    /**
     * Attempts to create a dispatcher for a Java 9 VM and falls back to a legacy dispatcher
     * if this is not possible.
     */
    public static ProcessProvider make();
}

/**
 * An attachment evaluator is responsible for deciding if an agent can be attached from the current process.
 */
protected interface AttachmentTypeEvaluator {
    /**
     * Checks if the current VM requires external attachment for the supplied process id.
     * @param processId The process id of the process to which to attach
     * @return true if the current VM requires external attachment for the supplied process
     */
    boolean requiresExternalAttachment(String processId);
}

/**
 * A dispatcher for native operations being used for communication with an OpenJ9 virtual machine.
 */
public interface Dispatcher {
    String getTemporaryFolder(String processId);
    int pid();
    int userId();
    boolean isExistingProcess(int processId);
    int getOwnerIdOf(File file);
    void setPermissions(File file, int permissions);
    void incrementSemaphore(File directory, String name, boolean global, int count);
    void decrementSemaphore(File directory, String name, boolean global, int count);
    void chownFileToUser(File file, long userId);
}

/**
 * A connector implementation for a POSIX environment using JNA.
 */
class ForJnaPosixEnvironment implements Dispatcher;

/**
 * A connector implementation for a Windows environment using JNA.
 */
class ForJnaWindowsEnvironment implements Dispatcher;

import net.bytebuddy.agent.ByteBuddyAgent;
import net.bytebuddy.agent.ByteBuddyAgent.AttachmentProvider;

// Create custom attachment strategy prioritizing specific mechanisms
AttachmentProvider customProvider = new AttachmentProvider.Compound(
    AttachmentProvider.ForModularizedVm.INSTANCE,    // Java 9+ modules first
    AttachmentProvider.ForJ9Vm.INSTANCE,             // IBM J9 support
    AttachmentProvider.ForEmulatedAttachment.INSTANCE // JNA fallback
);

// Use custom provider for installation
Instrumentation instrumentation = ByteBuddyAgent.install(customProvider);

// Use custom provider for attachment
File agentJar = new File("my-agent.jar");
ByteBuddyAgent.attach(agentJar, "1234", customProvider);

import net.bytebuddy.agent.ByteBuddyAgent.AttachmentProvider;

// Try different tools.jar locations
AttachmentProvider toolsJarProvider = new AttachmentProvider.Compound(
    AttachmentProvider.ForStandardToolsJarVm.JDK_ROOT,    // Standard JDK location
    AttachmentProvider.ForStandardToolsJarVm.JVM_ROOT,    // JRE location
    AttachmentProvider.ForStandardToolsJarVm.MACINTOSH    // macOS location
);

// Set custom tools.jar location
System.setProperty("net.bytebuddy.agent.toolsjar", "/custom/path/tools.jar");
AttachmentProvider customToolsJar = AttachmentProvider.ForUserDefinedToolsJar.INSTANCE;

// Use tools.jar provider
Instrumentation instrumentation = ByteBuddyAgent.install(toolsJarProvider);

import net.bytebuddy.agent.ByteBuddyAgent.AttachmentProvider;

// Force JNA-based attachment (requires JNA on classpath)
AttachmentProvider jnaProvider = AttachmentProvider.ForEmulatedAttachment.INSTANCE;

try {
    Instrumentation instrumentation = ByteBuddyAgent.install(jnaProvider);
    System.out.println("JNA attachment successful");
} catch (IllegalStateException e) {
    if (e.getMessage().contains("JNA dependency")) {
        System.err.println("JNA library not available");
    } else {
        System.err.println("JNA attachment failed: " + e.getMessage());
    }
}

import net.bytebuddy.agent.ByteBuddyAgent.ProcessProvider;

// Use current VM process provider
ProcessProvider currentVM = ProcessProvider.ForCurrentVm.INSTANCE;
String currentPid = currentVM.resolve();
System.out.println("Current process ID: " + currentPid);

// Custom process provider implementation
ProcessProvider customProvider = new ProcessProvider() {
    @Override
    public String resolve() {
        // Custom logic for process resolution
        return System.getProperty("my.app.pid", "1234");
    }
};

// Use custom provider for installation
Instrumentation instrumentation = ByteBuddyAgent.install(customProvider);

import net.bytebuddy.agent.VirtualMachine;
import com.sun.jna.Platform;

if (Platform.isWindows()) {
    // Windows-specific attachment using named pipes
    VirtualMachine vm = VirtualMachine.ForHotSpot.attach("1234", 
        new VirtualMachine.ForHotSpot.Connection.ForJnaWindowsNamedPipe.Factory());
    
} else if (Platform.isSolaris()) {
    // Solaris-specific attachment using doors
    VirtualMachine vm = VirtualMachine.ForHotSpot.attach("1234",
        new VirtualMachine.ForHotSpot.Connection.ForJnaSolarisDoor.Factory(15, 100, TimeUnit.MILLISECONDS));
    
} else {
    // POSIX-based systems (Linux, macOS) using sockets
    VirtualMachine vm = VirtualMachine.ForHotSpot.attach("1234",
        VirtualMachine.ForHotSpot.Connection.ForJnaPosixSocket.Factory.withDefaultTemporaryFolder(15, 100, TimeUnit.MILLISECONDS));
}

import java.util.Locale;

// Detect JVM type for appropriate provider selection
String vmName = System.getProperty("java.vm.name", "").toUpperCase(Locale.US);

if (vmName.contains("J9")) {
    // Use OpenJ9-specific attachment
    VirtualMachine vm = VirtualMachine.ForOpenJ9.attach("1234");
} else {
    // Use HotSpot-compatible attachment
    VirtualMachine vm = VirtualMachine.ForHotSpot.attach("1234");
}

import net.bytebuddy.agent.ByteBuddyAgent;
import net.bytebuddy.agent.ByteBuddyAgent.AttachmentProvider;

// Try multiple providers with detailed error reporting
AttachmentProvider[] providers = {
    AttachmentProvider.ForModularizedVm.INSTANCE,
    AttachmentProvider.ForJ9Vm.INSTANCE,
    AttachmentProvider.ForStandardToolsJarVm.JDK_ROOT,
    AttachmentProvider.ForEmulatedAttachment.INSTANCE
};

Instrumentation instrumentation = null;
for (AttachmentProvider provider : providers) {
    try {
        instrumentation = ByteBuddyAgent.install(provider);
        System.out.println("Success with provider: " + provider.getClass().getSimpleName());
        break;
    } catch (IllegalStateException e) {
        System.out.println("Failed with provider " + provider.getClass().getSimpleName() + ": " + e.getMessage());
    }
}

if (instrumentation == null) {
    System.err.println("All attachment providers failed");
}

// Configure custom tools.jar location
System.setProperty("net.bytebuddy.agent.toolsjar", "/opt/jdk/lib/tools.jar");

// Enable diagnostic output
System.setProperty("net.bytebuddy.agent.attacher.dump", "/tmp/attachment.log");

// Allow self-attachment on Java 9+
System.setProperty("jdk.attach.allowAttachSelf", "true");