Chg: update image tag in helm values to v2.6.0-RC5

Fix: https://telecominfraproject.atlassian.net/browse/WIFI-10070

build

@@ -1 +1 @@
-138
+141

helm/values.yaml

@@ -9,7 +9,7 @@ fullnameOverride: ""
 images:
   owprov:
     repository: tip-tip-wlan-cloud-ucentral.jfrog.io/owprov
-    tag: v2.6.0-RC4
+    tag: v2.6.0-RC5
     pullPolicy: Always
 #    regcred:
 #      registry: tip-tip-wlan-cloud-ucentral.jfrog.io

src/AutoDiscovery.h

@@ -33,7 +33,7 @@ namespace OpenWifi {
             void Stop() override;
             void ConnectionReceived( const std::string & Key, const std::string & Payload) {
                 std::lock_guard G(Mutex_);
-                Logger().information(Poco::format("Device(%s): Connection/Ping message.", Key));
+                poco_debug(Logger(),Poco::format("Device(%s): Connection/Ping message.", Key));
                 Queue_.enqueueNotification( new DiscoveryMessage(Key,Payload));
             }
             void run() override;

src/JobController.cpp

@@ -33,22 +33,22 @@ namespace OpenWifi {
 
             std::lock_guard G(Mutex_);
 
-            for(auto &job:jobs_) {
+            for(auto &current_job:jobs_) {
-                if(job!=nullptr) {
+                if(current_job!=nullptr) {
-                    if(job->Started()==0 && Pool_.used()<Pool_.available()) {
+                    if(current_job->Started()==0 && Pool_.used()<Pool_.available()) {
-                        job->Logger().information(fmt::format("Starting {}: {}",job->JobId(),job->Name()));
+                        current_job->Logger().information(fmt::format("Starting {}: {}",current_job->JobId(),current_job->Name()));
-                        job->Start();
+                        current_job->Start();
-                        Pool_.start(*job);
+                        Pool_.start(*current_job);
                     }
                 }
             }
 
-            for(auto it = jobs_.begin(); it!=jobs_.end();) {
+            for(auto it = jobs_.begin(); it!=jobs_.end();) {\
-                if(*it!=nullptr && (*it)->Completed()!=0) {
+                auto current_job = *it;
-                    auto tmp = it;
+                if(current_job!=nullptr && current_job->Completed()!=0) {
-                    (*it)->Logger().information(fmt::format("Completed {}: {}",(*it)->JobId(),(*it)->Name()));
+                    current_job->Logger().information(fmt::format("Completed {}: {}",current_job->JobId(),current_job->Name()));
                     it = jobs_.erase(it);
-                    delete *tmp;
+                    delete current_job;
                 } else {
                     ++it;
                 }

src/Tasks/VenueConfigUpdater.h

@@ -20,8 +20,6 @@ namespace OpenWifi {
                 auto Status = Results->get("status").extract<Poco::JSON::Object::Ptr>();
                 auto Rejected = Status->getArray("rejected");
                 std::transform(Rejected->begin(),Rejected->end(),std::back_inserter(Warnings), [](auto i) -> auto { return i.toString(); });
-//                for(const auto &i:*Rejected)
-                //                  Warnings.push_back(i.toString());
             }
         } catch (...) {
         }
@@ -106,78 +104,66 @@ namespace OpenWifi {
             ProvObjects::Venue  Venue;
             uint64_t Updated = 0, Failed = 0 , BadConfigs = 0 ;
             if(StorageService()->VenueDB().GetRecord("id",VenueUUID_,Venue)) {
-                const std::size_t MaxThreads=16;
-                struct tState {
-                    Poco::Thread                thr_;
-                    VenueDeviceConfigUpdater    *task= nullptr;
-                };
 
                 N.content.title = fmt::format("Updating {} configurations", Venue.info.name);
                 N.content.jobId = JobId();
 
-                std::array<tState,MaxThreads> Tasks;
+                Poco::ThreadPool    Pool_;
+                std::list<VenueDeviceConfigUpdater*> JobList;
+
 
                 for(const auto &uuid:Venue.devices) {
                     auto NewTask = new VenueDeviceConfigUpdater(uuid, Venue.info.name, Logger());
-                    // std::cout << "Scheduling config push for " << uuid << std::endl;
+                    bool TaskAdded=false;
-                    bool found_slot = false;
+                    while(!TaskAdded) {
-                    while (!found_slot) {
+                        if (Pool_.available()) {
-                        for (auto &cur_task: Tasks) {
+                            JobList.push_back(NewTask);
-                            if (cur_task.task == nullptr) {
+                            Pool_.start(*NewTask);
-                                cur_task.task = NewTask;
+                            TaskAdded = true;
-                                cur_task.thr_.start(*NewTask);
+                            continue;
-                                found_slot = true;
-                                break;
-                            }
                         }
+                    }
 
-                        //  Let's look for a slot...
+                    for(auto job_it = JobList.begin(); job_it !=JobList.end();) {
-                        if (!found_slot) {
+                        VenueDeviceConfigUpdater * current_job = *job_it;
-                            for (auto &cur_task: Tasks) {
+                        if(current_job!= nullptr && current_job->done_) {
-                                if (cur_task.task != nullptr && cur_task.task->started_) {
+                            Updated += current_job->updated_;
-                                    if (cur_task.thr_.isRunning())
+                            Failed += current_job->failed_;
-                                        continue;
+                            BadConfigs += current_job->bad_config_;
-                                    if (!cur_task.thr_.isRunning() && cur_task.task->done_) {
+                            if(current_job->updated_) {
-                                        cur_task.thr_.join();
+                                N.content.success.push_back(current_job->SerialNumber);
-                                        Updated += cur_task.task->updated_;
+                            } else if(current_job->failed_) {
-                                        Failed += cur_task.task->failed_;
+                                N.content.warning.push_back(current_job->SerialNumber);
-                                        BadConfigs += cur_task.task->bad_config_;
+                            } else {
-                                        cur_task.task->started_ = cur_task.task->done_ = false;
+                                N.content.error.push_back(current_job->SerialNumber);
-                                        delete cur_task.task;
-                                        cur_task.task = nullptr;
-                                    }
-                                }
                             }
+                            job_it = JobList.erase(job_it);
+                            delete current_job;
+                        } else {
+                            ++job_it;
                         }
                     }
                 }
+
                 Logger().debug("Waiting for outstanding update threads to finish.");
-                bool stillTasksRunning=true;
+                Pool_.joinAll();
-                while(stillTasksRunning) {
+                for(auto job_it = JobList.begin(); job_it !=JobList.end();) {
-                    stillTasksRunning = false;
+                    VenueDeviceConfigUpdater * current_job = *job_it;
-                    for(auto &cur_task:Tasks) {
+                    if(current_job!= nullptr && current_job->done_) {
-                        if(cur_task.task!= nullptr && cur_task.task->started_) {
+                        Updated += current_job->updated_;
-                            if(cur_task.thr_.isRunning()) {
+                        Failed += current_job->failed_;
-                                stillTasksRunning = true;
+                        BadConfigs += current_job->bad_config_;
-                                continue;
+                        if(current_job->updated_) {
-                            }
+                            N.content.success.push_back(current_job->SerialNumber);
-                            if(!cur_task.thr_.isRunning() && cur_task.task->done_) {
+                        } else if(current_job->failed_) {
-                                cur_task.thr_.join();
+                            N.content.warning.push_back(current_job->SerialNumber);
-                                if(cur_task.task->updated_) {
+                        } else {
-                                    Updated++;
+                            N.content.error.push_back(current_job->SerialNumber);
-                                    N.content.success.push_back(cur_task.task->SerialNumber);
-                                } else if(cur_task.task->failed_) {
-                                    Failed++;
-                                    N.content.warning.push_back(cur_task.task->SerialNumber);
-                                } else {
-                                    BadConfigs++;
-                                    N.content.error.push_back(cur_task.task->SerialNumber);
-                                }
-                                cur_task.task->started_ = cur_task.task->done_ = false;
-                                delete cur_task.task;
-                                cur_task.task = nullptr;
-                            }
                         }
+                        job_it = JobList.erase(job_it);
+                        delete current_job;
+                    } else {
+                        ++job_it;
                     }
                 }
 
@@ -189,6 +175,7 @@ namespace OpenWifi {
                 Logger().warning(N.content.details);
             }
 
+            // std::cout << N.content.details << std::endl;
             WebSocketClientNotificationVenueUpdateJobCompletionToUser(UserInfo().email, N);
             Logger().information(fmt::format("Job {} Completed: {} updated, {} failed to update , {} bad configurations.",
                                              JobId(), Updated ,Failed, BadConfigs));

src/Tasks/VenueRebooter.h

@@ -66,77 +66,59 @@ namespace OpenWifi {
             ProvObjects::Venue  Venue;
             uint64_t rebooted_ = 0, failed_ = 0;
             if(StorageService()->VenueDB().GetRecord("id",VenueUUID_,Venue)) {
-                const std::size_t MaxThreads=16;
-                struct tState {
-                    Poco::Thread                thr_;
-                    VenueDeviceRebooter    *task= nullptr;
-                };
 
                 N.content.title = fmt::format("Rebooting {} devices.", Venue.info.name);
                 N.content.jobId = JobId();
 
-                std::array<tState,MaxThreads> Tasks;
+                Poco::ThreadPool    Pool_;
+                std::list<VenueDeviceRebooter*> JobList;
 
                 for(const auto &uuid:Venue.devices) {
                     auto NewTask = new VenueDeviceRebooter(uuid, Venue.info.name, Logger());
-                    // std::cout << "Scheduling config push for " << uuid << std::endl;
+                    bool TaskAdded=false;
-                    bool found_slot = false;
+                    while(!TaskAdded) {
-                    while (!found_slot) {
+                        if (Pool_.available()) {
-                        for (auto &cur_task: Tasks) {
+                            JobList.push_back(NewTask);
-                            if (cur_task.task == nullptr) {
+                            Pool_.start(*NewTask);
-                                cur_task.task = NewTask;
+                            TaskAdded = true;
-                                cur_task.thr_.start(*NewTask);
+                            continue;
-                                found_slot = true;
-                                break;
-                            }
                         }
+                    }
 
-                        //  Let's look for a slot...
+                    for(auto job_it = JobList.begin(); job_it !=JobList.end();) {
-                        if (!found_slot) {
+                        VenueDeviceRebooter * current_job = *job_it;
-                            for (auto &cur_task: Tasks) {
+                        if(current_job!= nullptr && current_job->done_) {
-                                if (cur_task.task != nullptr && cur_task.task->started_) {
+                            if(current_job->rebooted_)
-                                    if (cur_task.thr_.isRunning())
+                                N.content.success.push_back(current_job->SerialNumber);
-                                        continue;
+                            else
-                                    if (!cur_task.thr_.isRunning() && cur_task.task->done_) {
+                                N.content.warning.push_back(current_job->SerialNumber);
-                                        cur_task.thr_.join();
+                            rebooted_ += current_job->rebooted_;
-                                        rebooted_ += cur_task.task->rebooted_;
+                            failed_ += current_job->failed_;
-                                        failed_ += cur_task.task->failed_;
+                            job_it = JobList.erase(job_it);
-                                        cur_task.task->started_ = cur_task.task->done_ = false;
+                            delete current_job;
-                                        delete cur_task.task;
+                        } else {
-                                        cur_task.task = nullptr;
+                            ++job_it;
-                                    }
-                                }
-                            }
                         }
                     }
                 }
+
                 Logger().debug("Waiting for outstanding update threads to finish.");
-                bool stillTasksRunning=true;
+                Pool_.joinAll();
-                while(stillTasksRunning) {
+                for(auto job_it = JobList.begin(); job_it !=JobList.end();) {
-                    stillTasksRunning = false;
+                    VenueDeviceRebooter * current_job = *job_it;
-                    for(auto &cur_task:Tasks) {
+                    if(current_job!= nullptr && current_job->done_) {
-                        if(cur_task.task!= nullptr && cur_task.task->started_) {
+                        if(current_job->rebooted_)
-                            if(cur_task.thr_.isRunning()) {
+                            N.content.success.push_back(current_job->SerialNumber);
-                                stillTasksRunning = true;
+                        else
-                                continue;
+                            N.content.warning.push_back(current_job->SerialNumber);
-                            }
+                        rebooted_ += current_job->rebooted_;
-                            if(!cur_task.thr_.isRunning() && cur_task.task->done_) {
+                        failed_ += current_job->failed_;
-                                cur_task.thr_.join();
+                        job_it = JobList.erase(job_it);
-                                if(cur_task.task->rebooted_) {
+                        delete current_job;
-                                    rebooted_++;
+                    } else {
-                                    N.content.success.push_back(cur_task.task->SerialNumber);
+                        ++job_it;
-                                } else if(cur_task.task->failed_) {
-                                    failed_++;
-                                    N.content.warning.push_back(cur_task.task->SerialNumber);
-                                }
-                                cur_task.task->started_ = cur_task.task->done_ = false;
-                                delete cur_task.task;
-                                cur_task.task = nullptr;
-                            }
-                        }
                     }
                 }
-
                 N.content.details = fmt::format("Job {} Completed: {} rebooted, {} failed to reboot.",
                                                 JobId(), rebooted_ ,failed_);
 
@@ -145,6 +127,7 @@ namespace OpenWifi {
                 Logger().warning(N.content.details);
             }
 
+            // std::cout << N.content.details << std::endl;
             WebSocketClientNotificationVenueRebootCompletionToUser(UserInfo().email,N);
             Logger().information(fmt::format("Job {} Completed: {} rebooted, {} failed to reboot.",
                                              JobId(), rebooted_ ,failed_));

src/Tasks/VenueUpgrade.h

@@ -31,7 +31,7 @@ namespace OpenWifi {
 
                 Storage::ApplyRules(rules_,Device.deviceRules);
                 if(Device.deviceRules.firmwareUpgrade=="no") {
-                    std::cout << "Skipped Upgrade:" << Device.serialNumber << std::endl;
+                    poco_debug(Logger(),fmt::format("Skipped Upgrade: {}", Device.serialNumber));
                     skipped_++;
                     done_=true;
                     return;
@@ -40,16 +40,14 @@ namespace OpenWifi {
                 FMSObjects::Firmware    F;
                 if(SDK::FMS::Firmware::GetLatest(Device.deviceType,Device.deviceRules.rcOnly=="yes",F)) {
                     if (SDK::GW::Device::Upgrade(nullptr, Device.serialNumber, 0, F.uri)) {
-                        std::cout << "Upgraded:" << Device.serialNumber << " to " << F.uri << std::endl;
                         Logger().debug(fmt::format("{}: Upgraded.",Device.serialNumber));
                         upgraded_++;
                     } else {
-                        std::cout << "Did not Upgrade:" << Device.serialNumber << " to " << F.uri << std::endl;
                         Logger().information(fmt::format("{}: Not Upgraded.", Device.serialNumber));
                         failed_++;
                     }
                 } else {
-                    std::cout << "Did not Upgrade:" << Device.serialNumber << " to <unknown>" << std::endl;
+                    Logger().information(fmt::format("{}: Not Upgraded. No firmware available.", Device.serialNumber));
                     failed_++;
                 }
             }
@@ -87,88 +85,71 @@ namespace OpenWifi {
             ProvObjects::Venue  Venue;
             uint64_t upgraded_ = 0, failed_ = 0;
             if(StorageService()->VenueDB().GetRecord("id",VenueUUID_,Venue)) {
-                const std::size_t MaxThreads=16;
-                struct tState {
-                    Poco::Thread                thr_;
-                    VenueDeviceUpgrade    *task= nullptr;
-                };
 
                 N.content.title = fmt::format("Upgrading {} devices.", Venue.info.name);
                 N.content.jobId = JobId();
 
-                std::array<tState,MaxThreads> Tasks;
+                Poco::ThreadPool                Pool_;
-                ProvObjects::DeviceRules    Rules;
+                std::list<VenueDeviceUpgrade*>  JobList;
+                ProvObjects::DeviceRules        Rules;
 
                 StorageService()->VenueDB().EvaluateDeviceRules(Venue.info.id, Rules);
 
                 for(const auto &uuid:Venue.devices) {
-                    auto NewTask = new VenueDeviceUpgrade(uuid, Venue.info.name, Rules,Logger());
+                    auto NewTask = new VenueDeviceUpgrade(uuid, Venue.info.name, Rules, Logger());
-                    // std::cout << "Scheduling config push for " << uuid << std::endl;
+                    bool TaskAdded = false;
-                    bool found_slot = false;
+                    while (!TaskAdded) {
-                    while (!found_slot) {
+                        if (Pool_.available()) {
-                        for (auto &cur_task: Tasks) {
+                            JobList.push_back(NewTask);
-                            if (cur_task.task == nullptr) {
+                            Pool_.start(*NewTask);
-                                cur_task.task = NewTask;
+                            TaskAdded = true;
-                                cur_task.thr_.start(*NewTask);
+                            continue;
-                                found_slot = true;
-                                break;
-                            }
                         }
+                    }
 
-                        //  Let's look for a slot...
+                    for (auto job_it = JobList.begin(); job_it != JobList.end();) {
-                        if (!found_slot) {
+                        VenueDeviceUpgrade *current_job = *job_it;
-                            for (auto &cur_task: Tasks) {
+                        if (current_job != nullptr && current_job->done_) {
-                                if (cur_task.task != nullptr && cur_task.task->started_) {
+                            if (current_job->upgraded_)
-                                    if (cur_task.thr_.isRunning())
+                                N.content.success.push_back(current_job->SerialNumber);
-                                        continue;
+                            else
-                                    if (!cur_task.thr_.isRunning() && cur_task.task->done_) {
+                                N.content.warning.push_back(current_job->SerialNumber);
-                                        cur_task.thr_.join();
+                            upgraded_ += current_job->upgraded_;
-                                        upgraded_ += cur_task.task->upgraded_;
+                            failed_ += current_job->failed_;
-                                        failed_ += cur_task.task->failed_;
+                            job_it = JobList.erase(job_it);
-                                        cur_task.task->started_ = cur_task.task->done_ = false;
+                            delete current_job;
-                                        delete cur_task.task;
+                        } else {
-                                        cur_task.task = nullptr;
+                            ++job_it;
-                                    }
-                                }
-                            }
                         }
                     }
                 }
-                Logger().debug("Waiting for outstanding update threads to finish.");
+
-                bool stillTasksRunning=true;
+                Logger().debug("Waiting for outstanding upgrade threads to finish.");
-                while(stillTasksRunning) {
+                Pool_.joinAll();
-                    stillTasksRunning = false;
+                for(auto job_it = JobList.begin(); job_it !=JobList.end();) {
-                    for(auto &cur_task:Tasks) {
+                    VenueDeviceUpgrade * current_job = *job_it;
-                        if(cur_task.task!= nullptr && cur_task.task->started_) {
+                    if(current_job!= nullptr && current_job->done_) {
-                            if(cur_task.thr_.isRunning()) {
+                        if(current_job->upgraded_)
-                                stillTasksRunning = true;
+                            N.content.success.push_back(current_job->SerialNumber);
-                                continue;
+                        else
-                            }
+                            N.content.warning.push_back(current_job->SerialNumber);
-                            if(!cur_task.thr_.isRunning() && cur_task.task->done_) {
+                        upgraded_ += current_job->upgraded_;
-                                cur_task.thr_.join();
+                        failed_ += current_job->failed_;
-                                if(cur_task.task->upgraded_) {
+                        job_it = JobList.erase(job_it);
-                                    upgraded_++;
+                        delete current_job;
-                                    N.content.success.push_back(cur_task.task->SerialNumber);
+                    } else {
-                                } else if(cur_task.task->failed_) {
+                        ++job_it;
-                                    failed_++;
-                                    N.content.warning.push_back(cur_task.task->SerialNumber);
-                                }
-                                cur_task.task->started_ = cur_task.task->done_ = false;
-                                delete cur_task.task;
-                                cur_task.task = nullptr;
-                            }
-                        }
                     }
                 }
 
                 N.content.details = fmt::format("Job {} Completed: {} upgraded, {} failed to upgrade.",
                                                 JobId(), upgraded_ ,failed_);
-
             } else {
                 N.content.details = fmt::format("Venue {} no longer exists.",VenueUUID_);
                 Logger().warning(N.content.details);
             }
 
+            // std::cout << N.content.details << std::endl;
             WebSocketClientNotificationVenueRebootCompletionToUser(UserInfo().email,N);
             Logger().information(fmt::format("Job {} Completed: {} upgraded, {} failed to upgrade.",
                                              JobId(), upgraded_ ,failed_));