Override env vars

include/aos/common/cloudprotocol/cloudprotocol.hpp

@@ -20,6 +20,19 @@
     Optional<StaticString<cSubjectIDLen>> mSubjectID;
     Optional<uint64_t>                    mInstance;
 
+    /**
+     * Returns true if instance ident matches filter.
+     *
+     * @param instanceIdent instance ident to match.
+     * @return bool.
+     */
+    bool Match(const InstanceIdent& instanceIdent) const
+    {
+        return (!mServiceID.HasValue() || *mServiceID == instanceIdent.mServiceID)
+            && (!mSubjectID.HasValue() || *mSubjectID == instanceIdent.mSubjectID)
+            && (!mInstance.HasValue() || *mInstance == instanceIdent.mInstance);
+    }
+
     /**
      * Compares instance filter.
      *
@@ -38,6 +51,27 @@
      * @return bool.
      */
     bool operator!=(const InstanceFilter& filter) const { return !operator==(filter); }
+
+    /**
+     * Outputs instance filter to log.
+     *
+     * @param log log to output.
+     * @param instanceFilter instance filter.
+     *
+     * @return Log&.
+     */
+    friend Log& operator<<(Log& log, const InstanceFilter& instanceFilter)
+    {
+        StaticString<32> instanceStr = "*";
+
+        if (instanceFilter.mInstance.HasValue()) {
+            instanceStr.Convert(*instanceFilter.mInstance);
+        }
+
+        return log << "{" << (instanceFilter.mServiceID.HasValue() ? *instanceFilter.mServiceID : "*") << ":"
+                   << (instanceFilter.mSubjectID.HasValue() ? *instanceFilter.mSubjectID : "*") << ":" << instanceStr
+                   << "}";
+    }
 };
 
 } // namespace aos::cloudprotocol

include/aos/common/cloudprotocol/envvars.hpp

@@ -45,6 +45,9 @@ struct EnvVarInfo {
     bool operator!=(const EnvVarInfo& info) const { return !operator==(info); }
 };
 
+/**
+ * Env vars info static array.
+ */
 using EnvVarInfoArray = StaticArray<EnvVarInfo, cMaxNumEnvVariables>;
 
 /**

include/aos/common/ocispec/runtimespec.hpp

@@ -163,14 +163,14 @@ struct POSIXRlimit {
  * Process contains information to start a specific application inside the container.
  */
 struct Process {
-    bool                                                           mTerminal;
-    User                                                           mUser;
-    StaticArray<StaticString<cMaxParamLen>, cMaxParamCount>        mArgs;
-    StaticArray<StaticString<cEnvVarNameLen>, cMaxNumEnvVariables> mEnv;
-    StaticString<cMaxParamLen>                                     mCwd;
-    bool                                                           mNoNewPrivileges;
-    Optional<LinuxCapabilities>                                    mCapabilities;
-    StaticArray<POSIXRlimit, cMaxParamCount>                       mRlimits;
+    bool                                                    mTerminal;
+    User                                                    mUser;
+    StaticArray<StaticString<cMaxParamLen>, cMaxParamCount> mArgs;
+    EnvVarsArray                                            mEnv;
+    StaticString<cMaxParamLen>                              mCwd;
+    bool                                                    mNoNewPrivileges;
+    Optional<LinuxCapabilities>                             mCapabilities;
+    StaticArray<POSIXRlimit, cMaxParamCount>                mRlimits;
 
     /**
      * Compares process spec.

include/aos/common/tools/list.hpp

@@ -29,9 +29,9 @@ class ListImpl {
 protected:
     struct Node {
         bool  mAllocated = false;
-        T     mValue;
-        Node* mNext = nullptr;
-        Node* mPrev = nullptr;
+        Node* mNext      = nullptr;
+        Node* mPrev      = nullptr;
+        alignas(T) uint8_t mBuffer[sizeof(T)];
     };
 
     /**
@@ -80,21 +80,21 @@ class ListImpl {
          *
          * @return Reference.
          */
-        Reference operator*() const { return mCurrentNode->mValue; }
+        Reference operator*() const { return *reinterpret_cast<Pointer>(mCurrentNode->mBuffer); }
 
         /**
          * Dereference operator.
          *
          * @return Pointer.
          */
-        Pointer operator&() const { return &mCurrentNode->mValue; }
+        Pointer operator&() const { return reinterpret_cast<Pointer>(mCurrentNode->mBuffer); }
 
         /**
          * Dereference operator.
          *
          * @return Pointer.
          */
-        Pointer operator->() const { return &mCurrentNode->mValue; }
+        Pointer operator->() const { return reinterpret_cast<Pointer>(mCurrentNode->mBuffer); }
 
         /**
          * Prefix increment operator.
@@ -192,7 +192,7 @@ class ListImpl {
             return nullptr;
         }
 
-        new (&node->mValue) T(args...);
+        new (&node->mBuffer) T(args...);
 
         return node;
     }
@@ -215,7 +215,7 @@ class ListImpl {
         assert(node.mAllocated);
 
         node.mAllocated = false;
-        node.mValue.~T();
+        reinterpret_cast<T*>(node.mBuffer)->~T();
     }
 
     void RemoveNode(Node& node)

include/aos/common/types.hpp

@@ -762,15 +762,20 @@ struct DeviceInfo {
     bool operator!=(const DeviceInfo& deviceInfo) const { return !operator==(deviceInfo); }
 };
 
+/**
+ * Env vars static array.
+ */
+using EnvVarsArray = StaticArray<StaticString<cEnvVarNameLen>, cMaxNumEnvVariables>;
+
 /**
  * Resource info.
  */
 struct ResourceInfo {
-    StaticString<cResourceNameLen>                                 mName;
-    StaticArray<StaticString<cGroupNameLen>, cMaxNumGroups>        mGroups;
-    StaticArray<Mount, cMaxNumFSMounts>                            mMounts;
-    StaticArray<StaticString<cEnvVarNameLen>, cMaxNumEnvVariables> mEnv;
-    StaticArray<Host, cMaxNumHosts>                                mHosts;
+    StaticString<cResourceNameLen>                          mName;
+    StaticArray<StaticString<cGroupNameLen>, cMaxNumGroups> mGroups;
+    StaticArray<Mount, cMaxNumFSMounts>                     mMounts;
+    EnvVarsArray                                            mEnv;
+    StaticArray<Host, cMaxNumHosts>                         mHosts;
 
     /**
      * Compares resource info.

include/aos/sm/launcher.hpp

@@ -14,7 +14,7 @@
 #include "aos/common/connectionsubsc.hpp"
 #include "aos/common/monitoring/monitoring.hpp"
 #include "aos/common/ocispec/ocispec.hpp"
-#include "aos/common/tools/map.hpp"
+#include "aos/common/tools/list.hpp"
 #include "aos/common/tools/noncopyable.hpp"
 #include "aos/common/types.hpp"
 #include "aos/sm/config.hpp"
@@ -63,7 +63,7 @@ class LauncherItf {
      * @return Error
      */
     virtual Error OverrideEnvVars(const Array<cloudprotocol::EnvVarsInstanceInfo>& envVarsInfo,
-        cloudprotocol::EnvVarsInstanceStatusArray&                                 statuses)
+        Array<cloudprotocol::EnvVarsInstanceStatus>&                               statuses)
         = 0;
 };
 
@@ -194,15 +194,15 @@ class StorageItf {
      * @param envVarsInstanceInfos[out] instances's override environment variables array.
      * @return Error.
      */
-    virtual Error GetOverrideEnvVars(cloudprotocol::EnvVarsInstanceInfoArray& envVarsInstanceInfos) const = 0;
+    virtual Error GetOverrideEnvVars(Array<cloudprotocol::EnvVarsInstanceInfo>& envVarsInstanceInfos) const = 0;
 
     /**
      * Sets instances's override environment variables array.
      *
      * @param envVarsInstanceInfos instances's override environment variables array.
      * @return Error.
      */
-    virtual Error SetOverrideEnvVars(const cloudprotocol::EnvVarsInstanceInfoArray& envVarsInstanceInfos) = 0;
+    virtual Error SetOverrideEnvVars(const Array<cloudprotocol::EnvVarsInstanceInfo>& envVarsInstanceInfos) = 0;
 
     /**
      * Returns online time.
@@ -311,7 +311,7 @@ class Launcher : public LauncherItf,
      * @return Error
      */
     Error OverrideEnvVars(const Array<cloudprotocol::EnvVarsInstanceInfo>& envVarsInfo,
-        cloudprotocol::EnvVarsInstanceStatusArray&                         statuses) override;
+        Array<cloudprotocol::EnvVarsInstanceStatus>&                       statuses) override;
 
     /**
      * Updates run instances status.
@@ -346,43 +346,57 @@ class Launcher : public LauncherItf,
 
     static constexpr auto cHostFSWhiteoutsDir = "whiteouts";
 
+    static constexpr auto cAllocatorSize
+        = Max(sizeof(InstanceInfoStaticArray) + sizeof(InstanceDataStaticArray) * 2 + sizeof(ServiceInfoStaticArray)
+                + sizeof(LayerInfoStaticArray) + sizeof(servicemanager::ServiceDataStaticArray)
+                + sizeof(InstanceStatusStaticArray) + sizeof(servicemanager::ServiceData) + sizeof(InstanceData),
+            sizeof(EnvVarsArray) + sizeof(InstanceStatusStaticArray) + sizeof(InstanceDataStaticArray));
+
     void  ShowResourceUsageStats();
     Error ProcessLastInstances();
     Error ProcessInstances(const Array<InstanceInfo>& instances, bool forceRestart = false);
     Error ProcessServices(const Array<ServiceInfo>& services);
     Error ProcessLayers(const Array<LayerInfo>& layers);
     Error ProcessStopInstances(const Array<InstanceData>& instances);
+    Error ProcessRestartInstances(const Array<InstanceData>& instances);
     Error SendRunStatus();
     Error SendOutdatedInstancesStatus(const Array<InstanceData>& instances);
     void  StopInstances(const Array<InstanceData>& instances);
     void  StartInstances(const Array<InstanceData>& instances);
+    void  RestartInstances(const Array<InstanceData>& instances);
     void  CacheServices(const Array<InstanceData>& instances);
     void  UpdateInstanceServices();
     Error GetStartInstances(const Array<InstanceInfo>& desiredInstances, Array<InstanceData>& startInstances) const;
     Error GetStopInstances(
         const Array<InstanceData>& startInstances, Array<InstanceData>& stopInstances, bool forceRestart) const;
-    Error GetCurrentInstances(Array<InstanceData>& instance) const;
+    Error GetCurrentInstances(Array<InstanceData>& instances) const;
+    Error StartInstance(const InstanceData& info);
+    Error StopInstance(const String& instanceID);
+    Error FillCurrentInstance(const Array<InstanceData>& instances);
+    Error RunLastInstances();
+    Error StopCurrentInstances();
+    Error GetOutdatedInstances(Array<InstanceData>& instances);
+    Error HandleOfflineTTLs();
+    Error SetEnvVars(const Array<cloudprotocol::EnvVarsInstanceInfo>& envVarsInfo,
+        Array<cloudprotocol::EnvVarsInstanceStatus>&                  statuses);
+    Error GetInstanceEnvVars(const InstanceIdent& instanceIdent, Array<StaticString<cEnvVarNameLen>>& envVars) const;
+    Error RemoveOutdatedEnvVars();
+    Error GetEnvChangedInstances(Array<InstanceData>& instance) const;
+    Error SendEnvChangedInstancesStatus(const Array<InstanceData>& instances);
+    Error UpdateInstancesEnvVars();
 
     servicemanager::ServiceData* GetService(const String& serviceID)
     {
         return mCurrentServices.FindIf(
             [&serviceID](const servicemanager::ServiceData& service) { return serviceID == service.mServiceID; });
     }
 
-    Instance* GetInstance(const String& instanceID)
+    List<Instance>::Iterator GetInstance(const String& instanceID)
     {
         return mCurrentInstances.FindIf(
             [&instanceID](const Instance& instance) { return instanceID == instance.InstanceID(); });
     }
 
-    Error StartInstance(const InstanceData& info);
-    Error StopInstance(Instance* instance);
-    Error FillCurrentInstance(const Array<InstanceData>& instances);
-    Error RunLastInstances();
-    Error StopCurrentInstances();
-    Error GetOutdatedInstances(Array<InstanceData>& instances);
-    Error HandleOfflineTTLs();
-
     Config                               mConfig;
     ConnectionPublisherItf*              mConnectionPublisher {};
     InstanceStatusReceiverItf*           mStatusReceiver {};
@@ -397,22 +411,20 @@ class Launcher : public LauncherItf,
     StorageItf*                          mStorage {};
     RuntimeItf*                          mRuntime {};
 
-    mutable StaticAllocator<sizeof(InstanceInfoStaticArray) + sizeof(InstanceDataStaticArray) * 2
-        + sizeof(ServiceInfoStaticArray) + sizeof(LayerInfoStaticArray) + sizeof(servicemanager::ServiceDataStaticArray)
-        + sizeof(InstanceStatusStaticArray) + sizeof(servicemanager::ServiceData) + sizeof(InstanceData)>
-        mAllocator;
+    mutable StaticAllocator<cAllocatorSize> mAllocator;
 
     bool                                      mLaunchInProgress = false;
     mutable Mutex                             mMutex;
     Thread<cThreadTaskSize, cThreadStackSize> mThread;
-    ThreadPool<cNumLaunchThreads, Max(cMaxNumInstances, cMaxNumServices, cMaxNumLayers), cThreadTaskSize,
+    ThreadPool<cNumLaunchThreads, Max(cMaxNumInstances * 2, cMaxNumServices, cMaxNumLayers), cThreadTaskSize,
         cThreadStackSize>
                                 mLaunchPool;
     bool                        mConnected = false;
     mutable ConditionalVariable mCondVar;
 
     StaticArray<servicemanager::ServiceData, cMaxNumServices> mCurrentServices;
-    StaticArray<Instance, cMaxNumInstances>                   mCurrentInstances;
+    StaticList<Instance, cMaxNumInstances>                    mCurrentInstances;
+    cloudprotocol::EnvVarsInstanceInfoArray                   mCurrentEnvVars;
     StaticString<cFilePathLen>                                mHostWhiteoutsDir;
     NodeInfo                                                  mNodeInfo;
     Time                                                      mOnlineTime;

include/aos/sm/launcher/instance.hpp

@@ -132,11 +132,6 @@
  */
 class Instance {
 public:
-    /**
-     * Creates instance.
-     */
-    Instance() = default;
-
     /**
      * Creates instance.
      *
@@ -249,6 +244,20 @@
      */
     Duration GetOfflineTTL() const { return mOfflineTTL; };
 
+    /**
+     * Returns instance override env vars.
+     *
+     * @return const EnvVarsArray&.
+     */
+    const EnvVarsArray& GetOverrideEnvVars() const { return mOverrideEnvVars; };
+
+    /**
+     * Sets instance override env vars.
+     *
+     * @param envVars
+     */
+    void SetOverrideEnvVars(const Array<StaticString<cEnvVarNameLen>>& envVars) { mOverrideEnvVars = envVars; };
+
     /**
      * Returns instances allocator.
      */
@@ -314,8 +323,7 @@
     static constexpr auto cAllocatorSize
         = (sizeof(oci::RuntimeSpec) + sizeof(image::ImageParts)
               + Max(sizeof(networkmanager::InstanceNetworkParameters), sizeof(monitoring::InstanceMonitorParams),
-                  sizeof(oci::ImageSpec) + sizeof(oci::ServiceConfig)
-                      + sizeof(StaticArray<StaticString<cEnvVarNameLen>, cMaxNumEnvVariables>),
+                  sizeof(oci::ImageSpec) + sizeof(oci::ServiceConfig) + sizeof(EnvVarsArray),
                   sizeof(LayersStaticArray) + sizeof(layermanager::LayerData), sizeof(Mount) + sizeof(ResourceInfo),
                   sizeof(Mount) + sizeof(DeviceInfo) + sizeof(StaticArray<oci::LinuxDevice, cMaxNumHostDevices>)))
         * AOS_CONFIG_LAUNCHER_NUM_COOPERATE_LAUNCHES;
@@ -392,6 +400,7 @@
     Error                              mRunError;
     bool                               mPermissionsRegistered = false;
     Duration                           mOfflineTTL            = 0;
+    EnvVarsArray                       mOverrideEnvVars;
 };
 
 } // namespace aos::sm::launcher

src/sm/launcher/instance.cpp

@@ -203,7 +203,7 @@
 
 Error Instance::CreateAosEnvVars(oci::RuntimeSpec& runtimeSpec)
 {
-    auto envVars = MakeUnique<StaticArray<StaticString<cEnvVarNameLen>, cMaxNumEnvVariables>>(&sAllocator);
+    auto                         envVars = MakeUnique<EnvVarsArray>(&sAllocator);
     StaticString<cEnvVarNameLen> envVar;
 
     if (auto err = envVar.Format("%s=%s", cEnvAosServiceID, mService->mServiceID.CStr()); !err.IsNone()) {
@@ -569,6 +569,10 @@
         return err;
     }
 
+    if (auto err = AddEnvVars(mOverrideEnvVars, runtimeSpec); !err.IsNone()) {
+        return err;
+    }
+
     if (auto err = ApplyImageConfig(imageSpec, runtimeSpec); !err.IsNone()) {
         return AOS_ERROR_WRAP(err);
     }