apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-11-02 20:02: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.user.ResourceLimitService;
import com.cloud.utils.IdentityProxy; import com.cloud.utils.IdentityProxy;
import com.cloud.utils.Pair; import com.cloud.utils.Pair;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.ComponentLocator;
import com.cloud.vm.BareMetalVmService; import com.cloud.vm.BareMetalVmService;
import com.cloud.vm.UserVmService; import com.cloud.vm.UserVmService;
@ -140,35 +141,46 @@ public abstract class BaseCmd {
public static Site2SiteVpnService _s2sVpnService; public static Site2SiteVpnService _s2sVpnService;
static void setComponents(ResponseGenerator generator) { static void setComponents(ResponseGenerator generator) {
ComponentLocator locator = ComponentLocator.getLocator(ManagementService.Name); _mgr = (ManagementService) ComponentContext.getCompanent(ManagementService.class);
_mgr = (ManagementService) ComponentLocator.getComponent(ManagementService.Name); _accountService = ComponentContext.getCompanent(AccountService.class);
_accountService = locator.getManager(AccountService.class); _configService = ComponentContext.getCompanent(ConfigurationService.class);
_configService = locator.getManager(ConfigurationService.class);
_userVmService = locator.getManager(UserVmService.class); _userVmService = ComponentContext.getCompanent(UserVmService.class);
_storageService = locator.getManager(StorageService.class);
_resourceService = locator.getManager(ResourceService.class); // TODO, ugly and will change soon
_networkService = locator.getManager(NetworkService.class); //
_templateService = locator.getManager(TemplateService.class); Map<String, UserVmService> svmServices = ComponentContext.getComponentsOfType(UserVmService.class);
_securityGroupService = locator.getManager(SecurityGroupService.class); _userVmService = svmServices.get("BareMetalVmManagerImpl");
_snapshotService = locator.getManager(SnapshotService.class);
_consoleProxyService = locator.getManager(ConsoleProxyService.class); _storageService = ComponentContext.getCompanent(StorageService.class);
_routerService = locator.getManager(VpcVirtualNetworkApplianceService.class); _resourceService = ComponentContext.getCompanent(ResourceService.class);
_entityMgr = locator.getManager(EntityManager.class); _networkService = ComponentContext.getCompanent(NetworkService.class);
_rulesService = locator.getManager(RulesService.class); _templateService = ComponentContext.getCompanent(TemplateService.class);
_lbService = locator.getManager(LoadBalancingRulesService.class);
_ravService = locator.getManager(RemoteAccessVpnService.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; _responseGenerator = generator;
_bareMetalVmService = locator.getManager(BareMetalVmService.class); _bareMetalVmService = ComponentContext.getCompanent(BareMetalVmService.class);
_projectService = locator.getManager(ProjectService.class); _projectService = ComponentContext.getCompanent(ProjectService.class);
_firewallService = locator.getManager(FirewallService.class); _firewallService = ComponentContext.getCompanent(FirewallService.class);
_domainService = locator.getManager(DomainService.class); _domainService = ComponentContext.getCompanent(DomainService.class);
_resourceLimitService = locator.getManager(ResourceLimitService.class); _resourceLimitService = ComponentContext.getCompanent(ResourceLimitService.class);
_identityService = locator.getManager(IdentityService.class); _identityService = ComponentContext.getCompanent(IdentityService.class);
_storageNetworkService = locator.getManager(StorageNetworkService.class); _storageNetworkService = ComponentContext.getCompanent(StorageNetworkService.class);
_taggedResourceService = locator.getManager(TaggedResourceService.class); _taggedResourceService = ComponentContext.getCompanent(TaggedResourceService.class);
_vpcService = locator.getManager(VpcService.class); _vpcService = ComponentContext.getCompanent(VpcService.class);
_networkACLService = locator.getManager(NetworkACLService.class); _networkACLService = ComponentContext.getCompanent(NetworkACLService.class);
_s2sVpnService = locator.getManager(Site2SiteVpnService.class); _s2sVpnService = ComponentContext.getCompanent(Site2SiteVpnService.class);
} }
public abstract void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException, NetworkRuleConflictException; 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.StringTokenizer;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import javax.inject.Inject;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import com.cloud.api.BaseCmd.CommandType; import com.cloud.api.BaseCmd.CommandType;
@ -44,6 +46,7 @@ import com.cloud.server.ManagementServer;
import com.cloud.user.Account; import com.cloud.user.Account;
import com.cloud.user.UserContext; import com.cloud.user.UserContext;
import com.cloud.utils.DateUtil; import com.cloud.utils.DateUtil;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.component.PluggableService; import com.cloud.utils.component.PluggableService;
import com.cloud.utils.exception.CSExceptionErrorCode; import com.cloud.utils.exception.CSExceptionErrorCode;
@ -56,21 +59,21 @@ import com.cloud.uuididentity.dao.IdentityDao;
public class ApiDispatcher { public class ApiDispatcher {
private static final Logger s_logger = Logger.getLogger(ApiDispatcher.class.getName()); private static final Logger s_logger = Logger.getLogger(ApiDispatcher.class.getName());
ComponentLocator _locator; @Inject AsyncJobManager _asyncMgr;
AsyncJobManager _asyncMgr; @Inject IdentityDao _identityDao;
IdentityDao _identityDao;
// singleton class // singleton class
private static ApiDispatcher s_instance = new ApiDispatcher(); private static ApiDispatcher s_instance;
public static ApiDispatcher getInstance() { public static ApiDispatcher getInstance() {
if(s_instance == null) {
s_instance = new ApiDispatcher();
s_instance = ComponentContext.inject(s_instance);
}
return s_instance; return s_instance;
} }
private ApiDispatcher() { public ApiDispatcher() {
_locator = ComponentLocator.getLocator(ManagementServer.Name);
_asyncMgr = _locator.getManager(AsyncJobManager.class);
_identityDao = _locator.getDao(IdentityDao.class);
} }
public void dispatchCreateCmd(BaseAsyncCreateCmd cmd, Map<String, String> params) { 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.IdentityProxy;
import com.cloud.utils.Pair; import com.cloud.utils.Pair;
import com.cloud.utils.PropertiesUtil; import com.cloud.utils.PropertiesUtil;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.component.PluggableService; import com.cloud.utils.component.PluggableService;
import com.cloud.utils.concurrency.NamedThreadFactory; 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.utils.exception.CSExceptionErrorCode;
import com.cloud.uuididentity.dao.IdentityDao; import com.cloud.uuididentity.dao.IdentityDao;
@Component
public class ApiServer implements HttpRequestHandler { public class ApiServer implements HttpRequestHandler {
private static final Logger s_logger = Logger.getLogger(ApiServer.class.getName()); private static final Logger s_logger = Logger.getLogger(ApiServer.class.getName());
private static final Logger s_accessLogger = Logger.getLogger("apiserver." + 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"; public static String jsonContentType = "text/javascript";
private Properties _apiCommands = null; private Properties _apiCommands = null;
private ApiDispatcher _dispatcher; private ApiDispatcher _dispatcher;
private AccountManager _accountMgr = null; @Inject private AccountManager _accountMgr;
private DomainManager _domainMgr = null; @Inject private DomainManager _domainMgr;
private AsyncJobManager _asyncMgr = null; @Inject private AsyncJobManager _asyncMgr;
private Account _systemAccount = null; @Inject private ConfigurationDao _configDao;
private User _systemUser = null; private Account _systemAccount;
private User _systemUser;
@Inject List<PluggableService> _pluggableServices; @Inject List<PluggableService> _pluggableServices;
@ -167,6 +168,7 @@ public class ApiServer implements HttpRequestHandler {
public static void initApiServer(String[] apiConfig) { public static void initApiServer(String[] apiConfig) {
if (s_instance == null) { if (s_instance == null) {
s_instance = new ApiServer(); s_instance = new ApiServer();
s_instance = ComponentContext.inject(s_instance);
s_instance.init(apiConfig); s_instance.init(apiConfig);
} }
} }
@ -272,19 +274,15 @@ public class ApiServer implements HttpRequestHandler {
String[] pluggableServicesApiConfigs = getPluggableServicesApiConfigs(); String[] pluggableServicesApiConfigs = getPluggableServicesApiConfigs();
processConfigFiles(pluggableServicesApiConfigs, true); processConfigFiles(pluggableServicesApiConfigs, true);
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
_accountMgr = locator.getManager(AccountManager.class);
_asyncMgr = locator.getManager(AsyncJobManager.class);
_systemAccount = _accountMgr.getSystemAccount(); _systemAccount = _accountMgr.getSystemAccount();
_systemUser = _accountMgr.getSystemUser(); _systemUser = _accountMgr.getSystemUser();
_dispatcher = ApiDispatcher.getInstance(); _dispatcher = ApiDispatcher.getInstance();
_domainMgr = locator.getManager(DomainManager.class);
Integer apiPort = null; // api port, null by default 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"); 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)) { if ((values != null) && (values.size() > 0)) {
ConfigurationVO apiPortConfig = values.get(0); ConfigurationVO apiPortConfig = values.get(0);
if (apiPortConfig.getValue() != null) { 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) { if (jsonType != null) {
jsonContentType = jsonType; 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 javax.naming.ConfigurationException;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import com.cloud.agent.api.Answer; 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;
import com.cloud.vm.VirtualMachineProfile.Param; import com.cloud.vm.VirtualMachineProfile.Param;
// TODO @Component
// @Component @Primary
@Local(value={BareMetalVmManager.class, BareMetalVmService.class}) @Local(value={BareMetalVmManager.class, BareMetalVmService.class})
public class BareMetalVmManagerImpl extends UserVmManagerImpl implements BareMetalVmManager, BareMetalVmService, Manager, public class BareMetalVmManagerImpl extends UserVmManagerImpl implements BareMetalVmManager, BareMetalVmService, Manager,
StateListener<State, VirtualMachine.Event, VirtualMachine> { 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.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import javax.crypto.Mac; import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec; import javax.crypto.spec.SecretKeySpec;
import javax.inject.Inject; import javax.inject.Inject;
import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.binary.Base64;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import com.cloud.acl.SecurityChecker.AccessType; import com.cloud.acl.SecurityChecker.AccessType;
import com.cloud.agent.AgentManager; import com.cloud.agent.AgentManager;
@ -217,6 +219,7 @@ import com.cloud.utils.Pair;
import com.cloud.utils.PasswordGenerator; import com.cloud.utils.PasswordGenerator;
import com.cloud.utils.Ternary; import com.cloud.utils.Ternary;
import com.cloud.utils.component.Adapters; import com.cloud.utils.component.Adapters;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.concurrency.NamedThreadFactory; import com.cloud.utils.concurrency.NamedThreadFactory;
import com.cloud.utils.crypt.DBEncryptionUtil; 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.Arrays;
import edu.emory.mathcs.backport.java.util.Collections; import edu.emory.mathcs.backport.java.util.Collections;
@Component
public class ManagementServerImpl implements ManagementServer { public class ManagementServerImpl implements ManagementServer {
public static final Logger s_logger = Logger.getLogger(ManagementServerImpl.class.getName()); public static final Logger s_logger = Logger.getLogger(ManagementServerImpl.class.getName());
private final AccountManager _accountMgr; @Inject private AccountManager _accountMgr;
private final AgentManager _agentMgr; @Inject private AgentManager _agentMgr;
private final AlertManager _alertMgr; @Inject private AlertManager _alertMgr;
private final IPAddressDao _publicIpAddressDao; @Inject private IPAddressDao _publicIpAddressDao;
private final DomainRouterDao _routerDao; @Inject private DomainRouterDao _routerDao;
private final ConsoleProxyDao _consoleProxyDao; @Inject private ConsoleProxyDao _consoleProxyDao;
private final ClusterDao _clusterDao; @Inject private ClusterDao _clusterDao;
private final SecondaryStorageVmDao _secStorageVmDao; @Inject private SecondaryStorageVmDao _secStorageVmDao;
private final EventDao _eventDao; @Inject private EventDao _eventDao;
private final DataCenterDao _dcDao; @Inject private DataCenterDao _dcDao;
private final VlanDao _vlanDao; @Inject private VlanDao _vlanDao;
private final AccountVlanMapDao _accountVlanMapDao; @Inject private AccountVlanMapDao _accountVlanMapDao;
private final PodVlanMapDao _podVlanMapDao; @Inject private PodVlanMapDao _podVlanMapDao;
private final HostDao _hostDao; @Inject private HostDao _hostDao;
private final HostDetailsDao _detailsDao; @Inject private HostDetailsDao _detailsDao;
private final UserDao _userDao; @Inject private UserDao _userDao;
private final UserVmDao _userVmDao; @Inject private UserVmDao _userVmDao;
private final ConfigurationDao _configDao; @Inject private ConfigurationDao _configDao;
private final ConsoleProxyManager _consoleProxyMgr; @Inject private ConsoleProxyManager _consoleProxyMgr;
private final SecondaryStorageVmManager _secStorageVmMgr; @Inject private SecondaryStorageVmManager _secStorageVmMgr;
private final SwiftManager _swiftMgr; @Inject private SwiftManager _swiftMgr;
private final ServiceOfferingDao _offeringsDao; @Inject private ServiceOfferingDao _offeringsDao;
private final DiskOfferingDao _diskOfferingDao; @Inject private DiskOfferingDao _diskOfferingDao;
private final VMTemplateDao _templateDao; @Inject private VMTemplateDao _templateDao;
private final DomainDao _domainDao; @Inject private DomainDao _domainDao;
private final AccountDao _accountDao; @Inject private AccountDao _accountDao;
private final AlertDao _alertDao; @Inject private AlertDao _alertDao;
private final CapacityDao _capacityDao; @Inject private CapacityDao _capacityDao;
private final GuestOSDao _guestOSDao; @Inject private GuestOSDao _guestOSDao;
private final GuestOSCategoryDao _guestOSCategoryDao; @Inject private GuestOSCategoryDao _guestOSCategoryDao;
private final StoragePoolDao _poolDao; @Inject private StoragePoolDao _poolDao;
private final NicDao _nicDao; @Inject private NicDao _nicDao;
private final NetworkDao _networkDao; @Inject private NetworkDao _networkDao;
private final StorageManager _storageMgr; @Inject private StorageManager _storageMgr;
private final VirtualMachineManager _itMgr; @Inject private VirtualMachineManager _itMgr;
private final HostPodDao _hostPodDao; @Inject private HostPodDao _hostPodDao;
private final VMInstanceDao _vmInstanceDao; @Inject private VMInstanceDao _vmInstanceDao;
private final VolumeDao _volumeDao; @Inject private VolumeDao _volumeDao;
private final AsyncJobDao _jobDao; @Inject private AsyncJobDao _jobDao;
private final AsyncJobManager _asyncMgr; @Inject private AsyncJobManager _asyncMgr;
private final int _purgeDelay; private int _purgeDelay;
private final InstanceGroupDao _vmGroupDao; @Inject private InstanceGroupDao _vmGroupDao;
private final UploadMonitor _uploadMonitor; @Inject private UploadMonitor _uploadMonitor;
private final UploadDao _uploadDao; @Inject private UploadDao _uploadDao;
private final SSHKeyPairDao _sshKeyPairDao; @Inject private SSHKeyPairDao _sshKeyPairDao;
private final LoadBalancerDao _loadbalancerDao; @Inject private LoadBalancerDao _loadbalancerDao;
private final HypervisorCapabilitiesDao _hypervisorCapabilitiesDao; @Inject private HypervisorCapabilitiesDao _hypervisorCapabilitiesDao;
@Inject @Inject private List<HostAllocator> _hostAllocators;
private List<HostAllocator> _hostAllocators; @Inject private ConfigurationManager _configMgr;
private final ConfigurationManager _configMgr; @Inject private ResourceTagDao _resourceTagDao;
private final ResourceTagDao _resourceTagDao;
@Inject @Inject private ProjectManager _projectMgr;
ProjectManager _projectMgr; @Inject private ResourceManager _resourceMgr;
private final ResourceManager _resourceMgr; @Inject private SnapshotManager _snapshotMgr;
@Inject @Inject private HighAvailabilityManager _haMgr;
SnapshotManager _snapshotMgr; @Inject private HostTagsDao _hostTagsDao;
@Inject
HighAvailabilityManager _haMgr;
@Inject
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; private String _hashKey = null;
protected ManagementServerImpl() { public ManagementServerImpl() {
ComponentLocator locator = ComponentLocator.getLocator(Name); }
_configDao = locator.getDao(ConfigurationDao.class);
_routerDao = locator.getDao(DomainRouterDao.class); @PostConstruct
_eventDao = locator.getDao(EventDao.class); void init() {
_dcDao = locator.getDao(DataCenterDao.class); _configs = _configDao.getConfiguration();
_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);
String value = _configs.get("event.purge.interval"); String value = _configs.get("event.purge.interval");
int cleanup = NumbersUtil.parseInt(value, 60 * 60 * 24); // 1 day. 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.Executors;
import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import com.cloud.resource.ResourceManager; import com.cloud.resource.ResourceManager;
import org.apache.log4j.Logger; 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.dao.VolumeDao;
import com.cloud.storage.secondary.SecondaryStorageVmManager; import com.cloud.storage.secondary.SecondaryStorageVmManager;
import com.cloud.utils.NumbersUtil; import com.cloud.utils.NumbersUtil;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.concurrency.NamedThreadFactory; import com.cloud.utils.concurrency.NamedThreadFactory;
import com.cloud.utils.db.SearchCriteria; import com.cloud.utils.db.SearchCriteria;
@ -75,16 +79,16 @@ public class StatsCollector {
private static StatsCollector s_instance = null; private static StatsCollector s_instance = null;
private ScheduledExecutorService _executor = null; private ScheduledExecutorService _executor = null;
private final AgentManager _agentMgr; @Inject private AgentManager _agentMgr;
private final UserVmManager _userVmMgr; @Inject private UserVmManager _userVmMgr;
private final HostDao _hostDao; @Inject private HostDao _hostDao;
private final UserVmDao _userVmDao; @Inject private UserVmDao _userVmDao;
private final VolumeDao _volsDao; @Inject private VolumeDao _volsDao;
private final StoragePoolDao _storagePoolDao; @Inject private StoragePoolDao _storagePoolDao;
private final StorageManager _storageManager; @Inject private StorageManager _storageManager;
private final StoragePoolHostDao _storagePoolHostDao; @Inject private StoragePoolHostDao _storagePoolHostDao;
private final SecondaryStorageVmManager _ssvmMgr; @Inject private SecondaryStorageVmManager _ssvmMgr;
private final ResourceManager _resourceMgr; @Inject private ResourceManager _resourceMgr;
private ConcurrentHashMap<Long, HostStats> _hostStats = new ConcurrentHashMap<Long, HostStats>(); private ConcurrentHashMap<Long, HostStats> _hostStats = new ConcurrentHashMap<Long, HostStats>();
private final ConcurrentHashMap<Long, VmStats> _VmStats = new ConcurrentHashMap<Long, VmStats>(); 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) { public static StatsCollector getInstance(Map<String, String> configs) {
if (s_instance == null) { 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; return s_instance;
} }
public StatsCollector() {
}
private StatsCollector(Map<String, String> configs) { private void init(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);
_executor = Executors.newScheduledThreadPool(3, new NamedThreadFactory("StatsCollector")); _executor = Executors.newScheduledThreadPool(3, new NamedThreadFactory("StatsCollector"));
hostStatsInterval = NumbersUtil.parseLong(configs.get("host.stats.interval"), 60000L); 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; package com.cloud.servlet;
import java.util.Map; import java.util.Map;
import java.util.Set;
import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener; import javax.servlet.ServletContextListener;
@ -34,8 +33,6 @@ import com.cloud.utils.SerialVersionUID;
import com.cloud.utils.component.ComponentContext; import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.component.ComponentLocator;
import com.cloud.utils.component.SystemIntegrityChecker; 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; import com.cloud.utils.db.GenericDaoBase;
public class CloudStartupServlet extends HttpServlet implements ServletContextListener { public class CloudStartupServlet extends HttpServlet implements ServletContextListener {
@ -49,13 +46,10 @@ public class CloudStartupServlet extends HttpServlet implements ServletContextLi
public void init() throws ServletException { public void init() throws ServletException {
// Save Configuration Values // Save Configuration Values
//ComponentLocator loc = ComponentLocator.getLocator(ConfigurationServer.Name); ConfigurationServer c = (ConfigurationServer)ComponentContext.getCompanent(ConfigurationServer.class);
ConfigurationServer c = (ConfigurationServer)ComponentContext.getCompanent(ConfigurationServer.class);
//ConfigurationServer c = new ConfigurationServerImpl();
try { try {
c.persistDefaultValues(); c.persistDefaultValues();
s_locator = ComponentLocator.getLocator(ManagementServer.Name); ManagementServer ms = (ManagementServer)ComponentContext.getCompanent(ManagementServer.class);
ManagementServer ms = (ManagementServer)ComponentLocator.getComponent(ManagementServer.Name);
ApiServer.initApiServer(ms.getApiConfig()); ApiServer.initApiServer(ms.getApiConfig());
} catch (InvalidParameterValueException ipve) { } catch (InvalidParameterValueException ipve) {
s_logger.error("Exception starting management server ", 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; package com.cloud.utils.component;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.aop.Advisor; import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory; import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor; import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory; import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware; import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import com.cloud.utils.db.TransactionContextBuilder; import com.cloud.utils.db.TransactionContextBuilder;
@ -35,6 +40,8 @@ import com.cloud.utils.db.TransactionContextBuilder;
*/ */
@Component @Component
public class ComponentContext implements ApplicationContextAware { public class ComponentContext implements ApplicationContextAware {
private static final Logger s_logger = Logger.getLogger(ComponentContext.class);
private static ApplicationContext s_appContext; private static ApplicationContext s_appContext;
public void setApplicationContext(ApplicationContext applicationContext) { public void setApplicationContext(ApplicationContext applicationContext) {
@ -52,15 +59,34 @@ public class ComponentContext implements ApplicationContextAware {
public static <T> T getCompanent(Class<T> beanType) { public static <T> T getCompanent(Class<T> beanType) {
assert(s_appContext != null); 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); T instance = s_appContext.getAutowireCapableBeanFactory().createBean(clz);
return inject(instance); return inject(instance);
} }
public static<T> T inject(Object instance) { public static <T> T inject(Object instance) {
// autowire dynamically loaded object // autowire dynamically loaded object
AutowireCapableBeanFactory beanFactory = s_appContext.getAutowireCapableBeanFactory(); AutowireCapableBeanFactory beanFactory = s_appContext.getAutowireCapableBeanFactory();
beanFactory.autowireBean(instance); beanFactory.autowireBean(instance);