| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 org.apache.stratos.autoscaler.applications.topic; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.stratos.autoscaler.AutoscalerContext; |
| import org.apache.stratos.autoscaler.applications.ApplicationHolder; |
| import org.apache.stratos.autoscaler.applications.pojo.ApplicationClusterContext; |
| import org.apache.stratos.autoscaler.client.cloud.controller.CloudControllerClient; |
| import org.apache.stratos.autoscaler.exception.DependencyBuilderException; |
| import org.apache.stratos.autoscaler.exception.TopologyInConsistentException; |
| import org.apache.stratos.autoscaler.grouping.topic.ClusterStatusEventPublisher; |
| import org.apache.stratos.autoscaler.monitor.ApplicationMonitorFactory; |
| import org.apache.stratos.autoscaler.monitor.application.ApplicationMonitor; |
| import org.apache.stratos.autoscaler.monitor.group.GroupMonitor; |
| import org.apache.stratos.messaging.domain.applications.*; |
| import org.apache.stratos.messaging.domain.topology.Topology; |
| import org.apache.stratos.messaging.message.receiver.topology.TopologyManager; |
| |
| import java.util.Collection; |
| import java.util.Set; |
| |
| /** |
| * This will build the application. |
| */ |
| public class ApplicationBuilder { |
| private static final Log log = LogFactory.getLog(ApplicationBuilder.class); |
| |
| |
| /*public static synchronized void handleApplicationDeployed(Application application, |
| Set<ApplicationClusterContext> applicationClusterContexts, |
| Set<MetaDataHolder> metaDataHolders) { |
| |
| |
| Applications applications = Appcation.getApplications(); |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| |
| if (applications.applicationExists(application.getUniqueIdentifier())) { |
| log.warn("Application with id [ " + application.getUniqueIdentifier() + " ] already exists in Applications"); |
| return; |
| } |
| List<Cluster> clusters = new ArrayList<Cluster>(); |
| for (ApplicationClusterContext applicationClusterContext : applicationClusterContexts) { |
| Cluster cluster = new Cluster(applicationClusterContext.getCartridgeType(), |
| applicationClusterContext.getClusterId(), applicationClusterContext.getDeploymentPolicyName(), |
| applicationClusterContext.getAutoscalePolicyName(), application.getUniqueIdentifier()); |
| //cluster.setStatus(Status.Created); |
| cluster.addHostName(applicationClusterContext.getHostName()); |
| cluster.setTenantRange(applicationClusterContext.getTenantRange()); |
| clusters.add(cluster); |
| |
| Service service = applications.getService(applicationClusterContext.getCartridgeType()); |
| if (service != null) { |
| service.addCluster(cluster); |
| log.info("Added Cluster " + cluster.toString() + " to Applications for Application with id: " + application.getUniqueIdentifier()); |
| } else { |
| log.error("Service " + applicationClusterContext.getCartridgeType() + " not found"); |
| return; |
| } |
| } |
| |
| // add to Applications and update |
| applications.addApplication(application); |
| ApplicationHolder.persistApplication(applications); |
| |
| log.info("Application with id [ " + application.getUniqueIdentifier() + " ] added to Applications successfully"); |
| org.apache.stratos.messaging.event.applications.ApplicationCreatedEvent applicationCreatedEvent = new org.apache.stratos.messaging.event.applications.ApplicationCreatedEvent(application, clusters); |
| ApplicationsEventPublisher.sendApplicationCreatedEvent(applicationCreatedEvent); |
| |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| }*/ |
| |
| /*public static synchronized void handleApplicationUndeployed(String applicationId) { |
| |
| Set<ClusterDataHolder> clusterData; |
| |
| // update the Application and Cluster Statuses as 'Terminating' |
| ApplicationHolder.acquireWriteLock(); |
| |
| try { |
| |
| Applications applications = ApplicationHolder.getApplications(); |
| |
| if (!applications.applicationExists(applicationId)) { |
| log.warn("Application with id [ " + applicationId + " ] doesn't exist in Applications"); |
| return; |
| } |
| |
| Application application = applications.getApplication(applicationId); |
| // check and update application status to 'Terminating' |
| if (!application.isStateTransitionValid(ApplicationStatus.Terminating)) { |
| log.error("Invalid state transfer from " + application.getStatus() + " to " + ApplicationStatus.Terminating); |
| } |
| // for now anyway update the status forcefully |
| application.setStatus(ApplicationStatus.Terminating); |
| |
| // update all the Clusters' statuses to 'Terminating' |
| clusterData = application.getClusterDataRecursively(); |
| for (ClusterDataHolder clusterDataHolder : clusterData) { |
| Service service = applications.getService(clusterDataHolder.getServiceType()); |
| if (service != null) { |
| Cluster aCluster = service.getCluster(clusterDataHolder.getClusterId()); |
| if (aCluster != null) { |
| // validate state transition |
| if (!aCluster.isStateTransitionValid(ClusterStatus.Terminating)) { |
| log.error("Invalid state transfer from " + aCluster.getStatus() + " to " |
| + ClusterStatus.Terminating); |
| } |
| // for now anyway update the status forcefully |
| aCluster.setStatus(ClusterStatus.Terminating); |
| |
| } else { |
| log.warn("Unable to find Cluster with cluster id " + clusterDataHolder.getClusterId() + |
| " in Applications"); |
| } |
| |
| } else { |
| log.warn("Unable to remove cluster with cluster id: " + clusterDataHolder.getClusterId() + " from Applications, " + |
| " associated Service [ " + clusterDataHolder.getServiceType() + " ] not found"); |
| } |
| } |
| |
| // update all Group's statuses to 'Terminating' |
| if (application.getGroups() != null) { |
| updateGroupStatusesRecursively(GroupStatus.Terminating, application.getGroups()); |
| } |
| |
| ApplicationHolder.persistApplication(applications); |
| |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| |
| ApplicationsEventPublisher.sendApplicationUndeployedEvent(applicationId, clusterData); |
| }*/ |
| |
| public static synchronized void handleCompleteApplication (Applications applications) { |
| if(log.isDebugEnabled()) { |
| log.debug("Handling complete application"); |
| } |
| |
| ApplicationHolder.acquireReadLock(); |
| try { |
| ApplicationsEventPublisher.sendCompleteApplicationsEvent(applications); |
| } finally { |
| ApplicationHolder.releaseReadLock(); |
| } |
| } |
| |
| public static synchronized void handleApplicationCreated (Application application, |
| Set<ApplicationClusterContext> appClusterContexts) { |
| |
| ApplicationHolder.acquireWriteLock(); |
| |
| Applications applications = ApplicationHolder.getApplications(); |
| |
| try { |
| if (applications.getApplication(application.getUniqueIdentifier()) == null) { |
| CloudControllerClient.getInstance().createApplicationClusters(application.getUniqueIdentifier(), |
| appClusterContexts); |
| ApplicationHolder.persistApplication(application); |
| // startApplicationMonitor(application.getUniqueIdentifier()); |
| } else { |
| log.warn("Application [ " + application.getUniqueIdentifier() + " ] already exists in Applications"); |
| } |
| |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| |
| ApplicationsEventPublisher.sendApplicationCreatedEvent(application); |
| } |
| |
| public static void handleApplicationUndeployed (String applicationId) { |
| |
| Applications applications = ApplicationHolder.getApplications(); |
| |
| ApplicationHolder.acquireWriteLock(); |
| Application applicationToRemove = applications.getApplication(applicationId); |
| Set<ClusterDataHolder> clusterData = null; |
| |
| try { |
| if (applicationToRemove != null) { |
| clusterData = applicationToRemove.getClusterDataRecursively(); |
| ApplicationHolder.removeApplication(applicationId); |
| } else { |
| log.warn("Application [ " + applicationId + " ] not found among existing Applications"); |
| } |
| |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| |
| ApplicationsEventPublisher.sendApplicationUndeployedEvent(applicationId, clusterData); |
| } |
| |
| public static void handleGroupTerminatedEvent(String appId, String groupId) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(appId); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| appId)); |
| return; |
| } |
| |
| Group group = application.getGroupRecursively(groupId); |
| if (group == null) { |
| log.warn(String.format("Group %s does not exist", |
| groupId)); |
| return; |
| } |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| GroupStatus status = GroupStatus.Terminated; |
| if (group.isStateTransitionValid(status)) { |
| log.info("Group Terminated adding status started for " + group.getUniqueIdentifier()); |
| group.setStatus(status); |
| //updating the groupMonitor |
| updateGroupMonitor(appId, groupId, status); |
| //publishing data |
| ApplicationsEventPublisher.sendGroupTerminatedEvent(appId, groupId); |
| } else { |
| log.warn("Terminated is not in the possible state list of [group] " + groupId); |
| } |
| ApplicationHolder.persistApplication(application); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| } |
| |
| public static void handleGroupActivatedEvent(String appId, String groupId) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(appId); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| appId)); |
| return; |
| } |
| |
| Group group = application.getGroupRecursively(groupId); |
| if (group == null) { |
| log.warn(String.format("Group %s does not exist", |
| groupId)); |
| return; |
| } |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| GroupStatus status = GroupStatus.Active; |
| if (group.isStateTransitionValid(status)) { |
| log.info("Group Active adding status started for " + group.getUniqueIdentifier()); |
| group.setStatus(status); |
| //updating the groupMonitor |
| updateGroupMonitor(appId, groupId, status); |
| //publishing data |
| ApplicationsEventPublisher.sendGroupActivatedEvent(appId, groupId); |
| } else { |
| log.warn("Active is not in the possible state list of [group] " + groupId); |
| } |
| ApplicationHolder.persistApplication(application); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| } |
| |
| public static void handleGroupCreatedEvent(String appId, String groupId) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(appId); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| appId)); |
| return; |
| } |
| |
| Group group = application.getGroupRecursively(groupId); |
| if (group == null) { |
| log.warn(String.format("Group %s does not exist", |
| groupId)); |
| return; |
| } |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| GroupStatus status = GroupStatus.Created; |
| if (group.isStateTransitionValid(status)) { |
| log.info("Group created adding status started for " + group.getUniqueIdentifier()); |
| group.setStatus(status); |
| //updating the groupMonitor |
| updateGroupMonitor(appId, groupId, status); |
| //publishing data |
| ApplicationsEventPublisher.sendGroupCreatedEvent(appId, groupId); |
| } else { |
| log.warn("Created is not in the possible state list of [group] " + groupId); |
| } |
| ApplicationHolder.persistApplication(application); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| |
| } |
| |
| public static void handleGroupInActivateEvent(String appId, String groupId) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(appId); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| appId)); |
| return; |
| } |
| |
| Group group = application.getGroupRecursively(groupId); |
| if (group == null) { |
| log.warn(String.format("Group %s does not exist", |
| groupId)); |
| return; |
| } |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| GroupStatus status = GroupStatus.Inactive; |
| if (group.isStateTransitionValid(status)) { |
| log.info("Group Inactive adding status started for " + group.getUniqueIdentifier()); |
| group.setStatus(status); |
| //updating the groupMonitor |
| updateGroupMonitor(appId, groupId, status); |
| //publishing data |
| ApplicationsEventPublisher.sendGroupInActivateEvent(appId, groupId); |
| } else { |
| log.warn("Inactive is not in the possible state list of [group] " + groupId); |
| } |
| ApplicationHolder.persistApplication(application); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| } |
| |
| public static void handleGroupTerminatingEvent(String appId, String groupId) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(appId); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| appId)); |
| return; |
| } |
| |
| Group group = application.getGroupRecursively(groupId); |
| if (group == null) { |
| log.warn(String.format("Group %s does not exist", |
| groupId)); |
| return; |
| } |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| GroupStatus status = GroupStatus.Terminating; |
| if (group.isStateTransitionValid(status)) { |
| log.info("Group Terminating adding status started for " + group.getUniqueIdentifier()); |
| group.setStatus(status); |
| //updating the groupMonitor |
| updateGroupMonitor(appId, groupId, status); |
| //publishing data |
| ApplicationsEventPublisher.sendGroupTerminatingEvent(appId, groupId); |
| } else { |
| log.warn("Terminating is not in the possible state list of [group] " + groupId); |
| } |
| ApplicationHolder.persistApplication(application); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| } |
| |
| public static void handleApplicationActivatedEvent(String appId) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(appId); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| appId)); |
| return; |
| } |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| ApplicationStatus status = ApplicationStatus.Active; |
| if(application.isStateTransitionValid(status)) { |
| application.setStatus(status); |
| updateApplicationMonitor(appId, status); |
| log.info("Application activated adding status started for Applications"); |
| ApplicationHolder.persistApplication(application); |
| //publishing data |
| ApplicationsEventPublisher.sendApplicationActivatedEvent(appId); |
| } |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| |
| } |
| |
| /*public static void handleApplicationCreatedEvent(ApplicationCreatedEvent event) { |
| Applications applications = ApplicationHolder.getApplications(); |
| Application application = applications.getApplication(event.getAppId()); |
| //update the status of the Group |
| if (application == null) { |
| log.warn(String.format("Application %s does not exist", |
| event.getAppId())); |
| return; |
| } |
| List<Cluster> clusters = new ArrayList<Cluster>(); |
| Set<ClusterDataHolder> allClusters = application.getClusterDataRecursively(); |
| |
| for (ClusterDataHolder clusterDataHolder : allClusters) { |
| String clusterId = clusterDataHolder.getClusterId(); |
| String serviceName = clusterDataHolder.getServiceType(); |
| clusters.add(ApplicationHolder.getApplications().getService(serviceName).getCluster(clusterId)); |
| } |
| org.apache.stratos.messaging.event.applications.ApplicationCreatedEvent applicationActivatedEvent = |
| new org.apache.stratos.messaging.event.applications.ApplicationCreatedEvent( |
| application, clusters); |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| application.setStatus(ApplicationStatus.Created); |
| log.info("Application created adding status started for Applications"); |
| |
| ApplicationHolder.persistApplication(applications); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| //publishing data |
| ApplicationsEventPublisher.sendApplicationCreatedEvent(applicationActivatedEvent); |
| }*/ |
| |
| public static void handleApplicationTerminatingEvent(String appId) { |
| |
| String applicationId = appId; |
| |
| // update the Application Status as 'Terminating' |
| ApplicationHolder.acquireWriteLock(); |
| |
| try { |
| |
| Applications applications = ApplicationHolder.getApplications(); |
| |
| if (!applications.applicationExists(applicationId)) { |
| log.warn("Application with id [ " + applicationId + " ] doesn't exist in Applications"); |
| return; |
| } |
| |
| Application application = applications.getApplication(applicationId); |
| // check and update application status to 'Terminating' |
| ApplicationStatus status = ApplicationStatus.Terminating; |
| if (!application.isStateTransitionValid(status)) { |
| log.error("Invalid state transfer from " + application.getStatus() + " to " + ApplicationStatus.Terminating); |
| } |
| // for now anyway update the status forcefully |
| application.setStatus(status); |
| log.info("Application " + applicationId + "'s status updated to " + ApplicationStatus.Terminating); |
| updateApplicationMonitor(appId, status); |
| ApplicationsEventPublisher.sendApplicationTerminatingEvent(applicationId); |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| |
| } |
| |
| private static void updateGroupStatusesRecursively(GroupStatus groupStatus, Collection<Group> groups) { |
| |
| for (Group group : groups) { |
| if (!group.isStateTransitionValid(groupStatus)) { |
| log.error("Invalid state transfer from " + group.getStatus() + " to " + groupStatus); |
| } |
| // force update for now |
| group.setStatus(groupStatus); |
| |
| // go recursively and update |
| if (group.getGroups() != null) { |
| updateGroupStatusesRecursively(groupStatus, group.getGroups()); |
| } |
| } |
| } |
| |
| public static void handleApplicationTerminatedEvent(String appId) { |
| |
| Applications applications = ApplicationHolder.getApplications(); |
| |
| try { |
| ApplicationHolder.acquireWriteLock(); |
| |
| if (!applications.applicationExists(appId)) { |
| log.warn("Application with id [ " + appId + " ] doesn't exist in Applications"); |
| //ApplicationsEventPublisher.sendApplicationRemovedEvent(applicationId, tenantId, tenantDomain); |
| |
| } else { |
| Application application = applications.getApplication(appId); |
| |
| if (!application.isStateTransitionValid(ApplicationStatus.Terminated)) { |
| log.error("Invalid status change from " + application.getStatus() + " to " + ApplicationStatus.Terminated); |
| } |
| // forcefully set status for now |
| application.setStatus(ApplicationStatus.Terminated); |
| updateApplicationMonitor(appId, ApplicationStatus.Terminated); |
| |
| int tenantId = application.getTenantId(); |
| String tenantDomain = application.getTenantDomain(); |
| Set<ClusterDataHolder> clusterData = application.getClusterDataRecursively(); |
| // remove clusters |
| /*for (ClusterDataHolder clusterDataHolder : clusterData) { |
| Service service = applications.getService(clusterDataHolder.getServiceType()); |
| if (service != null) { |
| // remove Cluster |
| service.removeCluster(clusterDataHolder.getClusterId()); |
| |
| if (log.isDebugEnabled()) { |
| log.debug("Removed cluster with id " + clusterDataHolder.getClusterId()); |
| } |
| } else { |
| log.warn("Unable to remove cluster with cluster id: " + clusterDataHolder.getClusterId() + " from Applications, " + |
| " associated Service [ " + clusterDataHolder.getServiceType() + " ] npt found"); |
| } |
| |
| // remove runtime data |
| FasterLookUpDataHolder dataHolder = FasterLookUpDataHolder.getInstance(); |
| dataHolder.removeClusterContext(clusterDataHolder.getClusterId()); |
| if (log.isDebugEnabled()) { |
| log.debug("Removed Cluster Context for Cluster id: " + clusterDataHolder.getClusterId()); |
| } |
| |
| try { |
| RegistryManager.getInstance().persist(dataHolder); |
| } catch (RegistryException e) { |
| log.error("Unable to persist data in Registry", e); |
| } |
| } |
| |
| |
| // remove application |
| applications.removeApplication(event.getAppId()); |
| ApplicationHolder.persistApplication(applications); |
| |
| deleteAppResourcesFromMetadataService(event); |
| |
| log.info("Removed application [ " + event.getAppId() + " ] from Applications"); |
| |
| ApplicationsEventPublisher.sendApplicationTerminatedEvent(new org.apache.stratos.messaging.event.applications.ApplicationTerminatedEvent(event.getAppId(), |
| clusterData, tenantId, tenantDomain))*/ |
| ; |
| } |
| |
| } finally { |
| ApplicationHolder.releaseWriteLock(); |
| } |
| } |
| |
| |
| protected static synchronized void startApplicationMonitor(String appId) { |
| |
| ApplicationMonitor applicationMonitor = null; |
| int retries = 5; |
| boolean success = false; |
| do { |
| try { |
| Thread.sleep(5000); |
| } catch (InterruptedException e1) { |
| } |
| try { |
| long start = System.currentTimeMillis(); |
| if (log.isDebugEnabled()) { |
| log.debug("application monitor is going to be started for [application] " + |
| appId); |
| } |
| applicationMonitor = ApplicationMonitorFactory.getApplicationMonitor(appId); |
| |
| long end = System.currentTimeMillis(); |
| log.info("Time taken to start app monitor: " + (end - start) / 1000); |
| success = true; |
| } catch (DependencyBuilderException e) { |
| String msg = "Application monitor creation failed for Application: "; |
| log.warn(msg, e); |
| retries--; |
| } catch (TopologyInConsistentException e) { |
| String msg = "Application monitor creation failed for Application: "; |
| log.warn(msg, e); |
| retries--; |
| } |
| } while (!success && retries != 0); |
| |
| if (applicationMonitor == null) { |
| String msg = "Application monitor creation failed, even after retrying for 5 times, " |
| + "for Application: " + appId; |
| log.error(msg); |
| throw new RuntimeException(msg); |
| } |
| |
| AutoscalerContext.getInstance().addAppMonitor(applicationMonitor); |
| |
| if (log.isInfoEnabled()) { |
| log.info(String.format("Application monitor has been added successfully: " + |
| "[application] %s", applicationMonitor.getId())); |
| } |
| } |
| |
| |
| /*Thread th = null; |
| if (!AutoscalerContext.getInstance() |
| .appMonitorExist(applicationId)) { |
| th = new Thread( |
| new ApplicationMonitorAdder(applicationId)); |
| } |
| |
| if (th != null) { |
| th.start(); |
| // try { |
| // th.join(); |
| // } catch (InterruptedException ignore) { |
| |
| if (log.isDebugEnabled()) { |
| log.debug(String |
| .format("Application monitor thread has been started successfully: " + |
| "[application] %s ", applicationId)); |
| } |
| } else { |
| if (log.isDebugEnabled()) { |
| log.debug(String |
| .format("Application monitor thread already exists: " + |
| "[application] %s ", applicationId)); |
| } |
| }*/ |
| |
| |
| private class ApplicationMonitorAdder implements Runnable { |
| private String appId; |
| |
| public ApplicationMonitorAdder(String appId) { |
| this.appId = appId; |
| } |
| |
| public void run() { |
| ApplicationMonitor applicationMonitor = null; |
| int retries = 5; |
| boolean success = false; |
| do { |
| try { |
| Thread.sleep(5000); |
| } catch (InterruptedException e1) { |
| } |
| try { |
| long start = System.currentTimeMillis(); |
| if (log.isDebugEnabled()) { |
| log.debug("application monitor is going to be started for [application] " + |
| appId); |
| } |
| applicationMonitor = ApplicationMonitorFactory.getApplicationMonitor(appId); |
| |
| long end = System.currentTimeMillis(); |
| log.info("Time taken to start app monitor: " + (end - start) / 1000); |
| success = true; |
| } catch (DependencyBuilderException e) { |
| String msg = "Application monitor creation failed for Application: "; |
| log.warn(msg, e); |
| retries--; |
| } catch (TopologyInConsistentException e) { |
| String msg = "Application monitor creation failed for Application: "; |
| log.warn(msg, e); |
| retries--; |
| } |
| } while (!success && retries != 0); |
| |
| if (applicationMonitor == null) { |
| String msg = "Application monitor creation failed, even after retrying for 5 times, " |
| + "for Application: " + appId; |
| log.error(msg); |
| throw new RuntimeException(msg); |
| } |
| |
| AutoscalerContext.getInstance().addAppMonitor(applicationMonitor); |
| |
| if (log.isInfoEnabled()) { |
| log.info(String.format("Application monitor has been added successfully: " + |
| "[application] %s", applicationMonitor.getId())); |
| } |
| } |
| } |
| |
| |
| private static void updateApplicationMonitor(String appId, ApplicationStatus status) { |
| //Updating the Application Monitor |
| ApplicationMonitor applicationMonitor = AutoscalerContext.getInstance().getAppMonitor(appId); |
| if(applicationMonitor != null) { |
| applicationMonitor.setStatus(status); |
| } else { |
| //TODO |
| } |
| |
| } |
| |
| private static void updateGroupMonitor(String appId, String groupId, GroupStatus status) { |
| //Updating the Application Monitor |
| ApplicationMonitor applicationMonitor = AutoscalerContext.getInstance().getAppMonitor(appId); |
| if(applicationMonitor != null) { |
| GroupMonitor monitor = (GroupMonitor) applicationMonitor.findGroupMonitorWithId(groupId); |
| if(monitor != null) { |
| monitor.setStatus(status); |
| } else { |
| //TODO |
| } |
| } |
| |
| } |
| } |
