apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

First page of Javelin management server bootstraped by Spring is able to show now

Browse Source
This commit is contained in:
Kelven Yang 2013-01-07 15:53:57 -08:00
parent 2d6133c61e
commit 559933f062
9 changed files with 196 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
api/src/com/cloud/api/BaseCmd.java
View File

@ -64,6 +64,7 @@ import com.cloud.user.DomainService;
import com.cloud.user.ResourceLimitService;
import com.cloud.utils.IdentityProxy;
import com.cloud.utils.Pair;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator;
import com.cloud.vm.BareMetalVmService;
import com.cloud.vm.UserVmService;
@ -140,35 +141,46 @@ public abstract class BaseCmd {
public static Site2SiteVpnService _s2sVpnService;
static void setComponents(ResponseGenerator generator) {
ComponentLocator locator = ComponentLocator.getLocator(ManagementService.Name);
_mgr = (ManagementService) ComponentLocator.getComponent(ManagementService.Name);
_accountService = locator.getManager(AccountService.class);
_configService = locator.getManager(ConfigurationService.class);
_userVmService = locator.getManager(UserVmService.class);
_storageService = locator.getManager(StorageService.class);
_resourceService = locator.getManager(ResourceService.class);
_networkService = locator.getManager(NetworkService.class);
_templateService = locator.getManager(TemplateService.class);
_securityGroupService = locator.getManager(SecurityGroupService.class);
_snapshotService = locator.getManager(SnapshotService.class);
_consoleProxyService = locator.getManager(ConsoleProxyService.class);
_routerService = locator.getManager(VpcVirtualNetworkApplianceService.class);
_entityMgr = locator.getManager(EntityManager.class);
_rulesService = locator.getManager(RulesService.class);
_lbService = locator.getManager(LoadBalancingRulesService.class);
_ravService = locator.getManager(RemoteAccessVpnService.class);
_mgr = (ManagementService) ComponentContext.getCompanent(ManagementService.class);
_accountService = ComponentContext.getCompanent(AccountService.class);
_configService = ComponentContext.getCompanent(ConfigurationService.class);
_userVmService = ComponentContext.getCompanent(UserVmService.class);
// TODO, ugly and will change soon
//
Map<String, UserVmService> svmServices = ComponentContext.getComponentsOfType(UserVmService.class);
_userVmService = svmServices.get("BareMetalVmManagerImpl");
_storageService = ComponentContext.getCompanent(StorageService.class);
_resourceService = ComponentContext.getCompanent(ResourceService.class);
_networkService = ComponentContext.getCompanent(NetworkService.class);
_templateService = ComponentContext.getCompanent(TemplateService.class);
// TODO, will change to looking for primary component
// ugly binding to a specific implementation
Map<String, SecurityGroupService> _sgServices = ComponentContext.getComponentsOfType(SecurityGroupService.class);
_securityGroupService = _sgServices.get("SecurityGroupManagerImpl2");
_snapshotService = ComponentContext.getCompanent(SnapshotService.class);
_consoleProxyService = ComponentContext.getCompanent(ConsoleProxyService.class);
_routerService = ComponentContext.getCompanent(VpcVirtualNetworkApplianceService.class);
_entityMgr = ComponentContext.getCompanent(EntityManager.class);
_rulesService = ComponentContext.getCompanent(RulesService.class);
_lbService = ComponentContext.getCompanent(LoadBalancingRulesService.class);
_ravService = ComponentContext.getCompanent(RemoteAccessVpnService.class);
_responseGenerator = generator;
_bareMetalVmService = locator.getManager(BareMetalVmService.class);
_projectService = locator.getManager(ProjectService.class);
_firewallService = locator.getManager(FirewallService.class);
_domainService = locator.getManager(DomainService.class);
_resourceLimitService = locator.getManager(ResourceLimitService.class);
_identityService = locator.getManager(IdentityService.class);
_storageNetworkService = locator.getManager(StorageNetworkService.class);
_taggedResourceService = locator.getManager(TaggedResourceService.class);
_vpcService = locator.getManager(VpcService.class);
_networkACLService = locator.getManager(NetworkACLService.class);
_s2sVpnService = locator.getManager(Site2SiteVpnService.class);
_bareMetalVmService = ComponentContext.getCompanent(BareMetalVmService.class);
_projectService = ComponentContext.getCompanent(ProjectService.class);
_firewallService = ComponentContext.getCompanent(FirewallService.class);
_domainService = ComponentContext.getCompanent(DomainService.class);
_resourceLimitService = ComponentContext.getCompanent(ResourceLimitService.class);
_identityService = ComponentContext.getCompanent(IdentityService.class);
_storageNetworkService = ComponentContext.getCompanent(StorageNetworkService.class);
_taggedResourceService = ComponentContext.getCompanent(TaggedResourceService.class);
_vpcService = ComponentContext.getCompanent(VpcService.class);
_networkACLService = ComponentContext.getCompanent(NetworkACLService.class);
_s2sVpnService = ComponentContext.getCompanent(Site2SiteVpnService.class);
}
public abstract void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException, NetworkRuleConflictException;

16
client/cloudstack-ui.launch
View File

@ -1,16 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<launchConfiguration type="org.eclipse.m2e.Maven2LaunchConfigurationType">
<booleanAttribute key="M2_DEBUG_OUTPUT" value="false"/>
<stringAttribute key="M2_GOALS" value="jetty:run"/>
<booleanAttribute key="M2_NON_RECURSIVE" value="false"/>
<booleanAttribute key="M2_OFFLINE" value="false"/>
<stringAttribute key="M2_PROFILES" value=""/>
<listAttribute key="M2_PROPERTIES"/>
<stringAttribute key="M2_RUNTIME" value="EMBEDDED"/>
<booleanAttribute key="M2_SKIP_TESTS" value="true"/>
<booleanAttribute key="M2_UPDATE_SNAPSHOTS" value="false"/>
<booleanAttribute key="M2_WORKSPACE_RESOLUTION" value="true"/>
<stringAttribute key="org.eclipse.debug.core.source_locator_id" value="org.eclipse.m2e.launching.MavenSourceLocator"/>
<stringAttribute key="org.eclipse.debug.core.source_locator_memento" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#10;&lt;sourceLookupDirector&gt;&#10;&lt;sourceContainers duplicates=&quot;false&quot;&gt;&#10;&lt;container memento=&quot;&amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot; standalone=&amp;quot;no&amp;quot;?&amp;gt;&amp;#10;&amp;lt;workspace/&amp;gt;&amp;#10;&quot; typeId=&quot;org.eclipse.debug.core.containerType.workspace&quot;/&gt;&#10;&lt;container memento=&quot;&amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-8&amp;quot; standalone=&amp;quot;no&amp;quot;?&amp;gt;&amp;#10;&amp;lt;default/&amp;gt;&amp;#10;&quot; typeId=&quot;org.eclipse.debug.core.containerType.default&quot;/&gt;&#10;&lt;/sourceContainers&gt;&#10;&lt;/sourceLookupDirector&gt;&#10;"/>
<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${project_loc:cloud-client-ui}"/>
</launchConfiguration>

19
server/src/com/cloud/api/ApiDispatcher.java
View File

@ -27,6 +27,8 @@ import java.util.Map;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import javax.inject.Inject;
import org.apache.log4j.Logger;
import com.cloud.api.BaseCmd.CommandType;
@ -44,6 +46,7 @@ import com.cloud.server.ManagementServer;
import com.cloud.user.Account;
import com.cloud.user.UserContext;
import com.cloud.utils.DateUtil;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.component.PluggableService;
import com.cloud.utils.exception.CSExceptionErrorCode;
@ -56,21 +59,21 @@ import com.cloud.uuididentity.dao.IdentityDao;
public class ApiDispatcher {
private static final Logger s_logger = Logger.getLogger(ApiDispatcher.class.getName());
ComponentLocator _locator;
AsyncJobManager _asyncMgr;
IdentityDao _identityDao;
@Inject AsyncJobManager _asyncMgr;
@Inject IdentityDao _identityDao;
// singleton class
private static ApiDispatcher s_instance = new ApiDispatcher();
private static ApiDispatcher s_instance;
public static ApiDispatcher getInstance() {
if(s_instance == null) {
s_instance = new ApiDispatcher();
s_instance = ComponentContext.inject(s_instance);
}
return s_instance;
}
private ApiDispatcher() {
_locator = ComponentLocator.getLocator(ManagementServer.Name);
_asyncMgr = _locator.getManager(AsyncJobManager.class);
_identityDao = _locator.getDao(IdentityDao.class);
public ApiDispatcher() {
}
public void dispatchCreateCmd(BaseAsyncCreateCmd cmd, Map<String, String> params) {

30
server/src/com/cloud/api/ApiServer.java
View File

@ -110,6 +110,7 @@ import com.cloud.user.UserVO;
import com.cloud.utils.IdentityProxy;
import com.cloud.utils.Pair;
import com.cloud.utils.PropertiesUtil;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.component.PluggableService;
import com.cloud.utils.concurrency.NamedThreadFactory;
@ -118,7 +119,6 @@ import com.cloud.utils.db.Transaction;
import com.cloud.utils.exception.CSExceptionErrorCode;
import com.cloud.uuididentity.dao.IdentityDao;
@Component
public class ApiServer implements HttpRequestHandler {
private static final Logger s_logger = Logger.getLogger(ApiServer.class.getName());
private static final Logger s_accessLogger = Logger.getLogger("apiserver." + ApiServer.class.getName());
@ -131,11 +131,12 @@ public class ApiServer implements HttpRequestHandler {
public static String jsonContentType = "text/javascript";
private Properties _apiCommands = null;
private ApiDispatcher _dispatcher;
private AccountManager _accountMgr = null;
private DomainManager _domainMgr = null;
private AsyncJobManager _asyncMgr = null;
private Account _systemAccount = null;
private User _systemUser = null;
@Inject private AccountManager _accountMgr;
@Inject private DomainManager _domainMgr;
@Inject private AsyncJobManager _asyncMgr;
@Inject private ConfigurationDao _configDao;
private Account _systemAccount;
private User _systemUser;
@Inject List<PluggableService> _pluggableServices;
@ -167,6 +168,7 @@ public class ApiServer implements HttpRequestHandler {
public static void initApiServer(String[] apiConfig) {
if (s_instance == null) {
s_instance = new ApiServer();
s_instance = ComponentContext.inject(s_instance);
s_instance.init(apiConfig);
}
}
@ -272,19 +274,15 @@ public class ApiServer implements HttpRequestHandler {
String[] pluggableServicesApiConfigs = getPluggableServicesApiConfigs();
processConfigFiles(pluggableServicesApiConfigs, true);
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
_accountMgr = locator.getManager(AccountManager.class);
_asyncMgr = locator.getManager(AsyncJobManager.class);
_systemAccount = _accountMgr.getSystemAccount();
_systemUser = _accountMgr.getSystemUser();
_dispatcher = ApiDispatcher.getInstance();
_domainMgr = locator.getManager(DomainManager.class);
Integer apiPort = null; // api port, null by default
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
SearchCriteria<ConfigurationVO> sc = configDao.createSearchCriteria();
SearchCriteria<ConfigurationVO> sc = _configDao.createSearchCriteria();
sc.addAnd("name", SearchCriteria.Op.EQ, "integration.api.port");
List<ConfigurationVO> values = configDao.search(sc, null);
List<ConfigurationVO> values = _configDao.search(sc, null);
if ((values != null) && (values.size() > 0)) {
ConfigurationVO apiPortConfig = values.get(0);
if (apiPortConfig.getValue() != null) {
@ -292,9 +290,9 @@ public class ApiServer implements HttpRequestHandler {
}
}
encodeApiResponse = Boolean.valueOf(configDao.getValue(Config.EncodeApiResponse.key()));
encodeApiResponse = Boolean.valueOf(_configDao.getValue(Config.EncodeApiResponse.key()));
String jsonType = configDao.getValue(Config.JavaScriptDefaultContentType.key());
String jsonType = _configDao.getValue(Config.JavaScriptDefaultContentType.key());
if (jsonType != null) {
jsonContentType = jsonType;
}

5
server/src/com/cloud/baremetal/BareMetalVmManagerImpl.java
View File

@ -28,6 +28,7 @@ import javax.inject.Inject;
import javax.naming.ConfigurationException;
import org.apache.log4j.Logger;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import com.cloud.agent.api.Answer;
@ -104,8 +105,8 @@ import com.cloud.vm.VirtualMachineName;
import com.cloud.vm.VirtualMachineProfile;
import com.cloud.vm.VirtualMachineProfile.Param;
// TODO
// @Component
@Component
@Primary
@Local(value={BareMetalVmManager.class, BareMetalVmService.class})
public class BareMetalVmManagerImpl extends UserVmManagerImpl implements BareMetalVmManager, BareMetalVmService, Manager,
StateListener<State, VirtualMachine.Event, VirtualMachine> {

194
server/src/com/cloud/server/ManagementServerImpl.java
View File

@ -39,12 +39,14 @@ import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import javax.inject.Inject;
import org.apache.commons.codec.binary.Base64;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import com.cloud.acl.SecurityChecker.AccessType;
import com.cloud.agent.AgentManager;
@ -217,6 +219,7 @@ import com.cloud.utils.Pair;
import com.cloud.utils.PasswordGenerator;
import com.cloud.utils.Ternary;
import com.cloud.utils.component.Adapters;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.concurrency.NamedThreadFactory;
import com.cloud.utils.crypt.DBEncryptionUtil;
@ -255,140 +258,89 @@ import com.cloud.vm.dao.VMInstanceDao;
import edu.emory.mathcs.backport.java.util.Arrays;
import edu.emory.mathcs.backport.java.util.Collections;
@Component
public class ManagementServerImpl implements ManagementServer {
public static final Logger s_logger = Logger.getLogger(ManagementServerImpl.class.getName());
private final AccountManager _accountMgr;
private final AgentManager _agentMgr;
private final AlertManager _alertMgr;
private final IPAddressDao _publicIpAddressDao;
private final DomainRouterDao _routerDao;
private final ConsoleProxyDao _consoleProxyDao;
private final ClusterDao _clusterDao;
private final SecondaryStorageVmDao _secStorageVmDao;
private final EventDao _eventDao;
private final DataCenterDao _dcDao;
private final VlanDao _vlanDao;
private final AccountVlanMapDao _accountVlanMapDao;
private final PodVlanMapDao _podVlanMapDao;
private final HostDao _hostDao;
private final HostDetailsDao _detailsDao;
private final UserDao _userDao;
private final UserVmDao _userVmDao;
private final ConfigurationDao _configDao;
private final ConsoleProxyManager _consoleProxyMgr;
private final SecondaryStorageVmManager _secStorageVmMgr;
private final SwiftManager _swiftMgr;
private final ServiceOfferingDao _offeringsDao;
private final DiskOfferingDao _diskOfferingDao;
private final VMTemplateDao _templateDao;
private final DomainDao _domainDao;
private final AccountDao _accountDao;
private final AlertDao _alertDao;
private final CapacityDao _capacityDao;
private final GuestOSDao _guestOSDao;
private final GuestOSCategoryDao _guestOSCategoryDao;
private final StoragePoolDao _poolDao;
private final NicDao _nicDao;
private final NetworkDao _networkDao;
private final StorageManager _storageMgr;
private final VirtualMachineManager _itMgr;
private final HostPodDao _hostPodDao;
private final VMInstanceDao _vmInstanceDao;
private final VolumeDao _volumeDao;
private final AsyncJobDao _jobDao;
private final AsyncJobManager _asyncMgr;
private final int _purgeDelay;
private final InstanceGroupDao _vmGroupDao;
private final UploadMonitor _uploadMonitor;
private final UploadDao _uploadDao;
private final SSHKeyPairDao _sshKeyPairDao;
private final LoadBalancerDao _loadbalancerDao;
private final HypervisorCapabilitiesDao _hypervisorCapabilitiesDao;
@Inject private AccountManager _accountMgr;
@Inject private AgentManager _agentMgr;
@Inject private AlertManager _alertMgr;
@Inject private IPAddressDao _publicIpAddressDao;
@Inject private DomainRouterDao _routerDao;
@Inject private ConsoleProxyDao _consoleProxyDao;
@Inject private ClusterDao _clusterDao;
@Inject private SecondaryStorageVmDao _secStorageVmDao;
@Inject private EventDao _eventDao;
@Inject private DataCenterDao _dcDao;
@Inject private VlanDao _vlanDao;
@Inject private AccountVlanMapDao _accountVlanMapDao;
@Inject private PodVlanMapDao _podVlanMapDao;
@Inject private HostDao _hostDao;
@Inject private HostDetailsDao _detailsDao;
@Inject private UserDao _userDao;
@Inject private UserVmDao _userVmDao;
@Inject private ConfigurationDao _configDao;
@Inject private ConsoleProxyManager _consoleProxyMgr;
@Inject private SecondaryStorageVmManager _secStorageVmMgr;
@Inject private SwiftManager _swiftMgr;
@Inject private ServiceOfferingDao _offeringsDao;
@Inject private DiskOfferingDao _diskOfferingDao;
@Inject private VMTemplateDao _templateDao;
@Inject private DomainDao _domainDao;
@Inject private AccountDao _accountDao;
@Inject private AlertDao _alertDao;
@Inject private CapacityDao _capacityDao;
@Inject private GuestOSDao _guestOSDao;
@Inject private GuestOSCategoryDao _guestOSCategoryDao;
@Inject private StoragePoolDao _poolDao;
@Inject private NicDao _nicDao;
@Inject private NetworkDao _networkDao;
@Inject private StorageManager _storageMgr;
@Inject private VirtualMachineManager _itMgr;
@Inject private HostPodDao _hostPodDao;
@Inject private VMInstanceDao _vmInstanceDao;
@Inject private VolumeDao _volumeDao;
@Inject private AsyncJobDao _jobDao;
@Inject private AsyncJobManager _asyncMgr;
private int _purgeDelay;
@Inject private InstanceGroupDao _vmGroupDao;
@Inject private UploadMonitor _uploadMonitor;
@Inject private UploadDao _uploadDao;
@Inject private SSHKeyPairDao _sshKeyPairDao;
@Inject private LoadBalancerDao _loadbalancerDao;
@Inject private HypervisorCapabilitiesDao _hypervisorCapabilitiesDao;
@Inject
private List<HostAllocator> _hostAllocators;
private final ConfigurationManager _configMgr;
private final ResourceTagDao _resourceTagDao;
@Inject private List<HostAllocator> _hostAllocators;
@Inject private ConfigurationManager _configMgr;
@Inject private ResourceTagDao _resourceTagDao;
@Inject
ProjectManager _projectMgr;
private final ResourceManager _resourceMgr;
@Inject
SnapshotManager _snapshotMgr;
@Inject
HighAvailabilityManager _haMgr;
@Inject
HostTagsDao _hostTagsDao;
@Inject private ProjectManager _projectMgr;
@Inject private ResourceManager _resourceMgr;
@Inject private SnapshotManager _snapshotMgr;
@Inject private HighAvailabilityManager _haMgr;
@Inject private HostTagsDao _hostTagsDao;
private final KeystoreManager _ksMgr;
@Inject ComponentContext _placeholder;
private KeystoreManager _ksMgr;
private final ScheduledExecutorService _eventExecutor = Executors.newScheduledThreadPool(1, new NamedThreadFactory("EventChecker"));
private ScheduledExecutorService _eventExecutor = Executors.newScheduledThreadPool(1, new NamedThreadFactory("EventChecker"));
private final Map<String, String> _configs;
private Map<String, String> _configs;
private final StatsCollector _statsCollector;
private StatsCollector _statsCollector;
private final Map<String, Boolean> _availableIdsMap;
private Map<String, Boolean> _availableIdsMap;
private String _hashKey = null;
protected ManagementServerImpl() {
ComponentLocator locator = ComponentLocator.getLocator(Name);
_configDao = locator.getDao(ConfigurationDao.class);
_routerDao = locator.getDao(DomainRouterDao.class);
_eventDao = locator.getDao(EventDao.class);
_dcDao = locator.getDao(DataCenterDao.class);
_vlanDao = locator.getDao(VlanDao.class);
_accountVlanMapDao = locator.getDao(AccountVlanMapDao.class);
_podVlanMapDao = locator.getDao(PodVlanMapDao.class);
_hostDao = locator.getDao(HostDao.class);
_detailsDao = locator.getDao(HostDetailsDao.class);
_hostPodDao = locator.getDao(HostPodDao.class);
_jobDao = locator.getDao(AsyncJobDao.class);
_clusterDao = locator.getDao(ClusterDao.class);
_nicDao = locator.getDao(NicDao.class);
_networkDao = locator.getDao(NetworkDao.class);
_loadbalancerDao = locator.getDao(LoadBalancerDao.class);
_accountMgr = locator.getManager(AccountManager.class);
_agentMgr = locator.getManager(AgentManager.class);
_alertMgr = locator.getManager(AlertManager.class);
_consoleProxyMgr = locator.getManager(ConsoleProxyManager.class);
_secStorageVmMgr = locator.getManager(SecondaryStorageVmManager.class);
_swiftMgr = locator.getManager(SwiftManager.class);
_storageMgr = locator.getManager(StorageManager.class);
_publicIpAddressDao = locator.getDao(IPAddressDao.class);
_consoleProxyDao = locator.getDao(ConsoleProxyDao.class);
_secStorageVmDao = locator.getDao(SecondaryStorageVmDao.class);
_userDao = locator.getDao(UserDao.class);
_userVmDao = locator.getDao(UserVmDao.class);
_offeringsDao = locator.getDao(ServiceOfferingDao.class);
_diskOfferingDao = locator.getDao(DiskOfferingDao.class);
_templateDao = locator.getDao(VMTemplateDao.class);
_domainDao = locator.getDao(DomainDao.class);
_accountDao = locator.getDao(AccountDao.class);
_alertDao = locator.getDao(AlertDao.class);
_capacityDao = locator.getDao(CapacityDao.class);
_guestOSDao = locator.getDao(GuestOSDao.class);
_guestOSCategoryDao = locator.getDao(GuestOSCategoryDao.class);
_poolDao = locator.getDao(StoragePoolDao.class);
_vmGroupDao = locator.getDao(InstanceGroupDao.class);
_uploadDao = locator.getDao(UploadDao.class);
_configs = _configDao.getConfiguration();
_vmInstanceDao = locator.getDao(VMInstanceDao.class);
_volumeDao = locator.getDao(VolumeDao.class);
_asyncMgr = locator.getManager(AsyncJobManager.class);
_uploadMonitor = locator.getManager(UploadMonitor.class);
_sshKeyPairDao = locator.getDao(SSHKeyPairDao.class);
_itMgr = locator.getManager(VirtualMachineManager.class);
_ksMgr = locator.getManager(KeystoreManager.class);
_resourceMgr = locator.getManager(ResourceManager.class);
_configMgr = locator.getManager(ConfigurationManager.class);
_resourceTagDao = locator.getDao(ResourceTagDao.class);
_hypervisorCapabilitiesDao = locator.getDao(HypervisorCapabilitiesDao.class);
public ManagementServerImpl() {
}
@PostConstruct
void init() {
_configs = _configDao.getConfiguration();
String value = _configs.get("event.purge.interval");
int cleanup = NumbersUtil.parseInt(value, 60 * 60 * 24); // 1 day.

47
server/src/com/cloud/server/StatsCollector.java
View File

@ -26,6 +26,9 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import com.cloud.resource.ResourceManager;
import org.apache.log4j.Logger;
@ -57,6 +60,7 @@ import com.cloud.storage.dao.StoragePoolHostDao;
import com.cloud.storage.dao.VolumeDao;
import com.cloud.storage.secondary.SecondaryStorageVmManager;
import com.cloud.utils.NumbersUtil;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.concurrency.NamedThreadFactory;
import com.cloud.utils.db.SearchCriteria;
@ -75,16 +79,16 @@ public class StatsCollector {
private static StatsCollector s_instance = null;
private ScheduledExecutorService _executor = null;
private final AgentManager _agentMgr;
private final UserVmManager _userVmMgr;
private final HostDao _hostDao;
private final UserVmDao _userVmDao;
private final VolumeDao _volsDao;
private final StoragePoolDao _storagePoolDao;
private final StorageManager _storageManager;
private final StoragePoolHostDao _storagePoolHostDao;
private final SecondaryStorageVmManager _ssvmMgr;
private final ResourceManager _resourceMgr;
@Inject private AgentManager _agentMgr;
@Inject private UserVmManager _userVmMgr;
@Inject private HostDao _hostDao;
@Inject private UserVmDao _userVmDao;
@Inject private VolumeDao _volsDao;
@Inject private StoragePoolDao _storagePoolDao;
@Inject private StorageManager _storageManager;
@Inject private StoragePoolHostDao _storagePoolHostDao;
@Inject private SecondaryStorageVmManager _ssvmMgr;
@Inject private ResourceManager _resourceMgr;
private ConcurrentHashMap<Long, HostStats> _hostStats = new ConcurrentHashMap<Long, HostStats>();
private final ConcurrentHashMap<Long, VmStats> _VmStats = new ConcurrentHashMap<Long, VmStats>();
@ -104,24 +108,19 @@ public class StatsCollector {
}
public static StatsCollector getInstance(Map<String, String> configs) {
if (s_instance == null) {
s_instance = new StatsCollector(configs);
s_instance = new StatsCollector();
s_instance = ComponentContext.inject(s_instance);
s_instance.init(configs);
}
return s_instance;
}
public StatsCollector() {
}
private StatsCollector(Map<String, String> configs) {
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
_agentMgr = locator.getManager(AgentManager.class);
_userVmMgr = locator.getManager(UserVmManager.class);
_ssvmMgr = locator.getManager(SecondaryStorageVmManager.class);
_hostDao = locator.getDao(HostDao.class);
_userVmDao = locator.getDao(UserVmDao.class);
_volsDao = locator.getDao(VolumeDao.class);
_storagePoolDao = locator.getDao(StoragePoolDao.class);
_storageManager = locator.getManager(StorageManager.class);
_storagePoolHostDao = locator.getDao(StoragePoolHostDao.class);
_resourceMgr = locator.getManager(ResourceManager.class);
private void init(Map<String, String> configs) {
_executor = Executors.newScheduledThreadPool(3, new NamedThreadFactory("StatsCollector"));
hostStatsInterval = NumbersUtil.parseLong(configs.get("host.stats.interval"), 60000L);

10
server/src/com/cloud/servlet/CloudStartupServlet.java
View File

@ -17,7 +17,6 @@
package com.cloud.servlet;
import java.util.Map;
import java.util.Set;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
@ -34,8 +33,6 @@ import com.cloud.utils.SerialVersionUID;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.component.SystemIntegrityChecker;
import com.cloud.utils.component.LegacyComponentLocator.ComponentInfo;
import com.cloud.utils.db.GenericDao;
import com.cloud.utils.db.GenericDaoBase;
public class CloudStartupServlet extends HttpServlet implements ServletContextListener {
@ -49,13 +46,10 @@ public class CloudStartupServlet extends HttpServlet implements ServletContextLi
public void init() throws ServletException {
// Save Configuration Values
//ComponentLocator loc = ComponentLocator.getLocator(ConfigurationServer.Name);
ConfigurationServer c = (ConfigurationServer)ComponentContext.getCompanent(ConfigurationServer.class);
//ConfigurationServer c = new ConfigurationServerImpl();
ConfigurationServer c = (ConfigurationServer)ComponentContext.getCompanent(ConfigurationServer.class);
try {
c.persistDefaultValues();
s_locator = ComponentLocator.getLocator(ManagementServer.Name);
ManagementServer ms = (ManagementServer)ComponentLocator.getComponent(ManagementServer.Name);
ManagementServer ms = (ManagementServer)ComponentContext.getCompanent(ManagementServer.class);
ApiServer.initApiServer(ms.getApiConfig());
} catch (InvalidParameterValueException ipve) {
s_logger.error("Exception starting management server ", ipve);

34
utils/src/com/cloud/utils/component/ComponentContext.java
View File

@ -17,12 +17,17 @@
package com.cloud.utils.component;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
import com.cloud.utils.db.TransactionContextBuilder;
@ -35,6 +40,8 @@ import com.cloud.utils.db.TransactionContextBuilder;
*/
@Component
public class ComponentContext implements ApplicationContextAware {
private static final Logger s_logger = Logger.getLogger(ComponentContext.class);
private static ApplicationContext s_appContext;
public void setApplicationContext(ApplicationContext applicationContext) {
@ -52,15 +59,34 @@ public class ComponentContext implements ApplicationContextAware {
public static <T> T getCompanent(Class<T> beanType) {
assert(s_appContext != null);
return (T)s_appContext.getBean(beanType);
try {
return (T)s_appContext.getBean(beanType);
} catch(NoSuchBeanDefinitionException e) {
Map<String, T> matchedTypes = getComponentsOfType(beanType);
if(matchedTypes.size() > 0) {
for(Map.Entry<String, T> entry : matchedTypes.entrySet()) {
Primary primary = entry.getClass().getAnnotation(Primary.class);
if(primary != null)
return entry.getValue();
}
s_logger.warn("Unable to uniquely locate bean type " + beanType.getName(), e);
return (T)matchedTypes.values().toArray()[0];
}
}
throw new NoSuchBeanDefinitionException("Unable to resolve bean type " + beanType.getName());
}
public static<T> T inject(Class<T> clz) {
public static <T> Map<String, T> getComponentsOfType(Class<T> beanType) {
return s_appContext.getBeansOfType(beanType);
}
public static <T> T inject(Class<T> clz) {
T instance = s_appContext.getAutowireCapableBeanFactory().createBean(clz);
return inject(instance);
}
public static<T> T inject(Object instance) {
public static <T> T inject(Object instance) {
// autowire dynamically loaded object
AutowireCapableBeanFactory beanFactory = s_appContext.getAutowireCapableBeanFactory();
beanFactory.autowireBean(instance);