asd

a

Author: kaspernielsen

modules/packed-incubator/packed-incubator-cli/src/main/java/app/packed/cli/CliCommandHandle.java

@@ -21,7 +21,7 @@
 import java.util.List;
 
 import app.packed.operation.OperationHandle;
-import app.packed.operation.OperationTemplate.Installer;
+import app.packed.operation.OperationInstaller;
 
 /**
  *
@@ -36,7 +36,7 @@ final class CliCommandHandle extends OperationHandle<CliCommandConfiguration> {
     /**
      * @param installer
      */
-    CliCommandHandle(Installer installer, CliNamespaceHandle namespace) {
+    CliCommandHandle(OperationInstaller installer, CliNamespaceHandle namespace) {
         super(installer);
         this.namespace = requireNonNull(namespace);
     }

modules/packed-incubator/packed-incubator-cli/src/main/java/app/packed/cli/CliExtension.java

@@ -26,6 +26,7 @@
 import app.packed.container.ContainerBuildLocal;
 import app.packed.container.ContainerConfiguration;
 import app.packed.container.ContainerHandle;
+import app.packed.container.ContainerInstaller;
 import app.packed.container.ContainerTemplate;
 import app.packed.container.Wirelet;
 import app.packed.extension.ExtensionHandle;
@@ -92,11 +93,11 @@ public CliNamespaceConfiguration namespace() {
         return ns().configuration(this);
     }
 
-    private ContainerTemplate.Installer<?> newContainer() {
+    private ContainerInstaller<?> newContainer() {
         if (isInApplicationLifetime()) {
             throw new UnsupportedOperationException("This method must be called from an extension in the application lifetime");
         }
-        ContainerTemplate.Installer<?> cb = base().newContainer(ContainerTemplate.GATEWAY);
+        ContainerInstaller<?> cb = base().newContainer(ContainerTemplate.GATEWAY);
         // CT.addEntryPointErrorMessage("Lifetime must container at least one entry point with CliCommand")
 
         return cb;

modules/packed-incubator/packed-incubator-cli/src/main/java/app/packed/cli/CliNamespaceHandle.java

@@ -21,6 +21,7 @@
 import app.packed.bean.BeanInstallationException;
 import app.packed.build.BuildActor;
 import app.packed.namespace.NamespaceHandle;
+import app.packed.namespace.NamespaceInstaller;
 import app.packed.namespace.NamespaceTemplate;
 import app.packed.operation.OperationTemplate;
 
@@ -35,7 +36,7 @@ final class CliNamespaceHandle extends NamespaceHandle<CliExtension, CliNamespac
     /** All the commands within the namespace. */
     final LinkedHashMap<String, CliCommandHandle> oldCommands = new LinkedHashMap<>();
 
-    CliNamespaceHandle(NamespaceTemplate.Installer installer) {
+    CliNamespaceHandle(NamespaceInstaller installer) {
         super(installer);
     }
 

modules/packed-incubator/packed-incubator-concurrent/src/main/java/app/packed/concurrent/DaemonOperationHandle.java

@@ -15,7 +15,7 @@
  */
 package app.packed.concurrent;
 
-import app.packed.operation.OperationTemplate.Installer;
+import app.packed.operation.OperationInstaller;
 import internal.app.packed.concurrent.ScheduledDaemon;
 
 /** An operation handle for a daemon operation. */
@@ -27,7 +27,7 @@ final class DaemonOperationHandle extends ThreadedOperationHandle<DaemonOperatio
 
     boolean useVirtual;
 
-    DaemonOperationHandle(Installer installer, ThreadNamespaceHandle namespace) {
+    DaemonOperationHandle(OperationInstaller installer, ThreadNamespaceHandle namespace) {
         super(installer, namespace);
     }
 

modules/packed-incubator/packed-incubator-concurrent/src/main/java/app/packed/concurrent/ScheduledOperationHandle.java

@@ -15,7 +15,7 @@
  */
 package app.packed.concurrent;
 
-import app.packed.operation.OperationTemplate.Installer;
+import app.packed.operation.OperationInstaller;
 import app.packed.util.Nullable;
 import internal.app.packed.concurrent.ScheduleImpl;
 import internal.app.packed.concurrent.ScheduledOperation;
@@ -31,7 +31,7 @@ public final class ScheduledOperationHandle extends ThreadedOperationHandle<Sche
     /**
      * @param installer
      */
-    public ScheduledOperationHandle(Installer installer, ThreadNamespaceHandle namespace) {
+    public ScheduledOperationHandle(OperationInstaller installer, ThreadNamespaceHandle namespace) {
         super(installer, namespace);
     }
 

modules/packed-incubator/packed-incubator-concurrent/src/main/java/app/packed/concurrent/ThreadNamespaceHandle.java

@@ -20,6 +20,7 @@
 import app.packed.bean.BeanConfiguration;
 import app.packed.build.BuildActor;
 import app.packed.namespace.NamespaceHandle;
+import app.packed.namespace.NamespaceInstaller;
 import app.packed.namespace.NamespaceTemplate;
 import internal.app.packed.concurrent.ExecutorConfiguration;
 import internal.app.packed.concurrent.ScheduledDaemon;
@@ -41,7 +42,7 @@ final class ThreadNamespaceHandle extends NamespaceHandle<ThreadExtension, Threa
      * @param installer
      *            the namespace installer
      */
-    protected ThreadNamespaceHandle(NamespaceTemplate.Installer installer) {
+    protected ThreadNamespaceHandle(NamespaceInstaller installer) {
         super(installer);
     }
 

modules/packed-incubator/packed-incubator-concurrent/src/main/java/app/packed/concurrent/ThreadedOperationHandle.java

@@ -19,7 +19,7 @@
 
 import app.packed.operation.OperationConfiguration;
 import app.packed.operation.OperationHandle;
-import app.packed.operation.OperationTemplate.Installer;
+import app.packed.operation.OperationInstaller;
 
 /**
  *
@@ -31,7 +31,7 @@ public class ThreadedOperationHandle<C extends OperationConfiguration> extends O
     /**
      * @param installer
      */
-    public ThreadedOperationHandle(Installer installer, ThreadNamespaceHandle namespace) {
+    public ThreadedOperationHandle(OperationInstaller installer, ThreadNamespaceHandle namespace) {
         super(installer);
         this.namespace = requireNonNull(namespace);
     }

modules/packed/src/main/java/app/packed/application/ApplicationHandle.java

@@ -60,7 +60,7 @@ public non-sealed class ApplicationHandle<A, C extends ApplicationConfiguration>
      * @param installer
      *            the installer for the application
      */
-    public ApplicationHandle(ApplicationTemplate.Installer<?> installer) {
+    public ApplicationHandle(ApplicationInstaller<?> installer) {
         PackedApplicationInstaller<?> inst = (PackedApplicationInstaller<?>) installer;
         this.application = inst.toHandle();
 

modules/packed/src/main/java/app/packed/application/ApplicationInstaller.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2008 Kasper Nielsen.
+ *
+ * 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
+ *
+ *     http://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 app.packed.application;
+
+import app.packed.application.repository.ApplicationLauncher;
+import app.packed.assembly.Assembly;
+import app.packed.container.Wirelet;
+import internal.app.packed.application.PackedApplicationInstaller;
+
+/** An installer for applications. */
+public sealed interface ApplicationInstaller<H extends ApplicationHandle<?, ?>> permits PackedApplicationInstaller {
+
+    /**
+     * Add the specified tags to the application.
+     *
+     * @param tags
+     *            the tags to add
+     * @return this configurator
+     * @see ApplicationMirror#componentTags()
+     * @see ApplicationHandle#componentTag(String...)
+     * @see ApplicationConfiguration#componentTag(String...)
+     */
+    ApplicationInstaller<H> componentTag(String... tags);
+
+    /**
+     * <p>
+     * The handle that is returned will be non-configurable.
+     *
+     * @param assembly
+     * @param wirelets
+     * @return
+     */
+    H install(Assembly assembly, Wirelet... wirelets);
+
+    default ApplicationLauncher<?> installAtRuntime(Assembly assembly, Wirelet... wirelets) {
+        throw new UnsupportedOperationException();
+    }
+
+    ApplicationInstaller<H> named(String name);
+
+    <T> ApplicationInstaller<H> setLocal(ApplicationBuildLocal<T> local, T value);
+}

modules/packed/src/main/java/app/packed/application/ApplicationRepository.java

@@ -16,45 +16,43 @@
 package app.packed.application;
 
 import java.util.Optional;
+import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 import app.packed.application.repository.ApplicationLauncher;
 import app.packed.application.repository.ManagedInstance;
 import app.packed.extension.BaseExtension;
 import app.packed.extension.BaseExtensionPoint;
+import internal.app.packed.application.PackedApplicationTemplate;
 import internal.app.packed.extension.ExtensionSetup;
 
 /**
  * An application repository that can be used to install applications at runtime or retrieve applications that were
  * installed at build-time.
  * <p>
- * This interface only supported unmanaged applications.
- * If you need to create managed applications uses {@link app.packed.application.guestmanager.ManagedApplicationRepository}.
+ * This interface only supported unmanaged applications. If you need to create managed applications uses
+ * {@link app.packed.application.guestmanager.ManagedApplicationRepository}.
  */
 public interface ApplicationRepository<I, H extends ApplicationHandle<I, ?>> {
 
-    Optional<H> handle(String name);
-
-    /**
-     * {@return a stream of all applications (represented by their application handle} that have been installed into the
-     * repository}
-     */
-    Stream<H> handles();
-
     Optional<ManagedInstance<I>> instance(String name);
 
     Stream<ManagedInstance<I>> instances();
 
     Optional<ApplicationLauncher<I>> launcher(String name);
 
+    /**
+     * {@return a stream of all applications (represented by their application handle} that have been installed into the
+     * repository}
+     */
     Stream<ApplicationLauncher<I>> launchers();
 
     /**
      * Creates an installer for a new application based on {@link #template()}.
      *
      * @return an installer for a new application
      */
-    ApplicationTemplate.Installer<H> newApplication();
+    ApplicationLauncher<I> install(Consumer<? super ApplicationInstaller<H>> installer);
 
     /** {@return the template that is used for all applications in this repository} */
     ApplicationTemplate<H> template();
@@ -64,19 +62,23 @@ public interface ApplicationRepository<I, H extends ApplicationHandle<I, ?>> {
     }
 
     // Syntes maaske vi skal tage H med.. Saa kan vi lave en god default key
-    static <A, H extends ApplicationHandle<A, ?>> ApplicationRepositoryConfiguration<A, H> install(Class<H> handleKind, ApplicationTemplate<H> template,
-            BaseExtension extension) {
-        return ApplicationRepositoryHandle.install(handleKind, template, ExtensionSetup.crack(extension), ExtensionSetup.crack(extension).container.assembly);
+    static <A, H extends ApplicationHandle<A, ?>> ApplicationRepositoryConfiguration<A, H> install(ApplicationTemplate<H> template, BaseExtension extension) {
+        // Hmm, maaske flyt tilbage til config, skal lave de samme checks for extension der laver det
+        PackedApplicationTemplate<H> t = (PackedApplicationTemplate<H>) template;
+        if (t.guestClass() == Void.class) {
+            throw new UnsupportedOperationException("Does not support application templates of Void.class guest type");
+        }
+        return ApplicationRepositoryHandle.install(t, ExtensionSetup.crack(extension), ExtensionSetup.crack(extension).container.assembly);
     }
 
-    static <A, H extends ApplicationHandle<A, ?>> ApplicationRepositoryConfiguration<A, H> provide(Class<H> handleKind, ApplicationTemplate<H> template,
-            BaseExtension extension) {
-        return install(handleKind, template, extension).provide();
+    static <A, H extends ApplicationHandle<A, ?>> ApplicationRepositoryConfiguration<A, H> provide(ApplicationTemplate<H> template, BaseExtension extension) {
+        return install(template, extension).provide();
     }
 
     // Shared with ContainerRepository
     interface Entry {
         boolean isBuild();
+
         boolean isLazy(); // Built on first usage
 
         // An application can be, NA, INSTALLING, AVAILABLE