wer

s

Author: kaspernielsen

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

@@ -117,6 +117,7 @@ public final C configuration() {
      * @throws IllegalStateException
      *             if the application was build with {@link BuildGoal#IMAGE}.
      */
+    // Tror jeg fjerner den her... BaseImage er kun noget man bruger ved rødder tænker jeg???
     public final BaseImage<A> image() {
         BaseImage<A> i = image;
         if (i == null) {
@@ -141,10 +142,18 @@ public final boolean isConfigurable() {
      * @param wirelets
      *            optional wirelets
      * @return the application instance
+     *
+     * @throws UnsupportedOperationException
+     *             if managed and not a root container\
+     * @see #launch(GuestManager, Wirelet...)
      */
     @SuppressWarnings("unchecked")
+    // Tror den her bliver hidden
+    // Problemet er at den er statisk. Der er ingen runtime information.
+    // Hvis vi har startet 23 applikationer, faar de stadig ingen input
     public final A launch(RunState state, Wirelet... wirelets) {
         requireNonNull(state, "state is null");
+        // TODO fix
         if (!application.completedBuilding) {
             throw new IllegalStateException("Application has not finished building");
         }

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

@@ -9,6 +9,7 @@
 import java.util.stream.Stream;
 
 import app.packed.assembly.AssemblyMirror;
+import app.packed.bean.BeanMirror;
 import app.packed.build.BuildGoal;
 import app.packed.component.ComponentMirror;
 import app.packed.component.ComponentPath;
@@ -59,6 +60,34 @@ public ApplicationMirror(ApplicationHandle<?, ?> handle) {
         this.handle = requireNonNull(handle);
     }
 
+    /**
+     * {@return a stream of all of the operations declared in the application.}
+     * <p>
+     * Unlike {@link #beans()}, this stream includes beans that are owned by extensions.
+     */
+    public Stream<BeanMirror> allBeans() {
+        return containers().stream().flatMap(ContainerMirror::allBeans);
+    }
+
+    /** {@return a stream of all of the operations declared by the user in the application.} */
+    public Stream<OperationMirror> allOperations() {
+        return allBeans().flatMap(BeanMirror::operations);
+    }
+
+    /**
+     * Returns a stream of all of the operations declared by the bean with the specified mirror type.
+     *
+     * @param <T>
+     * @param operationType
+     *            the type of operations to include
+     * @return a collection of all of the operations declared by the bean of the specified type.
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends OperationMirror> Stream<T> allOperations(Class<T> operationType) {
+        requireNonNull(operationType, "operationType is null");
+        return (Stream<T>) allOperations().filter(f -> operationType.isAssignableFrom(f.getClass()));
+    }
+
     /** {@return a tree representing all the assemblies used for creating this application} */
     public TreeView<AssemblyMirror> assemblies() {
         return new PackedTreeView<>(handle.application.container().assembly, null, c -> c.mirror());
@@ -69,6 +98,15 @@ public AssemblyMirror assembly() {
         return handle.application.container().assembly.mirror();
     }
 
+    /** {@return a stream of all of the bean declared by the user in the application.} */
+    public Stream<BeanMirror> beans() {
+        return containers().stream().flatMap(ContainerMirror::beans);
+    }
+    // ApplicationMirror
+    // All namespaces with root container
+    // All namespaces in the whole application
+    // All namespaces with a non-user owner
+
     /** {@return the build goal that was used when building the application} */
     public BuildGoal buildGoal() {
         return handle.application.deployment.goal;
@@ -158,6 +196,9 @@ public String name() {
         return handle.application.container().name();
     }
 
+    // Alternatively all keysspaces not owned by the application must be prefixed with $
+    // $FooExtension$main I think I like this better
+    // NamespaceKey <Type, Owner?, ContainerPath, Name>
 
     // Application owned namespace...
     // Optional???
@@ -177,18 +218,9 @@ public <N extends NamespaceMirror<?>> Optional<N> namespace(Class<N> type, Strin
         return Optional.empty();
     }
 
-    // ApplicationMirror
-    // All namespaces with root container
-    // All namespaces in the whole application
-    // All namespaces with a non-user owner
-
-    // Alternatively all keysspaces not owned by the application must be prefixed with $
-    // $FooExtension$main I think I like this better
-    // NamespaceKey <Type, Owner?, ContainerPath, Name>
-
-    /** {@return a stream of all of the operations declared by the bean.} */
+    /** {@return a stream of all of the operations declared by the user in the application.} */
     public Stream<OperationMirror> operations() {
-        return handle.application.container().stream().map(s -> s.mirror()).flatMap(ContainerMirror::operations);
+        return beans().flatMap(BeanMirror::operations);
     }
 
     /**

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

@@ -0,0 +1,86 @@
+/*
+ * 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 java.util.Optional;
+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.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}.
+ */
+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);
+
+    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();
+
+    /** {@return the template that is used for all applications in this repository} */
+    ApplicationTemplate<H> template();
+
+    static <A, H extends ApplicationHandle<A, ?>> ApplicationRepositoryConfiguration<A, H> install(BaseExtensionPoint point) {
+        throw new UnsupportedOperationException();
+    }
+
+    // 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> provide(Class<H> handleKind, ApplicationTemplate<H> template,
+            BaseExtension extension) {
+        return install(handleKind, template, extension).provide();
+    }
+
+    // Shared with ContainerRepository
+    interface Entry {
+        boolean isBuild();
+        boolean isLazy(); // Built on first usage
+
+        // An application can be, NA, INSTALLING, AVAILABLE
+        // Don't know if we at runtime
+        // Hvad hvis man ikke vil installere noget paa runtime...
+    }
+}

…/ApplicationRepositoryConfiguration.java …/ApplicationRepositoryConfiguration.javamodules/packed/src/main/java/app/packed/application/repository/ApplicationRepositoryConfiguration.java renamed to modules/packed/src/main/java/app/packed/application/ApplicationRepositoryConfiguration.java modules/packed/src/main/java/app/packed/application/repository/ApplicationRepositoryConfiguration.java renamed to modules/packed/src/main/java/app/packed/application/ApplicationRepositoryConfiguration.java

@@ -13,13 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package app.packed.application.repository;
+package app.packed.application;
 
 import java.util.function.Consumer;
 
-import app.packed.application.ApplicationHandle;
-import app.packed.application.ApplicationTemplate;
-import app.packed.binding.Key;
 import app.packed.service.ProvidableBeanConfiguration;
 
 /**
@@ -35,24 +32,24 @@
 // I don't know don't we always??
 
 // Maybe we don't extend it ServiableBean and have a provideAtRuntime();
-public final class ApplicationRepositoryConfiguration<H extends ApplicationHandle<?, ?>> extends ProvidableBeanConfiguration<ApplicationRepository<H>> {
+public final class ApplicationRepositoryConfiguration<I, H extends ApplicationHandle<I, ?>> extends ProvidableBeanConfiguration<ApplicationRepository<I, H>> {
 
     /** The application repository bean handle. */
-    final ApplicationRepositoryHandle<H> handle;
+    final ApplicationRepositoryHandle<I, H> handle;
 
     /**
      * @param handle
      *            the bean's handle
      */
-    ApplicationRepositoryConfiguration(ApplicationRepositoryHandle<H> handle) {
+    ApplicationRepositoryConfiguration(ApplicationRepositoryHandle<I, H> handle) {
         super(handle);
         this.handle = handle;
     }
 
     // Okay, vi har elastic search in an Assembly. Byg den
     // Expose some services. Og vi har nok en masse shared services.
     // Tror ikke helt vi er klar
-
+    // Ved ikke om det har noget med repository at goere. Det tror jeg egentlig ikke...
     public void buildDependecy(Consumer<? super ApplicationTemplate.Installer<H>> installer) {
         handle.repository.add(installer);
     }
@@ -63,21 +60,16 @@ public void buildDependecy(Consumer<? super ApplicationTemplate.Installer<H>> in
      * @param installer
      *            a consumer that performs the actual installation of the application
      */
-    public void installChildApplication(Consumer<? super ApplicationTemplate.Installer<H>> installer) {
+    public void installApplication(Consumer<? super ApplicationTemplate.Installer<H>> installer) {
         handle.repository.add(installer);
     }
 
     @Override
-    public ApplicationRepositoryConfiguration<H> provideAs(Class<? super ApplicationRepository<H>> key) {
-        super.provideAs(key);
+    public ApplicationRepositoryConfiguration<I, H> provide() {
+        super.provide();
         return this;
     }
 
-    @Override
-    public ApplicationRepositoryConfiguration<H> provideAs(Key<? super ApplicationRepository<H>> key) {
-        super.provideAs(key);
-        return this;
-    }
 
     /** {@return the templates that are available in the repository) */
     @SuppressWarnings("unchecked")

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

@@ -0,0 +1,97 @@
+/*
+ * 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 java.lang.reflect.ParameterizedType;
+
+import app.packed.bean.BeanHandle;
+import app.packed.bean.BeanInstaller;
+import app.packed.bean.BeanKind;
+import app.packed.bean.BeanTemplate;
+import app.packed.binding.Key;
+import app.packed.binding.Variable;
+import app.packed.lifecycle.LifecycleKind;
+import internal.app.packed.application.PackedApplicationTemplate;
+import internal.app.packed.application.repository.AbstractApplicationRepository;
+import internal.app.packed.application.repository.BuildApplicationRepository;
+import internal.app.packed.application.repository.ManagedApplicationRepository;
+import internal.app.packed.application.repository.UnmanagedApplicationRepository;
+import internal.app.packed.bean.BeanSetup;
+import internal.app.packed.bean.PackedBeanTemplate;
+import internal.app.packed.build.AuthoritySetup;
+import internal.app.packed.extension.ExtensionSetup;
+import internal.app.packed.util.types.Types;
+
+class ApplicationRepositoryHandle<I, H extends ApplicationHandle<I, ?>> extends BeanHandle<ApplicationRepositoryConfiguration<I, H>> {
+
+    private static final PackedBeanTemplate REPOSITORY_BEAN_TEMPLATE = (PackedBeanTemplate) BeanTemplate.of(BeanKind.CONTAINER,
+            b -> b.createAs(AbstractApplicationRepository.class));
+
+    private final Class<H> handleKind;
+
+    final BuildApplicationRepository repository;
+
+    private ApplicationRepositoryHandle(BeanInstaller installer, Class<H> handleKind, BuildApplicationRepository repository) {
+        super(installer);
+        this.handleKind = handleKind;
+        this.repository = repository;
+    }
+
+    @Override
+    public Key<?> defaultKey() {
+        // We need to know the template type either, from the template itself, or when creating the repository.
+        // Think we might as well just do it in the template
+        ParameterizedType p = Types.createNewParameterizedType(ApplicationRepository.class, repository.template.guestClass(), handleKind);
+        Variable v = Variable.of(p);
+        Key<?> key = Key.fromVariable(v);
+        return key;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected ApplicationRepositoryConfiguration<I, H> newBeanConfiguration() {
+        return new ApplicationRepositoryConfiguration<>(this);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    protected void onClose() {
+        bindServiceInstance(BuildApplicationRepository.class, repository);
+        BeanSetup.crack(this).container.application.subChildren.add(repository);
+    }
+
+    static <A, H extends ApplicationHandle<A, ?>> ApplicationRepositoryConfiguration<A, H> install(Class<H> handleKind, ApplicationTemplate<H> template,
+            ExtensionSetup es, AuthoritySetup<?> owner) {
+        PackedApplicationTemplate<H> t = (PackedApplicationTemplate<H>) template;
+        if (t.guestClass() == Void.class) {
+            throw new UnsupportedOperationException("Does not support application templates of Void.class guest type");
+        }
+
+        // Create a new installer for the repository bean
+
+        Class<?> cl = t.containerTemplate().lifecycleKind() == LifecycleKind.UNMANAGED ? UnmanagedApplicationRepository.class
+                : ManagedApplicationRepository.class;
+
+        BeanInstaller installer = ApplicationRepositoryHandle.REPOSITORY_BEAN_TEMPLATE.newInstaller(es, owner);
+        ApplicationRepositoryHandle<A, H> h = installer.install(cl, i -> new ApplicationRepositoryHandle<>(i, handleKind, new BuildApplicationRepository(t)));
+
+        // Create a new installer for the guest bean
+        BeanInstaller i = PackedApplicationTemplate.GB.newInstaller(es, owner);
+        t.installGuestBean(i, h.repository::onCodeGenerated);
+
+        return h.configuration();
+    }
+}