use of org.spongepowered.plugin.PluginContainer in project SpongeCommon by SpongePowered.
the class FilteredPluginContainerParameter method parseValue.
@Override
public Optional<? extends PluginContainer> parseValue(final Parameter.Key<? super PluginContainer> parameterKey, final ArgumentReader.Mutable reader, final CommandContext.Builder context) throws ArgumentParseException {
final String id = reader.parseString();
final PluginContainer pluginContainer = this.validPluginContainers.get(id);
if (pluginContainer != null) {
return Optional.of(pluginContainer);
}
throw reader.createException(Component.text("Could not find valid plugin to refresh with ID \"" + id + "\""));
}
use of org.spongepowered.plugin.PluginContainer in project SpongeCommon by SpongePowered.
the class InventoryUtil method getPluginContainer.
public static PluginContainer getPluginContainer(Object inventory) {
// TODO maybe caching?
final PluginContainer container;
if (inventory instanceof CustomInventory) {
return ((CustomInventory) inventory).getPlugin();
}
if (inventory instanceof CarriedInventory) {
final Optional<?> carrier = ((CarriedInventory<?>) inventory).carrier();
if (carrier.isPresent()) {
inventory = carrier.get();
}
}
final Object base = inventory;
if (base instanceof BlockEntity) {
final ResourceKey key = Sponge.game().registry(RegistryTypes.BLOCK_ENTITY_TYPE).valueKey(((BlockEntity) base).type());
final String pluginId = key.namespace();
container = Sponge.pluginManager().plugin(pluginId).orElseThrow(() -> new AssertionError("Missing plugin " + pluginId + " for block " + key.namespace() + ":" + key.value()));
} else if (base instanceof Entity) {
final ResourceKey key = (ResourceKey) (Object) EntityType.getKey((EntityType<?>) ((Entity) base).type());
final String pluginId = key.namespace();
container = Sponge.pluginManager().plugin(pluginId).orElseGet(() -> {
SpongeCommon.logger().debug("Unknown plugin for [{}]", base);
return Launch.instance().minecraftPlugin();
});
} else if (base instanceof SpongeUserData) {
container = Launch.instance().minecraftPlugin();
} else {
container = Sponge.pluginManager().plugin(PlatformHooks.INSTANCE.getInventoryHooks().getModIdFromInventory(base.getClass())).orElseGet(() -> {
SpongeCommon.logger().debug("Unknown plugin for [{}]", base);
return Launch.instance().minecraftPlugin();
});
}
return container;
}
use of org.spongepowered.plugin.PluginContainer in project SpongeCommon by SpongePowered.
the class VanillaPluginManager method loadPlugins.
@SuppressWarnings("unchecked")
public void loadPlugins(final VanillaPluginPlatform platform) {
this.locatedResources.putAll(platform.getResources());
final Map<PluginCandidate<PluginResource>, PluginLanguageService<PluginResource>> pluginLanguageLookup = new HashMap<>();
final Map<PluginLanguageService<PluginResource>, PluginLoader<PluginResource, PluginContainer>> pluginLoaders = new HashMap<>();
// Initialise the plugin language loaders.
for (final Map.Entry<PluginLanguageService<PluginResource>, List<PluginCandidate<PluginResource>>> candidate : platform.getCandidates().entrySet()) {
final PluginLanguageService<PluginResource> languageService = candidate.getKey();
final String loaderClass = languageService.pluginLoader();
try {
pluginLoaders.put(languageService, (PluginLoader<PluginResource, PluginContainer>) Class.forName(loaderClass).getConstructor().newInstance());
} catch (final InstantiationException | IllegalAccessException | ClassNotFoundException | NoSuchMethodException | InvocationTargetException e) {
throw new RuntimeException(e);
}
candidate.getValue().forEach(x -> pluginLanguageLookup.put(x, languageService));
}
// Priority to platform plugins that will already exist here -- meaning the resolver will act upon them first
// and if someone decides to give a plugin an ID that is the same as a platform plugin, the resolver will effectively
// reject it.
final Set<PluginCandidate<PluginResource>> resources = new LinkedHashSet<>();
pluginLanguageLookup.keySet().stream().filter(x -> this.plugins.containsKey(x.metadata().id())).forEach(resources::add);
resources.addAll(pluginLanguageLookup.keySet());
final ResolutionResult<PluginResource> resolutionResult = DependencyResolver.resolveAndSortCandidates(resources, platform.logger());
final Map<PluginCandidate<PluginResource>, String> failedInstances = new HashMap<>();
final Map<PluginCandidate<PluginResource>, String> consequentialFailedInstances = new HashMap<>();
final ClassLoader launchClassloader = VanillaLaunch.instance().getClass().getClassLoader();
for (final PluginCandidate<PluginResource> candidate : resolutionResult.sortedSuccesses()) {
final PluginContainer plugin = this.plugins.get(candidate.metadata().id());
if (plugin != null) {
if (plugin instanceof VanillaDummyPluginContainer) {
continue;
}
// If we get here, we screwed up - duplicate IDs should have been detected earlier.
// Place it in the resolution result... it'll then get picked up in the big error message
resolutionResult.duplicateIds().add(candidate.metadata().id());
// but this is our screw up, let's also make a big point of it
final PrettyPrinter prettyPrinter = new PrettyPrinter(120).add("ATTEMPTED TO CREATE PLUGIN WITH DUPLICATE PLUGIN ID").centre().hr().addWrapped("Sponge attempted to create a second plugin with ID '%s'. This is not allowed - all plugins must have a unique " + "ID. Usually, Sponge will catch this earlier -- but in this case Sponge has validated two plugins with " + "the same ID. Please report this error to Sponge.", candidate.metadata().id()).add().add("Technical Details:").add("Plugins to load:", 4);
resolutionResult.sortedSuccesses().forEach(x -> prettyPrinter.add("*" + x.metadata().id(), 4));
prettyPrinter.add().add("Detected Duplicate IDs:", 4);
resolutionResult.duplicateIds().forEach(x -> prettyPrinter.add("*" + x, 4));
prettyPrinter.log(platform.logger(), Level.ERROR);
continue;
}
// This should work fine, we're sorted so all deps should be in place at this stage.
if (this.stillValid(candidate, consequentialFailedInstances)) {
final PluginLanguageService<PluginResource> languageService = pluginLanguageLookup.get(candidate);
final PluginLoader<PluginResource, PluginContainer> pluginLoader = pluginLoaders.get(languageService);
try {
final PluginContainer container = pluginLoader.loadPlugin(platform.getStandardEnvironment(), candidate, launchClassloader);
this.addPlugin(container);
this.containerToResource.put(container, candidate.resource());
} catch (final InvalidPluginException e) {
failedInstances.put(candidate, "Failed to construct: see stacktrace(s) above this message for details.");
e.printStackTrace();
}
}
}
resolutionResult.printErrorsIfAny(failedInstances, consequentialFailedInstances, platform.logger());
platform.logger().info("Loaded plugin(s): {}", this.sortedPlugins.stream().map(p -> p.metadata().id()).collect(Collectors.toList()));
}
use of org.spongepowered.plugin.PluginContainer in project SpongeCommon by SpongePowered.
the class CrashReportMixin_Vanilla method vanilla$addPluginsToEnvironment.
@Inject(method = "initDetails", at = @At("RETURN"))
private void vanilla$addPluginsToEnvironment(final CallbackInfo ci) {
this.systemDetails.setDetail("Plugins", () -> {
final StringBuilder result = new StringBuilder(64);
for (final PluginContainer container : Sponge.pluginManager().plugins()) {
final PluginMetadata metadata = container.metadata();
final String name = metadata.name().orElse(metadata.id());
result.append("\n\t\t").append(name).append(" (").append(metadata.id()).append(") ").append(metadata.version());
}
return result.toString();
});
}
use of org.spongepowered.plugin.PluginContainer in project SpongeCommon by SpongePowered.
the class PluginRepositorySource method loadPacks.
@Override
public void loadPacks(final Consumer<Pack> callback, final Pack.PackConstructor constructor) {
final VanillaPluginManager pluginManager = (VanillaPluginManager) Launch.instance().pluginManager();
// For each plugin, we create a pack. That pack might be empty.
for (final PluginContainer pluginContainer : pluginManager.plugins()) {
// The pack ID is prepended with "plugin-", as this will be the namespace we have to use a valid
// character as a separator
final String id = "plugin-" + pluginContainer.metadata().id();
final PluginResource resource = pluginManager.resource(pluginContainer);
// TODO: provide hook in the resource to return the file system for all resource types?
// Also -- can we fake a FileSystem for a non-Jar (needs thinking about)....
@Nullable Supplier<FileSystem> fileSystemSupplier = null;
if (resource instanceof JVMPluginResource) {
final String extension = FilenameUtils.getExtension(resource.path().getFileName().toString());
if ("jar".equals(extension)) {
fileSystemSupplier = ((JVMPluginResource) resource)::fileSystem;
}
}
final PluginPackResources packResources = new PluginPackResources(id, pluginContainer, fileSystemSupplier);
final Pack pack = Pack.create(id, true, () -> packResources, constructor, Pack.Position.BOTTOM, PackSource.DEFAULT);
((PackRepositoryBridge_Vanilla) this.repository).bridge$registerResourcePack(pluginContainer, pack);
callback.accept(pack);
}
}
Aggregations