@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
ComponentLocator locator = ComponentLocator.getCurrentLocator();
_configDao = locator.getDao(ConfigurationDao.class);
_setupAgentPath = Script.findScript(getPatchPath(), "setup_agent.sh");
_kvmPrivateNic = _configDao.getValue(Config.KvmPrivateNetwork.key());
if (_kvmPrivateNic == null) {
_kvmPrivateNic = "cloudbr0";
}
_kvmPublicNic = _configDao.getValue(Config.KvmPublicNetwork.key());
if (_kvmPublicNic == null) {
_kvmPublicNic = _kvmPrivateNic;
}
_kvmGuestNic = _configDao.getValue(Config.KvmGuestNetwork.key());
if (_kvmGuestNic == null) {
_kvmGuestNic = _kvmPrivateNic;
}
if (_setupAgentPath == null) {
throw new ConfigurationException("Can't find setup_agent.sh");
}
_hostIp = _configDao.getValue("host");
if (_hostIp == null) {
throw new ConfigurationException("Can't get host IP");
}
_resourceMgr.registerResourceStateAdapter(this.getClass().getSimpleName(), this);
return true;
}
public ApiServlet() {
super();
_apiServer = ApiServer.getInstance();
if (_apiServer == null) {
throw new CloudRuntimeException("ApiServer not initialized");
}
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
_accountMgr = locator.getManager(AccountService.class);
}
public void test217to22Upgrade() throws SQLException {
s_logger.debug("Finding sample data from 2.2.14");
// DbTestUtils.executeScript("PreviousDatabaseSchema/2.2.14/dave-sample.sql", false,
// true);
Connection conn;
PreparedStatement pstmt;
VersionDaoImpl dao = ComponentLocator.inject(VersionDaoImpl.class);
DatabaseUpgradeChecker checker = ComponentLocator.inject(DatabaseUpgradeChecker.class);
String version = dao.getCurrentVersion();
assert version.equals("2.2.14") : "Version returned is not 2.2.14 but " + version;
checker.upgrade("2.2.14", "3.0.3");
}
public static void initApiServer() {
if (s_instance == null) {
// Injection will create ApiServer and all its fields which have @Inject
s_instance = ComponentLocator.inject(ApiServer.class);
s_instance.init();
}
}
@Override
public List<UserVmVO> listVirtualNetworkInstancesByAcctAndZone(long accountId, long dcId) {
if (AccountDataCenterVirtualSearch == null) {
ServiceOfferingDao offeringDao =
ComponentLocator.getLocator("management-server").getDao(ServiceOfferingDao.class);
SearchBuilder<ServiceOfferingVO> offeringSearch = offeringDao.createSearchBuilder();
offeringSearch.and(
"guestIpType", offeringSearch.entity().getGuestIpType(), SearchCriteria.Op.EQ);
AccountDataCenterVirtualSearch = createSearchBuilder();
AccountDataCenterVirtualSearch.and(
"account", AccountDataCenterVirtualSearch.entity().getAccountId(), SearchCriteria.Op.EQ);
AccountDataCenterVirtualSearch.and(
"dc", AccountDataCenterVirtualSearch.entity().getDataCenterId(), SearchCriteria.Op.EQ);
AccountDataCenterVirtualSearch.join(
"offeringSearch",
offeringSearch,
AccountDataCenterVirtualSearch.entity().getServiceOfferingId(),
offeringSearch.entity().getId());
AccountDataCenterVirtualSearch.done();
}
SearchCriteria sc = AccountDataCenterVirtualSearch.create();
sc.setParameters("account", accountId);
sc.setParameters("dc", dcId);
sc.setJoinParameters("offeringSearch", "guestIpType", ServiceOffering.GuestIpType.Virtualized);
return listActiveBy(sc);
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
Map<String, String> configs = _configDao.getConfiguration("Network", params);
_numWorkerThreads =
NumbersUtil.parseInt(
configs.get(Config.SecurityGroupWorkerThreads.key()), WORKER_THREAD_COUNT);
_timeBetweenCleanups =
NumbersUtil.parseInt(
configs.get(Config.SecurityGroupWorkCleanupInterval.key()), TIME_BETWEEN_CLEANUPS);
_globalWorkLockTimeout =
NumbersUtil.parseInt(configs.get(Config.SecurityGroupWorkGlobalLockTimeout.key()), 300);
/* register state listener, no matter security group is enabled or not */
VirtualMachine.State.getStateMachine().registerListener(this);
_answerListener = new SecurityGroupListener(this, _agentMgr, _workDao);
_agentMgr.registerForHostEvents(_answerListener, true, true, true);
_serverId = ((ManagementServer) ComponentLocator.getComponent(ManagementServer.Name)).getId();
s_logger.info(
"SecurityGroupManager: num worker threads="
+ _numWorkerThreads
+ ", time between cleanups="
+ _timeBetweenCleanups
+ " global lock timeout="
+ _globalWorkLockTimeout);
createThreadPools();
return true;
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
if (s_logger.isInfoEnabled()) {
s_logger.info("Start configuring AgentBasedConsoleProxyManager");
}
_name = name;
ComponentLocator locator = ComponentLocator.getCurrentLocator();
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
if (configDao == null) {
throw new ConfigurationException("Unable to get the configuration dao.");
}
Map<String, String> configs = configDao.getConfiguration("management-server", params);
String value = configs.get("consoleproxy.url.port");
if (value != null) {
_consoleProxyUrlPort =
NumbersUtil.parseInt(value, ConsoleProxyManager.DEFAULT_PROXY_URL_PORT);
}
value = configs.get("consoleproxy.port");
if (value != null) {
_consoleProxyPort = NumbersUtil.parseInt(value, ConsoleProxyManager.DEFAULT_PROXY_VNC_PORT);
}
value = configs.get("consoleproxy.sslEnabled");
if (value != null && value.equalsIgnoreCase("true")) {
_sslEnabled = true;
}
_instance = configs.get("instance.name");
_consoleProxyUrlDomain = configs.get("consoleproxy.url.domain");
_listener = new ConsoleProxyListener(this);
_agentMgr.registerForHostEvents(_listener, true, true, false);
_itMgr.registerGuru(VirtualMachine.Type.ConsoleProxy, this);
if (s_logger.isInfoEnabled()) {
s_logger.info(
"AgentBasedConsoleProxyManager has been configured. SSL enabled: " + _sslEnabled);
}
return true;
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
ConfigurationDao dao = ComponentLocator.getCurrentLocator().getDao(ConfigurationDao.class);
_params = dao.getConfiguration(params);
_name = name;
return true;
}
public void init() {
BaseCmd.setComponents(new ApiResponseHelper());
BaseListCmd.configure();
_systemAccount = _accountMgr.getSystemAccount();
_systemUser = _accountMgr.getSystemUser();
_dispatcher = ApiDispatcher.getInstance();
Integer apiPort = null; // api port, null by default
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
SearchCriteria<ConfigurationVO> sc = configDao.createSearchCriteria();
sc.addAnd("name", SearchCriteria.Op.EQ, "integration.api.port");
List<ConfigurationVO> values = configDao.search(sc, null);
if ((values != null) && (values.size() > 0)) {
ConfigurationVO apiPortConfig = values.get(0);
if (apiPortConfig.getValue() != null) {
apiPort = Integer.parseInt(apiPortConfig.getValue());
}
}
Set<Class<?>> cmdClasses =
ReflectUtil.getClassesWithAnnotation(
APICommand.class, new String[] {"org.apache.cloudstack.api", "com.cloud.api"});
for (Class<?> cmdClass : cmdClasses) {
String apiName = cmdClass.getAnnotation(APICommand.class).name();
if (_apiNameCmdClassMap.containsKey(apiName)) {
s_logger.error("API Cmd class " + cmdClass.getName() + " has non-unique apiname" + apiName);
continue;
}
_apiNameCmdClassMap.put(apiName, cmdClass);
}
encodeApiResponse = Boolean.valueOf(configDao.getValue(Config.EncodeApiResponse.key()));
String jsonType = configDao.getValue(Config.JavaScriptDefaultContentType.key());
if (jsonType != null) {
jsonContentType = jsonType;
}
if (apiPort != null) {
ListenerThread listenerThread = new ListenerThread(this, apiPort);
listenerThread.start();
}
}
@Override
public void execute()
throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException,
ConcurrentOperationException, ResourceAllocationException {
try {
ExternalNetworkDeviceManager nwDeviceMgr;
ComponentLocator locator = ComponentLocator.getLocator(ManagementService.Name);
nwDeviceMgr = locator.getManager(ExternalNetworkDeviceManager.class);
Host device = nwDeviceMgr.addNetworkDevice(this);
NetworkDeviceResponse response = nwDeviceMgr.getApiResponse(device);
response.setObjectName("networkdevice");
response.setResponseName(getCommandName());
this.setResponseObject(response);
} catch (InvalidParameterValueException ipve) {
throw new ServerApiException(BaseCmd.PARAM_ERROR, ipve.getMessage());
} catch (CloudRuntimeException cre) {
throw new ServerApiException(BaseCmd.INTERNAL_ERROR, cre.getMessage());
}
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
_name = name;
ComponentLocator locator = ComponentLocator.getCurrentLocator();
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
if (configDao == null) {
s_logger.error("Unable to get the configuration dao. " + ConfigurationDao.class.getName());
return false;
}
_snapshotPollInterval = NumbersUtil.parseInt(configDao.getValue("snapshot.poll.interval"), 300);
boolean snapshotsRecurringTest =
Boolean.parseBoolean(configDao.getValue("snapshot.recurring.test"));
if (snapshotsRecurringTest) {
// look for some test values in the configuration table so that snapshots can be taken more
// frequently (QA test code)
int minutesPerHour =
NumbersUtil.parseInt(configDao.getValue("snapshot.test.minutes.per.hour"), 60);
int hoursPerDay = NumbersUtil.parseInt(configDao.getValue("snapshot.test.hours.per.day"), 24);
int daysPerWeek = NumbersUtil.parseInt(configDao.getValue("snapshot.test.days.per.week"), 7);
int daysPerMonth =
NumbersUtil.parseInt(configDao.getValue("snapshot.test.days.per.month"), 30);
int weeksPerMonth =
NumbersUtil.parseInt(configDao.getValue("snapshot.test.weeks.per.month"), 4);
int monthsPerYear =
NumbersUtil.parseInt(configDao.getValue("snapshot.test.months.per.year"), 12);
_testTimerTask =
new TestClock(
this,
minutesPerHour,
hoursPerDay,
daysPerWeek,
daysPerMonth,
weeksPerMonth,
monthsPerYear);
}
_currentTimestamp = new Date();
s_logger.info("Snapshot Scheduler is configured.");
return true;
}
@Override
public void init() throws ServletException {
// Save Configuration Values
// ComponentLocator loc = ComponentLocator.getLocator(ConfigurationServer.Name);
ConfigurationServer c =
(ConfigurationServer) ComponentLocator.getComponent(ConfigurationServer.Name);
// ConfigurationServer c = new ConfigurationServerImpl();
try {
c.persistDefaultValues();
s_locator = ComponentLocator.getLocator(ManagementServer.Name);
ManagementServer ms = (ManagementServer) ComponentLocator.getComponent(ManagementServer.Name);
ms.enableAdminUser("password");
ApiServer.initApiServer(ms.getApiConfig());
} catch (InvalidParameterValueException ipve) {
s_logger.error("Exception starting management server ", ipve);
throw new ServletException(ipve.getMessage());
} catch (Exception e) {
s_logger.error("Exception starting management server ", e);
throw new ServletException(e.getMessage());
}
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
super.configure(name, params);
ComponentLocator locator = ComponentLocator.getCurrentLocator();
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
Map<String, String> dbParams = configDao.getConfiguration(params);
_cidr = dbParams.get(Config.ControlCidr);
if (_cidr == null) {
_cidr = "169.254.0.0/16";
}
_gateway = dbParams.get(Config.ControlGateway);
if (_gateway == null) {
_gateway = NetUtils.getLinkLocalGateway();
}
s_logger.info("Control network setup: cidr=" + _cidr + "; gateway = " + _gateway);
return true;
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
_name = name;
String value = null;
_storage = (StorageLayer) params.get(StorageLayer.InstanceConfigKey);
if (_storage == null) {
value = (String) params.get(StorageLayer.ClassConfigKey);
if (value == null) {
throw new ConfigurationException("Unable to find the storage layer");
}
Class<StorageLayer> clazz;
try {
clazz = (Class<StorageLayer>) Class.forName(value);
} catch (ClassNotFoundException e) {
throw new ConfigurationException("Unable to instantiate " + value);
}
_storage = ComponentLocator.inject(clazz);
}
String useSsl = (String) params.get("sslcopy");
if (useSsl != null) {
_sslCopy = Boolean.parseBoolean(useSsl);
}
configureFolders(name, params);
String inSystemVM = (String) params.get("secondary.storage.vm");
if (inSystemVM != null && "true".equalsIgnoreCase(inSystemVM)) {
s_logger.info("UploadManager: starting additional services since we are inside system vm");
startAdditionalServices();
// blockOutgoingOnPrivate();
}
value = (String) params.get("install.timeout.pergig");
this.installTimeoutPerGig = NumbersUtil.parseInt(value, 15 * 60) * 1000;
value = (String) params.get("install.numthreads");
final int numInstallThreads = NumbersUtil.parseInt(value, 10);
String scriptsDir = (String) params.get("template.scripts.dir");
if (scriptsDir == null) {
scriptsDir = "scripts/storage/secondary";
}
// Add more processors here.
threadPool = Executors.newFixedThreadPool(numInstallThreads);
return true;
}
@Override
public void execute()
throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException,
ConcurrentOperationException, ResourceAllocationException {
// param checks
if (snapshotReservation != null && (snapshotReservation < 0 || snapshotReservation > 100))
throw new InvalidParameterValueException("Invalid snapshot reservation");
ComponentLocator locator = ComponentLocator.getLocator(ManagementService.Name);
NetappManager netappMgr = locator.getManager(NetappManager.class);
StringBuilder s = new StringBuilder(getVolSize().toString());
s.append("g");
try {
netappMgr.createVolumeOnFiler(
ipAddress,
aggrName,
poolName,
volName,
s.toString(),
snapshotPolicy,
snapshotReservation,
userName,
password);
CreateVolumeOnFilerCmdResponse response = new CreateVolumeOnFilerCmdResponse();
response.setResponseName(getCommandName());
this.setResponseObject(response);
} catch (ServerException e) {
throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, e.toString());
} catch (InvalidParameterValueException e) {
throw new ServerApiException(ApiErrorCode.PARAM_ERROR, e.toString());
} catch (UnknownHostException e) {
throw new ServerApiException(ApiErrorCode.PARAM_ERROR, e.toString());
}
}
protected StoragePoolDaoImpl() {
AllFieldSearch = createSearchBuilder();
AllFieldSearch.and("name", AllFieldSearch.entity().getName(), SearchCriteria.Op.EQ);
AllFieldSearch.and("uuid", AllFieldSearch.entity().getUuid(), SearchCriteria.Op.EQ);
AllFieldSearch.and(
"datacenterId", AllFieldSearch.entity().getDataCenterId(), SearchCriteria.Op.EQ);
AllFieldSearch.and(
"hostAddress", AllFieldSearch.entity().getHostAddress(), SearchCriteria.Op.EQ);
AllFieldSearch.and("status", AllFieldSearch.entity().getStatus(), SearchCriteria.Op.EQ);
AllFieldSearch.and("path", AllFieldSearch.entity().getPath(), SearchCriteria.Op.EQ);
AllFieldSearch.and("podId", AllFieldSearch.entity().getPodId(), Op.EQ);
AllFieldSearch.done();
DcPodSearch = createSearchBuilder();
DcPodSearch.and("datacenterId", DcPodSearch.entity().getDataCenterId(), SearchCriteria.Op.EQ);
DcPodSearch.and().op("nullpod", DcPodSearch.entity().getPodId(), SearchCriteria.Op.NULL);
DcPodSearch.or("podId", DcPodSearch.entity().getPodId(), SearchCriteria.Op.EQ);
DcPodSearch.cp();
DcPodSearch.and()
.op("nullcluster", DcPodSearch.entity().getClusterId(), SearchCriteria.Op.NULL);
DcPodSearch.or("cluster", DcPodSearch.entity().getClusterId(), SearchCriteria.Op.EQ);
DcPodSearch.cp();
DcPodSearch.done();
DcPodAnyClusterSearch = createSearchBuilder();
DcPodAnyClusterSearch.and(
"datacenterId", DcPodAnyClusterSearch.entity().getDataCenterId(), SearchCriteria.Op.EQ);
DcPodAnyClusterSearch.and()
.op("nullpod", DcPodAnyClusterSearch.entity().getPodId(), SearchCriteria.Op.NULL);
DcPodAnyClusterSearch.or(
"podId", DcPodAnyClusterSearch.entity().getPodId(), SearchCriteria.Op.EQ);
DcPodAnyClusterSearch.cp();
DcPodAnyClusterSearch.done();
DeleteLvmSearch = createSearchBuilder();
DeleteLvmSearch.and("ids", DeleteLvmSearch.entity().getId(), SearchCriteria.Op.IN);
DeleteLvmSearch.and().op("LVM", DeleteLvmSearch.entity().getPoolType(), SearchCriteria.Op.EQ);
DeleteLvmSearch.or("Filesystem", DeleteLvmSearch.entity().getPoolType(), SearchCriteria.Op.EQ);
DeleteLvmSearch.cp();
DeleteLvmSearch.done();
StatusCountSearch = createSearchBuilder(Long.class);
StatusCountSearch.and("status", StatusCountSearch.entity().getStatus(), SearchCriteria.Op.IN);
StatusCountSearch.select(null, Func.COUNT, null);
StatusCountSearch.done();
_detailsDao = ComponentLocator.inject(StoragePoolDetailsDaoImpl.class);
}
public void test2214to30Upgrade() throws SQLException {
s_logger.debug("Finding sample data from 2.2.14");
DbTestUtils.executeScript("fake.sql", false, true);
DatabaseUpgradeChecker checker = ComponentLocator.inject(DatabaseUpgradeChecker.class);
checker.upgrade("2.2.14", "3.0.0");
Connection conn = Transaction.getStandaloneConnection();
try {
checkSystemVm(conn);
} finally {
try {
conn.close();
} catch (SQLException e) {
}
}
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
if (s_logger.isInfoEnabled()) {
s_logger.info("Start configuring secondary storage vm manager : " + name);
}
_name = name;
ComponentLocator locator = ComponentLocator.getCurrentLocator();
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
if (configDao == null) {
throw new ConfigurationException("Unable to get the configuration dao.");
}
Map<String, String> configs = configDao.getConfiguration("management-server", params);
_secStorageVmRamSize =
NumbersUtil.parseInt(configs.get("secstorage.vm.ram.size"), DEFAULT_SS_VM_RAMSIZE);
_secStorageVmCpuMHz =
NumbersUtil.parseInt(configs.get("secstorage.vm.cpu.mhz"), DEFAULT_SS_VM_CPUMHZ);
String useServiceVM = configDao.getValue("secondary.storage.vm");
boolean _useServiceVM = false;
if ("true".equalsIgnoreCase(useServiceVM)) {
_useServiceVM = true;
}
String sslcopy = configDao.getValue("secstorage.encrypt.copy");
if ("true".equalsIgnoreCase(sslcopy)) {
_useSSlCopy = true;
}
_allowedInternalSites = configDao.getValue("secstorage.allowed.internal.sites");
String value = configs.get("secstorage.capacityscan.interval");
_capacityScanInterval = NumbersUtil.parseLong(value, DEFAULT_CAPACITY_SCAN_INTERVAL);
_instance = configs.get("instance.name");
if (_instance == null) {
_instance = "DEFAULT";
}
Map<String, String> agentMgrConfigs = configDao.getConfiguration("AgentManager", params);
_mgmt_host = agentMgrConfigs.get("host");
if (_mgmt_host == null) {
s_logger.warn(
"Critical warning! Please configure your management server host address right after you have started your management server and then restart it, otherwise you won't have access to secondary storage");
}
value = agentMgrConfigs.get("port");
_mgmt_port = NumbersUtil.parseInt(value, 8250);
_listener = new SecondaryStorageListener(this, _agentMgr);
_agentMgr.registerForHostEvents(_listener, true, false, true);
_itMgr.registerGuru(VirtualMachine.Type.SecondaryStorageVm, this);
_useLocalStorage = Boolean.parseBoolean(configs.get(Config.SystemVMUseLocalStorage.key()));
_serviceOffering =
new ServiceOfferingVO(
"System Offering For Secondary Storage VM",
1,
_secStorageVmRamSize,
_secStorageVmCpuMHz,
null,
null,
false,
null,
_useLocalStorage,
true,
null,
true,
VirtualMachine.Type.SecondaryStorageVm,
true);
_serviceOffering.setUniqueName("Cloud.com-SecondaryStorage");
_serviceOffering = _offeringDao.persistSystemServiceOffering(_serviceOffering);
// this can sometimes happen, if DB is manually or programmatically manipulated
if (_serviceOffering == null) {
String msg =
"Data integrity problem : System Offering For Secondary Storage VM has been removed?";
s_logger.error(msg);
throw new ConfigurationException(msg);
}
if (_useServiceVM) {
_loadScanner = new SystemVmLoadScanner<Long>(this);
_loadScanner.initScan(STARTUP_DELAY, _capacityScanInterval);
}
if (s_logger.isInfoEnabled()) {
s_logger.info("Secondary storage vm Manager is configured.");
}
return true;
}
@Local(value = NetworkDao.class)
@DB(txn = false)
public class NetworkDaoImpl extends GenericDaoBase<NetworkVO, Long> implements NetworkDao {
final SearchBuilder<NetworkVO> AllFieldsSearch;
final SearchBuilder<NetworkVO> AccountSearch;
final SearchBuilder<NetworkVO> RelatedConfigSearch;
final SearchBuilder<NetworkVO> AccountNetworkSearch;
final SearchBuilder<NetworkVO> ZoneBroadcastUriSearch;
final SearchBuilder<NetworkVO> ZoneSecurityGroupSearch;
final GenericSearchBuilder<NetworkVO, Long> CountByOfferingId;
final SearchBuilder<NetworkVO> PhysicalNetworkSearch;
final SearchBuilder<NetworkVO> securityGroupSearch;
NetworkAccountDaoImpl _accountsDao = ComponentLocator.inject(NetworkAccountDaoImpl.class);
NetworkDomainDaoImpl _domainsDao = ComponentLocator.inject(NetworkDomainDaoImpl.class);
NetworkOpDaoImpl _opDao = ComponentLocator.inject(NetworkOpDaoImpl.class);
NetworkServiceMapDaoImpl _ntwkSvcMap = ComponentLocator.inject(NetworkServiceMapDaoImpl.class);
final TableGenerator _tgMacAddress;
Random _rand = new Random(System.currentTimeMillis());
long _prefix = 0x2;
protected NetworkDaoImpl() {
super();
AllFieldsSearch = createSearchBuilder();
AllFieldsSearch.and("trafficType", AllFieldsSearch.entity().getTrafficType(), Op.EQ);
AllFieldsSearch.and("cidr", AllFieldsSearch.entity().getCidr(), Op.EQ);
AllFieldsSearch.and("broadcastType", AllFieldsSearch.entity().getBroadcastDomainType(), Op.EQ);
AllFieldsSearch.and("offering", AllFieldsSearch.entity().getNetworkOfferingId(), Op.EQ);
AllFieldsSearch.and("datacenter", AllFieldsSearch.entity().getDataCenterId(), Op.EQ);
AllFieldsSearch.and("account", AllFieldsSearch.entity().getAccountId(), Op.EQ);
AllFieldsSearch.and("related", AllFieldsSearch.entity().getRelated(), Op.EQ);
AllFieldsSearch.and("guestType", AllFieldsSearch.entity().getGuestType(), Op.EQ);
AllFieldsSearch.and("physicalNetwork", AllFieldsSearch.entity().getPhysicalNetworkId(), Op.EQ);
AllFieldsSearch.done();
AccountSearch = createSearchBuilder();
AccountSearch.and("offering", AccountSearch.entity().getNetworkOfferingId(), Op.EQ);
SearchBuilder<NetworkAccountVO> join = _accountsDao.createSearchBuilder();
join.and("account", join.entity().getAccountId(), Op.EQ);
AccountSearch.join(
"accounts",
join,
AccountSearch.entity().getId(),
join.entity().getNetworkId(),
JoinBuilder.JoinType.INNER);
AccountSearch.and("datacenter", AccountSearch.entity().getDataCenterId(), Op.EQ);
AccountSearch.and("cidr", AccountSearch.entity().getCidr(), Op.EQ);
AccountSearch.done();
RelatedConfigSearch = createSearchBuilder();
RelatedConfigSearch.and("offering", RelatedConfigSearch.entity().getNetworkOfferingId(), Op.EQ);
RelatedConfigSearch.and("datacenter", RelatedConfigSearch.entity().getDataCenterId(), Op.EQ);
SearchBuilder<NetworkAccountVO> join2 = _accountsDao.createSearchBuilder();
join2.and("account", join2.entity().getAccountId(), Op.EQ);
RelatedConfigSearch.join(
"account",
join2,
join2.entity().getNetworkId(),
RelatedConfigSearch.entity().getId(),
JoinType.INNER);
RelatedConfigSearch.done();
AccountNetworkSearch = createSearchBuilder();
AccountNetworkSearch.and("networkId", AccountNetworkSearch.entity().getId(), Op.EQ);
SearchBuilder<NetworkAccountVO> mapJoin = _accountsDao.createSearchBuilder();
mapJoin.and("accountId", mapJoin.entity().getAccountId(), Op.EQ);
AccountNetworkSearch.join(
"networkSearch",
mapJoin,
AccountNetworkSearch.entity().getId(),
mapJoin.entity().getNetworkId(),
JoinBuilder.JoinType.INNER);
AccountNetworkSearch.done();
ZoneBroadcastUriSearch = createSearchBuilder();
ZoneBroadcastUriSearch.and(
"dataCenterId", ZoneBroadcastUriSearch.entity().getDataCenterId(), Op.EQ);
ZoneBroadcastUriSearch.and(
"broadcastUri", ZoneBroadcastUriSearch.entity().getBroadcastUri(), Op.EQ);
ZoneBroadcastUriSearch.done();
ZoneSecurityGroupSearch = createSearchBuilder();
ZoneSecurityGroupSearch.and(
"dataCenterId", ZoneSecurityGroupSearch.entity().getDataCenterId(), Op.EQ);
SearchBuilder<NetworkServiceMapVO> join1 = _ntwkSvcMap.createSearchBuilder();
join1.and("service", join1.entity().getService(), Op.EQ);
ZoneSecurityGroupSearch.join(
"services",
join1,
ZoneSecurityGroupSearch.entity().getId(),
join1.entity().getNetworkId(),
JoinBuilder.JoinType.INNER);
ZoneSecurityGroupSearch.done();
CountByOfferingId = createSearchBuilder(Long.class);
CountByOfferingId.select(null, Func.COUNT, CountByOfferingId.entity().getId());
CountByOfferingId.and("offeringId", CountByOfferingId.entity().getNetworkOfferingId(), Op.EQ);
CountByOfferingId.and("removed", CountByOfferingId.entity().getRemoved(), Op.NULL);
CountByOfferingId.done();
PhysicalNetworkSearch = createSearchBuilder();
PhysicalNetworkSearch.and(
"physicalNetworkId", PhysicalNetworkSearch.entity().getPhysicalNetworkId(), Op.EQ);
PhysicalNetworkSearch.done();
securityGroupSearch = createSearchBuilder();
SearchBuilder<NetworkServiceMapVO> join3 = _ntwkSvcMap.createSearchBuilder();
join3.and("service", join3.entity().getService(), Op.EQ);
securityGroupSearch.join(
"services",
join3,
securityGroupSearch.entity().getId(),
join3.entity().getNetworkId(),
JoinBuilder.JoinType.INNER);
securityGroupSearch.done();
_tgMacAddress = _tgs.get("macAddress");
}
@Override
public List<NetworkVO> listBy(long accountId, long dataCenterId, Network.GuestType type) {
SearchCriteria<NetworkVO> sc = AllFieldsSearch.create();
sc.setParameters("datacenter", dataCenterId);
sc.setParameters("account", accountId);
if (type != null) {
sc.setParameters("guestType", type);
}
return listBy(sc, null);
}
public List<NetworkVO> findBy(
TrafficType trafficType,
Mode mode,
BroadcastDomainType broadcastType,
long networkOfferingId,
long dataCenterId) {
SearchCriteria<NetworkVO> sc = AllFieldsSearch.create();
sc.setParameters("trafficType", trafficType);
sc.setParameters("broadcastType", broadcastType);
sc.setParameters("offering", networkOfferingId);
sc.setParameters("datacenter", dataCenterId);
return search(sc, null);
}
@Override
public List<NetworkVO> listBy(long accountId, long offeringId, long dataCenterId) {
SearchCriteria<NetworkVO> sc = AccountSearch.create();
sc.setParameters("offering", offeringId);
sc.setJoinParameters("accounts", "account", accountId);
sc.setParameters("datacenter", dataCenterId);
return listBy(sc);
}
@Override
public List<NetworkVO> listBy(long accountId, long offeringId, long dataCenterId, String cidr) {
SearchCriteria<NetworkVO> sc = AccountSearch.create();
sc.setParameters("offering", offeringId);
sc.setJoinParameters("accounts", "account", accountId);
sc.setParameters("datacenter", dataCenterId);
sc.setParameters("cidr", cidr);
return listBy(sc);
}
@Override
@DB
public NetworkVO persist(NetworkVO network, boolean gc, Map<String, String> serviceProviderMap) {
Transaction txn = Transaction.currentTxn();
txn.start();
// 1) create network
NetworkVO newNetwork = super.persist(network);
// 2) add account to the network
addAccountToNetwork(network.getId(), network.getAccountId(), true);
// 3) add network to gc monitor table
NetworkOpVO op = new NetworkOpVO(network.getId(), gc);
_opDao.persist(op);
// 4) add services/providers for the network
persistNetworkServiceProviders(newNetwork.getId(), serviceProviderMap);
txn.commit();
return newNetwork;
}
@Override
@DB
public boolean update(Long networkId, NetworkVO network, Map<String, String> serviceProviderMap) {
Transaction txn = Transaction.currentTxn();
txn.start();
super.update(networkId, network);
if (serviceProviderMap != null) {
_ntwkSvcMap.deleteByNetworkId(networkId);
persistNetworkServiceProviders(networkId, serviceProviderMap);
}
txn.commit();
return true;
}
@Override
@DB
public void persistNetworkServiceProviders(
long networkId, Map<String, String> serviceProviderMap) {
Transaction txn = Transaction.currentTxn();
txn.start();
for (String service : serviceProviderMap.keySet()) {
NetworkServiceMapVO serviceMap =
new NetworkServiceMapVO(
networkId,
Service.getService(service),
Provider.getProvider(serviceProviderMap.get(service)));
_ntwkSvcMap.persist(serviceMap);
}
txn.commit();
}
protected void addAccountToNetwork(long networkId, long accountId, boolean isOwner) {
NetworkAccountVO account = new NetworkAccountVO(networkId, accountId, isOwner);
_accountsDao.persist(account);
}
@Override
public SearchBuilder<NetworkAccountVO> createSearchBuilderForAccount() {
return _accountsDao.createSearchBuilder();
}
@Override
public List<NetworkVO> getNetworksForOffering(
long offeringId, long dataCenterId, long accountId) {
SearchCriteria<NetworkVO> sc = RelatedConfigSearch.create();
sc.setParameters("offering", offeringId);
sc.setParameters("dc", dataCenterId);
sc.setJoinParameters("account", "account", accountId);
return search(sc, null);
}
@Override
public String getNextAvailableMacAddress(long networkConfigId) {
SequenceFetcher fetch = SequenceFetcher.getInstance();
long seq = fetch.getNextSequence(Long.class, _tgMacAddress, networkConfigId);
seq = seq | _prefix << 40 | ((_rand.nextInt(Short.MAX_VALUE) << 16) & 0x00000000ffff0000l);
return NetUtils.long2Mac(seq);
}
@Override
public List<NetworkVO> listBy(long accountId, long networkId) {
SearchCriteria<NetworkVO> sc = AccountNetworkSearch.create();
sc.setParameters("networkId", networkId);
sc.setJoinParameters("networkSearch", "accountId", accountId);
return listBy(sc);
}
@Override
public List<NetworkVO> listBy(long zoneId, String broadcastUri) {
SearchCriteria<NetworkVO> sc = ZoneBroadcastUriSearch.create();
sc.setParameters("dataCenterId", zoneId);
sc.setParameters("broadcastUri", broadcastUri);
return search(sc, null);
}
@Override
public List<NetworkVO> listByZone(long zoneId) {
SearchCriteria<NetworkVO> sc = ZoneBroadcastUriSearch.create();
sc.setParameters("dataCenterId", zoneId);
return search(sc, null);
}
@Override
public List<NetworkVO> listByZoneSecurityGroup(Long zoneId) {
SearchCriteria<NetworkVO> sc = ZoneSecurityGroupSearch.create();
if (zoneId != null) {
sc.setParameters("dataCenterId", zoneId);
}
sc.setJoinParameters("services", "service", Service.SecurityGroup.getName());
return search(sc, null);
}
@Override
public void changeActiveNicsBy(long networkId, int count) {
_opDao.changeActiveNicsBy(networkId, count);
}
@Override
public int getActiveNicsIn(long networkId) {
return _opDao.getActiveNics(networkId);
}
@Override
public List<Long> findNetworksToGarbageCollect() {
return _opDao.getNetworksToGarbageCollect();
}
@Override
public void clearCheckForGc(long networkId) {
_opDao.clearCheckForGc(networkId);
}
@Override
public List<NetworkVO> listByOwner(long ownerId) {
SearchCriteria<NetworkVO> sc = AllFieldsSearch.create();
sc.setParameters("account", ownerId);
return listBy(sc);
}
@Override
public void addDomainToNetwork(long networkId, long domainId) {
addDomainToNetworknetwork(networkId, domainId);
}
protected void addDomainToNetworknetwork(long networkId, long domainId) {
NetworkDomainVO domain = new NetworkDomainVO(networkId, domainId);
_domainsDao.persist(domain);
}
@Override
public Long getNetworkCountByOfferingId(long offeringId) {
SearchCriteria<Long> sc = CountByOfferingId.create();
sc.setParameters("offeringId", offeringId);
List<Long> results = customSearch(sc, null);
return results.get(0);
}
@Override
public List<NetworkVO> listSecurityGroupEnabledNetworks() {
SearchCriteria<NetworkVO> sc = securityGroupSearch.create();
sc.setJoinParameters("services", "service", Service.SecurityGroup.getName());
return listBy(sc);
}
@Override
public List<NetworkVO> listByPhysicalNetwork(long physicalNetworkId) {
SearchCriteria<NetworkVO> sc = PhysicalNetworkSearch.create();
sc.setParameters("physicalNetworkId", physicalNetworkId);
return listBy(sc);
}
@Override
public List<NetworkVO> listByPhysicalNetworkTrafficType(
long physicalNetworkId, TrafficType trafficType) {
SearchCriteria<NetworkVO> sc = AllFieldsSearch.create();
sc.setParameters("trafficType", trafficType);
sc.setParameters("physicalNetworkId", physicalNetworkId);
return listBy(sc);
}
@Override
public List<NetworkVO> listByPhysicalNetworkAndProvider(
long physicalNetworkId, String providerName) {
SearchBuilder<NetworkServiceMapVO> svcProviderMapSearch = _ntwkSvcMap.createSearchBuilder();
NetworkServiceMapVO svcProviderEntry = svcProviderMapSearch.entity();
svcProviderMapSearch.and(
"Provider", svcProviderMapSearch.entity().getProvider(), SearchCriteria.Op.EQ);
SearchBuilder<NetworkVO> networksSearch = createSearchBuilder();
networksSearch.and("physicalNetworkId", networksSearch.entity().getPhysicalNetworkId(), Op.EQ);
networksSearch.join(
"svcProviderMapSearch",
svcProviderMapSearch,
networksSearch.entity().getId(),
svcProviderEntry.getNetworkId(),
JoinBuilder.JoinType.INNER);
SearchCriteria<NetworkVO> sc = networksSearch.create();
sc.setJoinParameters("svcProviderMapSearch", "Provider", providerName);
sc.setParameters("physicalNetworkId", physicalNetworkId);
return listBy(sc);
}
@Override
public List<NetworkVO> listBy(
long accountId, long dataCenterId, Network.GuestType type, TrafficType trafficType) {
SearchCriteria<NetworkVO> sc = AllFieldsSearch.create();
sc.setParameters("datacenter", dataCenterId);
sc.setParameters("account", accountId);
sc.setParameters("guestType", type);
sc.setParameters("trafficType", trafficType);
return listBy(sc, null);
}
}
private StatsCollector(Map<String, String> configs) {
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
_agentMgr = locator.getManager(AgentManager.class);
_userVmMgr = locator.getManager(UserVmManager.class);
_hostDao = locator.getDao(HostDao.class);
_userVmDao = locator.getDao(UserVmDao.class);
_volsDao = locator.getDao(VolumeDao.class);
_capacityDao = locator.getDao(CapacityDao.class);
_storagePoolDao = locator.getDao(StoragePoolDao.class);
_storageManager = locator.getManager(StorageManager.class);
_storagePoolHostDao = locator.getDao(StoragePoolHostDao.class);
_executor = Executors.newScheduledThreadPool(3, new NamedThreadFactory("StatsCollector"));
hostStatsInterval = NumbersUtil.parseLong(configs.get("host.stats.interval"), 60000L);
hostAndVmStatsInterval = NumbersUtil.parseLong(configs.get("vm.stats.interval"), 60000L);
storageStatsInterval = NumbersUtil.parseLong(configs.get("storage.stats.interval"), 60000L);
volumeStatsInterval = NumbersUtil.parseLong(configs.get("volume.stats.interval"), -1L);
_executor.scheduleWithFixedDelay(
new HostCollector(), 15000L, hostStatsInterval, TimeUnit.MILLISECONDS);
_executor.scheduleWithFixedDelay(
new VmStatsCollector(), 15000L, hostAndVmStatsInterval, TimeUnit.MILLISECONDS);
_executor.scheduleWithFixedDelay(
new StorageCollector(), 15000L, storageStatsInterval, TimeUnit.MILLISECONDS);
// -1 means we don't even start this thread to pick up any data.
if (volumeStatsInterval > 0) {
_executor.scheduleWithFixedDelay(
new VolumeCollector(), 15000L, volumeStatsInterval, TimeUnit.MILLISECONDS);
} else {
s_logger.info("Disabling volume stats collector");
}
}
@Override
public boolean configure(final String name, final Map<String, Object> xmlParams)
throws ConfigurationException {
_name = name;
ComponentLocator locator = ComponentLocator.getLocator(ManagementServer.Name);
_serverId = ((ManagementServer) ComponentLocator.getComponent(ManagementServer.Name)).getId();
_investigators = locator.getAdapters(Investigator.class);
_fenceBuilders = locator.getAdapters(FenceBuilder.class);
Map<String, String> params = new HashMap<String, String>();
final ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
if (configDao != null) {
params = configDao.getConfiguration(Long.toHexString(_serverId), xmlParams);
}
String value = params.get("workers");
final int count = NumbersUtil.parseInt(value, 1);
_workers = new WorkerThread[count];
for (int i = 0; i < _workers.length; i++) {
_workers[i] = new WorkerThread("HA-Worker-" + i);
}
value = params.get("force.ha");
_forceHA = Boolean.parseBoolean(value);
value = params.get("time.to.sleep");
_timeToSleep = NumbersUtil.parseInt(value, 60) * 1000;
value = params.get("max.retries");
_maxRetries = NumbersUtil.parseInt(value, 5);
value = params.get("time.between.failures");
_timeBetweenFailures = NumbersUtil.parseLong(value, 3600) * 1000;
value = params.get("time.between.cleanup");
_timeBetweenCleanups = NumbersUtil.parseLong(value, 3600 * 24);
value = params.get("stop.retry.interval");
_stopRetryInterval = NumbersUtil.parseInt(value, 10 * 60);
value = params.get("restart.retry.interval");
_restartRetryInterval = NumbersUtil.parseInt(value, 10 * 60);
value = params.get("investigate.retry.interval");
_investigateRetryInterval = NumbersUtil.parseInt(value, 1 * 60);
value = params.get("migrate.retry.interval");
_migrateRetryInterval = NumbersUtil.parseInt(value, 2 * 60);
_instance = params.get("instance");
if (_instance == null) {
_instance = "VMOPS";
}
_haDao.releaseWorkItems(_serverId);
_stopped = true;
_executor = Executors.newScheduledThreadPool(count, new NamedThreadFactory("HA"));
return true;
}
public void test217to22Upgrade() throws SQLException {
s_logger.debug("Finding sample data from 2.1.7");
DbTestUtils.executeScript("fake.sql", false, true);
Connection conn;
PreparedStatement pstmt;
VersionDaoImpl dao = ComponentLocator.inject(VersionDaoImpl.class);
DatabaseUpgradeChecker checker = ComponentLocator.inject(DatabaseUpgradeChecker.class);
String version = dao.getCurrentVersion();
assert version.equals("2.1.7") : "Version returned is not 2.1.7 but " + version;
checker.upgrade("2.1.7", "2.2.4");
conn = Transaction.getStandaloneConnection();
try {
pstmt = conn.prepareStatement("SELECT version FROM version ORDER BY id DESC LIMIT 1");
ResultSet rs = pstmt.executeQuery();
assert rs.next() : "No version selected";
assert rs.getString(1).equals("2.2.4") : "VERSION stored is not 2.2.4: " + rs.getString(1);
rs.close();
pstmt.close();
pstmt = conn.prepareStatement("SELECT COUNT(*) FROM network_offerings");
rs = pstmt.executeQuery();
assert rs.next() : "Unable to get the count of network offerings.";
assert (rs.getInt(1) == 7) : "Didn't find 7 network offerings but found " + rs.getInt(1);
rs.close();
pstmt.close();
pstmt = conn.prepareStatement("SELECT DISTINCT networktype FROM data_center");
rs = pstmt.executeQuery();
assert rs.next() && rs.getString(1).equals("Advanced")
: "Network type is not advanced? " + rs.getString(1);
assert !rs.next() : "Why do we have another one? " + rs.getString(1);
rs.close();
pstmt.close();
pstmt =
conn.prepareStatement(
"SELECT COUNT(*) FROM disk_offering WHERE removed IS NULL AND system_use=1 AND type='Service' AND recreatable=1");
rs = pstmt.executeQuery();
assert (rs.next() && rs.getInt(1) == 3)
: "DiskOffering for system VMs are incorrect. Expecting 3 but got " + rs.getInt(1);
rs.close();
pstmt.close();
pstmt =
conn.prepareStatement(
"SELECT COUNT(*) FROM op_dc_link_local_ip_address_alloc WHERE nic_id IS NOT NULL");
rs = pstmt.executeQuery();
rs.next();
int controlNics = rs.getInt(1);
rs.close();
pstmt.close();
pstmt =
conn.prepareStatement(
"SELECT COUNT(*) FROM nics WHERE reserver_name='ControlNetworkGuru' and ip4_address is NOT NULL");
rs = pstmt.executeQuery();
assert (rs.next() && controlNics == rs.getInt(1))
: "Allocated nics should have been " + controlNics + " but it is " + rs.getInt(1);
rs.close();
pstmt.close();
} finally {
try {
conn.close();
} catch (SQLException e) {
}
}
}
@Override
@Before
public void setUp() throws Exception {
_locator = new MockComponentLocator("management-server");
_locator.addDao("StackMaidDao", StackMaidDaoImpl.class);
_locator.addDao("VMTemplateZoneDao", VMTemplateZoneDaoImpl.class);
_locator.addDao("DomainRouterDao", DomainRouterDaoImpl.class);
_locator.addDao("HostDao", HostDaoImpl.class);
_locator.addDao("VMInstanceDao", VMInstanceDaoImpl.class);
_locator.addDao("UserVmDao", UserVmDaoImpl.class);
ComponentInfo<? extends GenericDao<?, ? extends Serializable>> info =
_locator.addDao("ServiceOfferingDao", ServiceOfferingDaoImpl.class);
info.addParameter("cache.size", "50");
info.addParameter("cache.time.to.live", "600");
info = _locator.addDao("DiskOfferingDao", DiskOfferingDaoImpl.class);
info.addParameter("cache.size", "50");
info.addParameter("cache.time.to.live", "600");
info = _locator.addDao("DataCenterDao", DataCenterDaoImpl.class);
info.addParameter("cache.size", "50");
info.addParameter("cache.time.to.live", "600");
info = _locator.addDao("HostPodDao", HostPodDaoImpl.class);
info.addParameter("cache.size", "50");
info.addParameter("cache.time.to.live", "600");
_locator.addDao("IPAddressDao", IPAddressDaoImpl.class);
info = _locator.addDao("VlanDao", VlanDaoImpl.class);
info.addParameter("cache.size", "30");
info.addParameter("cache.time.to.live", "3600");
_locator.addDao("PodVlanMapDao", PodVlanMapDaoImpl.class);
_locator.addDao("AccountVlanMapDao", AccountVlanMapDaoImpl.class);
_locator.addDao("VolumeDao", VolumeDaoImpl.class);
_locator.addDao("EventDao", EventDaoImpl.class);
info = _locator.addDao("UserDao", UserDaoImpl.class);
info.addParameter("cache.size", "5000");
info.addParameter("cache.time.to.live", "300");
_locator.addDao("UserStatisticsDao", UserStatisticsDaoImpl.class);
_locator.addDao("FirewallRulesDao", FirewallRulesDaoImpl.class);
_locator.addDao("LoadBalancerDao", LoadBalancerDaoImpl.class);
_locator.addDao("NetworkRuleConfigDao", NetworkRuleConfigDaoImpl.class);
_locator.addDao("LoadBalancerVMMapDao", LoadBalancerVMMapDaoImpl.class);
_locator.addDao("DataCenterIpAddressDao", DataCenterIpAddressDaoImpl.class);
_locator.addDao("SecurityGroupDao", SecurityGroupDaoImpl.class);
// _locator.addDao("IngressRuleDao", IngressRuleDaoImpl.class);
_locator.addDao("SecurityGroupVMMapDao", SecurityGroupVMMapDaoImpl.class);
_locator.addDao("SecurityGroupRulesDao", SecurityGroupRulesDaoImpl.class);
_locator.addDao("SecurityGroupWorkDao", SecurityGroupWorkDaoImpl.class);
_locator.addDao("VmRulesetLogDao", VmRulesetLogDaoImpl.class);
_locator.addDao("AlertDao", AlertDaoImpl.class);
_locator.addDao("CapacityDao", CapacityDaoImpl.class);
_locator.addDao("DomainDao", DomainDaoImpl.class);
_locator.addDao("AccountDao", AccountDaoImpl.class);
_locator.addDao("ResourceLimitDao", ResourceLimitDaoImpl.class);
_locator.addDao("ResourceCountDao", ResourceCountDaoImpl.class);
_locator.addDao("UserAccountDao", UserAccountDaoImpl.class);
_locator.addDao("VMTemplateHostDao", VMTemplateHostDaoImpl.class);
_locator.addDao("UploadDao", UploadDaoImpl.class);
_locator.addDao("VMTemplatePoolDao", VMTemplatePoolDaoImpl.class);
_locator.addDao("LaunchPermissionDao", LaunchPermissionDaoImpl.class);
_locator.addDao("ConfigurationDao", ConfigurationDaoImpl.class);
info = _locator.addDao("VMTemplateDao", VMTemplateDaoImpl.class);
info.addParameter("cache.size", "100");
info.addParameter("cache.time.to.live", "600");
info.addParameter("routing.uniquename", "routing");
_locator.addDao("HighAvailabilityDao", HighAvailabilityDaoImpl.class);
_locator.addDao("ConsoleProxyDao", ConsoleProxyDaoImpl.class);
_locator.addDao("SecondaryStorageVmDao", SecondaryStorageVmDaoImpl.class);
_locator.addDao("ManagementServerHostDao", ManagementServerHostDaoImpl.class);
_locator.addDao("AgentUpgradeDao", AgentUpgradeDaoImpl.class);
_locator.addDao("SnapshotDao", SnapshotDaoImpl.class);
_locator.addDao("AsyncJobDao", AsyncJobDaoImpl.class);
_locator.addDao("SyncQueueDao", SyncQueueDaoImpl.class);
_locator.addDao("SyncQueueItemDao", SyncQueueItemDaoImpl.class);
_locator.addDao("GuestOSDao", GuestOSDaoImpl.class);
_locator.addDao("GuestOSCategoryDao", GuestOSCategoryDaoImpl.class);
_locator.addDao("StoragePoolDao", StoragePoolDaoImpl.class);
_locator.addDao("StoragePoolHostDao", StoragePoolHostDaoImpl.class);
_locator.addDao("DetailsDao", HostDetailsDaoImpl.class);
_locator.addDao("SnapshotPolicyDao", SnapshotPolicyDaoImpl.class);
_locator.addDao("SnapshotScheduleDao", SnapshotScheduleDaoImpl.class);
_locator.addDao("ClusterDao", ClusterDaoImpl.class);
_locator.addDao("CertificateDao", CertificateDaoImpl.class);
_locator.addDao("NetworkConfigurationDao", NetworkDaoImpl.class);
_locator.addDao("NetworkOfferingDao", NetworkOfferingDaoImpl.class);
_locator.addDao("NicDao", NicDaoImpl.class);
_locator.addDao("InstanceGroupDao", InstanceGroupDaoImpl.class);
_locator.addDao("InstanceGroupVMMapDao", InstanceGroupVMMapDaoImpl.class);
_locator.addDao("RemoteAccessVpnDao", RemoteAccessVpnDaoImpl.class);
_locator.addDao("VpnUserDao", VpnUserDaoImpl.class);
_locator.addDao("ItWorkDao", ItWorkDaoImpl.class);
_locator.addDao("FirewallRulesDao", FirewallRulesDaoImpl.class);
_locator.addDao("PortForwardingRulesDao", PortForwardingRulesDaoImpl.class);
_locator.addDao("FirewallRulesCidrsDao", FirewallRulesCidrsDaoImpl.class);
_locator.addDao("SSHKeyPairDao", SSHKeyPairDaoImpl.class);
_locator.addDao("UsageEventDao", UsageEventDaoImpl.class);
_locator.addDao("ClusterDetailsDao", ClusterDetailsDaoImpl.class);
_locator.addDao("UserVmDetailsDao", UserVmDetailsDaoImpl.class);
_locator.addDao("StoragePoolWorkDao", StoragePoolWorkDaoImpl.class);
_locator.addDao("HostTagsDao", HostTagsDaoImpl.class);
_locator.addDao("NetworkDomainDao", NetworkDomainDaoImpl.class);
_locator.addDao("KeystoreDao", KeystoreDaoImpl.class);
_locator.addDao("DcDetailsDao", DcDetailsDaoImpl.class);
_locator.addDao("SwiftDao", SwiftDaoImpl.class);
_locator.addDao("AgentTransferMapDao", HostTransferMapDaoImpl.class);
_locator.addDao("ProjectDao", ProjectDaoImpl.class);
_locator.addDao("InlineLoadBalancerNicMapDao", InlineLoadBalancerNicMapDaoImpl.class);
_locator.addDao("ElasticLbVmMap", ElasticLbVmMapDaoImpl.class);
_locator.addDao("ProjectsAccountDao", ProjectAccountDaoImpl.class);
info = _locator.addDao("HypervisorCapabilitiesDao", HypervisorCapabilitiesDaoImpl.class);
info.addParameter("cache.size", "100");
info.addParameter("cache.time.to.live", "600");
_locator.addManager("StackMaidManager", CheckPointManagerImpl.class);
_locator.addManager("account manager", AccountManagerImpl.class);
_locator.addManager("domain manager", DomainManagerImpl.class);
_locator.addManager("resource limit manager", ResourceLimitManagerImpl.class);
_locator.addManager("configuration manager", ConfigurationManagerImpl.class);
_locator.addManager("network manager", NetworkManagerImpl.class);
_locator.addManager("download manager", DownloadMonitorImpl.class);
_locator.addManager("upload manager", UploadMonitorImpl.class);
_locator.addManager("keystore manager", KeystoreManagerImpl.class);
_locator.addManager("secondary storage vm manager", SecondaryStorageManagerImpl.class);
_locator.addManager("vm manager", UserVmManagerImpl.class);
_locator.addManager("upgrade manager", UpgradeManagerImpl.class);
_locator.addManager("StorageManager", StorageManagerImpl.class);
_locator.addManager("SyncQueueManager", SyncQueueManagerImpl.class);
_locator.addManager("AsyncJobManager", AsyncJobManagerImpl.class);
_locator.addManager("AsyncJobExecutorContext", AsyncJobExecutorContextImpl.class);
_locator.addManager("HA Manager", HighAvailabilityManagerImpl.class);
_locator.addManager("Alert Manager", AlertManagerImpl.class);
_locator.addManager("Template Manager", TemplateManagerImpl.class);
_locator.addManager("Snapshot Manager", SnapshotManagerImpl.class);
_locator.addManager("SnapshotScheduler", SnapshotSchedulerImpl.class);
_locator.addManager("SecurityGroupManager", SecurityGroupManagerImpl2.class);
_locator.addManager("DomainRouterManager", VirtualNetworkApplianceManagerImpl.class);
_locator.addManager("EntityManager", EntityManagerImpl.class);
_locator.addManager("LoadBalancingRulesManager", LoadBalancingRulesManagerImpl.class);
_locator.addManager("RulesManager", RulesManagerImpl.class);
_locator.addManager("RemoteAccessVpnManager", RemoteAccessVpnManagerImpl.class);
_locator.addManager("OvsTunnelManager", OvsTunnelManagerImpl.class);
_locator.addManager("Capacity Manager", CapacityManagerImpl.class);
_locator.addManager("Cluster Manager", ClusterManagerImpl.class);
_locator.addManager("VirtualMachineManager", ClusteredVirtualMachineManagerImpl.class);
_locator.addManager("HypervisorGuruManager", HypervisorGuruManagerImpl.class);
_locator.addManager("ClusterFenceManager", ClusterFenceManagerImpl.class);
_locator.addManager("ResourceManager", ResourceManagerImpl.class);
_locator.addManager("OCFS2Manager", OCFS2ManagerImpl.class);
_locator.addManager("FirewallManager", FirewallManagerImpl.class);
ComponentInfo<? extends Manager> info1 =
_locator.addManager("ConsoleProxyManager", ConsoleProxyManagerImpl.class);
info1.addParameter("consoleproxy.sslEnabled", "true");
_locator.addManager("ClusteredAgentManager", ClusteredAgentManagerImpl.class);
_locator.addManager("ProjectManager", ProjectManagerImpl.class);
_locator.addManager("ElasticLoadBalancerManager", ElasticLoadBalancerManagerImpl.class);
_locator.makeActive(null);
_configService = ComponentLocator.inject(ConfigurationManagerImpl.class);
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
_name = name;
ComponentLocator locator = ComponentLocator.getCurrentLocator();
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
if (configDao == null) {
s_logger.error("Unable to get the configuration dao.");
return false;
}
Map<String, String> configs = configDao.getConfiguration("management-server", params);
// set up the email system for alerts
String emailAddressList = configs.get("alert.email.addresses");
String[] emailAddresses = null;
if (emailAddressList != null) {
emailAddresses = emailAddressList.split(",");
}
String smtpHost = configs.get("alert.smtp.host");
int smtpPort = NumbersUtil.parseInt(configs.get("alert.smtp.port"), 25);
String useAuthStr = configs.get("alert.smtp.useAuth");
boolean useAuth = ((useAuthStr == null) ? false : Boolean.parseBoolean(useAuthStr));
String smtpUsername = configs.get("alert.smtp.username");
String smtpPassword = configs.get("alert.smtp.password");
String emailSender = configs.get("alert.email.sender");
String smtpDebugStr = configs.get("alert.smtp.debug");
boolean smtpDebug = false;
if (smtpDebugStr != null) {
smtpDebug = Boolean.parseBoolean(smtpDebugStr);
}
_emailAlert =
new EmailAlert(
emailAddresses,
smtpHost,
smtpPort,
useAuth,
smtpUsername,
smtpPassword,
emailSender,
smtpDebug);
String storageCapacityThreshold = _configDao.getValue(Config.StorageCapacityThreshold.key());
String cpuCapacityThreshold = _configDao.getValue(Config.CPUCapacityThreshold.key());
String memoryCapacityThreshold = _configDao.getValue(Config.MemoryCapacityThreshold.key());
String storageAllocCapacityThreshold =
_configDao.getValue(Config.StorageAllocatedCapacityThreshold.key());
String publicIPCapacityThreshold = _configDao.getValue(Config.PublicIpCapacityThreshold.key());
String privateIPCapacityThreshold =
_configDao.getValue(Config.PrivateIpCapacityThreshold.key());
String secondaryStorageCapacityThreshold =
_configDao.getValue(Config.SecondaryStorageCapacityThreshold.key());
String vlanCapacityThreshold = _configDao.getValue(Config.VlanCapacityThreshold.key());
String directNetworkPublicIpCapacityThreshold =
_configDao.getValue(Config.DirectNetworkPublicIpCapacityThreshold.key());
String localStorageCapacityThreshold =
_configDao.getValue(Config.LocalStorageCapacityThreshold.key());
if (storageCapacityThreshold != null) {
_storageCapacityThreshold = Double.parseDouble(storageCapacityThreshold);
}
if (storageAllocCapacityThreshold != null) {
_storageAllocCapacityThreshold = Double.parseDouble(storageAllocCapacityThreshold);
}
if (cpuCapacityThreshold != null) {
_cpuCapacityThreshold = Double.parseDouble(cpuCapacityThreshold);
}
if (memoryCapacityThreshold != null) {
_memoryCapacityThreshold = Double.parseDouble(memoryCapacityThreshold);
}
if (publicIPCapacityThreshold != null) {
_publicIPCapacityThreshold = Double.parseDouble(publicIPCapacityThreshold);
}
if (privateIPCapacityThreshold != null) {
_privateIPCapacityThreshold = Double.parseDouble(privateIPCapacityThreshold);
}
if (secondaryStorageCapacityThreshold != null) {
_secondaryStorageCapacityThreshold = Double.parseDouble(secondaryStorageCapacityThreshold);
}
if (vlanCapacityThreshold != null) {
_vlanCapacityThreshold = Double.parseDouble(vlanCapacityThreshold);
}
if (directNetworkPublicIpCapacityThreshold != null) {
_directNetworkPublicIpCapacityThreshold =
Double.parseDouble(directNetworkPublicIpCapacityThreshold);
}
if (localStorageCapacityThreshold != null) {
_localStorageCapacityThreshold = Double.parseDouble(localStorageCapacityThreshold);
}
_capacityTypeThresholdMap.put(Capacity.CAPACITY_TYPE_STORAGE, _storageCapacityThreshold);
_capacityTypeThresholdMap.put(
Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED, _storageAllocCapacityThreshold);
_capacityTypeThresholdMap.put(Capacity.CAPACITY_TYPE_CPU, _cpuCapacityThreshold);
_capacityTypeThresholdMap.put(Capacity.CAPACITY_TYPE_MEMORY, _memoryCapacityThreshold);
_capacityTypeThresholdMap.put(
Capacity.CAPACITY_TYPE_VIRTUAL_NETWORK_PUBLIC_IP, _publicIPCapacityThreshold);
_capacityTypeThresholdMap.put(Capacity.CAPACITY_TYPE_PRIVATE_IP, _privateIPCapacityThreshold);
_capacityTypeThresholdMap.put(
Capacity.CAPACITY_TYPE_SECONDARY_STORAGE, _secondaryStorageCapacityThreshold);
_capacityTypeThresholdMap.put(Capacity.CAPACITY_TYPE_VLAN, _vlanCapacityThreshold);
_capacityTypeThresholdMap.put(
Capacity.CAPACITY_TYPE_DIRECT_ATTACHED_PUBLIC_IP, _directNetworkPublicIpCapacityThreshold);
_capacityTypeThresholdMap.put(
Capacity.CAPACITY_TYPE_LOCAL_STORAGE, _localStorageCapacityThreshold);
String capacityCheckPeriodStr = configs.get("capacity.check.period");
if (capacityCheckPeriodStr != null) {
_capacityCheckPeriod = Long.parseLong(capacityCheckPeriodStr);
if (_capacityCheckPeriod <= 0)
_capacityCheckPeriod = Long.parseLong(Config.CapacityCheckPeriod.getDefaultValue());
}
String cpuOverProvisioningFactorStr = configs.get("cpu.overprovisioning.factor");
if (cpuOverProvisioningFactorStr != null) {
_cpuOverProvisioningFactor = NumbersUtil.parseFloat(cpuOverProvisioningFactorStr, 1);
if (_cpuOverProvisioningFactor < 1) {
_cpuOverProvisioningFactor = 1;
}
}
_timer = new Timer("CapacityChecker");
return true;
}
@Override
public boolean configure(String name, Map<String, Object> params) throws ConfigurationException {
s_logger.info("Configure VmwareManagerImpl, manager name: " + name);
_name = name;
ComponentLocator locator = ComponentLocator.getCurrentLocator();
ConfigurationDao configDao = locator.getDao(ConfigurationDao.class);
if (configDao == null) {
throw new ConfigurationException("Unable to get the configuration dao.");
}
if (!configDao.isPremium()) {
s_logger.error("Vmware component can only run under premium distribution");
throw new ConfigurationException("Vmware component can only run under premium distribution");
}
_instance = configDao.getValue(Config.InstanceName.key());
if (_instance == null) {
_instance = "DEFAULT";
}
s_logger.info("VmwareManagerImpl config - instance.name: " + _instance);
_mountParent = configDao.getValue(Config.MountParent.key());
if (_mountParent == null) {
_mountParent = File.separator + "mnt";
}
if (_instance != null) {
_mountParent = _mountParent + File.separator + _instance;
}
s_logger.info("VmwareManagerImpl config - _mountParent: " + _mountParent);
String value = (String) params.get("scripts.timeout");
_timeout = NumbersUtil.parseInt(value, 1440) * 1000;
_storage = (StorageLayer) params.get(StorageLayer.InstanceConfigKey);
if (_storage == null) {
value = (String) params.get(StorageLayer.ClassConfigKey);
if (value == null) {
value = "com.cloud.storage.JavaStorageLayer";
}
try {
Class<?> clazz = Class.forName(value);
_storage = (StorageLayer) ComponentLocator.inject(clazz);
_storage.configure("StorageLayer", params);
} catch (ClassNotFoundException e) {
throw new ConfigurationException("Unable to find class " + value);
}
}
_privateNetworkVSwitchName = configDao.getValue(Config.VmwarePrivateNetworkVSwitch.key());
if (_privateNetworkVSwitchName == null) {
_privateNetworkVSwitchName = "vSwitch0";
}
_publicNetworkVSwitchName = configDao.getValue(Config.VmwarePublicNetworkVSwitch.key());
if (_publicNetworkVSwitchName == null) {
_publicNetworkVSwitchName = "vSwitch0";
}
_guestNetworkVSwitchName = configDao.getValue(Config.VmwareGuestNetworkVSwitch.key());
if (_guestNetworkVSwitchName == null) {
_guestNetworkVSwitchName = "vSwitch0";
}
_serviceConsoleName = configDao.getValue(Config.VmwareServiceConsole.key());
if (_serviceConsoleName == null) {
_serviceConsoleName = "Service Console";
}
_managemetPortGroupName = configDao.getValue(Config.VmwareManagementPortGroup.key());
if (_managemetPortGroupName == null) {
_managemetPortGroupName = "Management Network";
}
configDao.getValue(Config.VmwareServiceConsole.key());
_additionalPortRangeStart =
NumbersUtil.parseInt(
configDao.getValue(Config.VmwareAdditionalVncPortRangeStart.key()), 59000);
if (_additionalPortRangeStart > 65535) {
s_logger.warn(
"Invalid port range start port ("
+ _additionalPortRangeStart
+ ") for additional VNC port allocation, reset it to default start port 59000");
_additionalPortRangeStart = 59000;
}
_additionalPortRangeSize =
NumbersUtil.parseInt(
configDao.getValue(Config.VmwareAdditionalVncPortRangeSize.key()), 1000);
if (_additionalPortRangeSize < 0
|| _additionalPortRangeStart + _additionalPortRangeSize > 65535) {
s_logger.warn(
"Invalid port range size ("
+ _additionalPortRangeSize
+ " for range starts at "
+ _additionalPortRangeStart);
_additionalPortRangeSize = Math.min(1000, 65535 - _additionalPortRangeStart);
}
_maxHostsPerCluster =
NumbersUtil.parseInt(
configDao.getValue(Config.VmwarePerClusterHostMax.key()),
VmwareManager.MAX_HOSTS_PER_CLUSTER);
_cpuOverprovisioningFactor = configDao.getValue(Config.CPUOverprovisioningFactor.key());
if (_cpuOverprovisioningFactor == null || _cpuOverprovisioningFactor.isEmpty())
_cpuOverprovisioningFactor = "1";
_memOverprovisioningFactor = configDao.getValue(Config.MemOverprovisioningFactor.key());
if (_memOverprovisioningFactor == null || _memOverprovisioningFactor.isEmpty())
_memOverprovisioningFactor = "1";
_reserveCpu = configDao.getValue(Config.VmwareReserveCpu.key());
if (_reserveCpu == null || _reserveCpu.isEmpty()) _reserveCpu = "false";
_reserveMem = configDao.getValue(Config.VmwareReserveMem.key());
if (_reserveMem == null || _reserveMem.isEmpty()) _reserveMem = "false";
s_logger.info(
"Additional VNC port allocation range is settled at "
+ _additionalPortRangeStart
+ " to "
+ (_additionalPortRangeStart + _additionalPortRangeSize));
value = configDao.getValue(Config.VmwareGuestNicDeviceType.key());
if (value == null || "E1000".equalsIgnoreCase(value))
this._guestNicDeviceType = VirtualEthernetCardType.E1000;
else if ("PCNet32".equalsIgnoreCase(value))
this._guestNicDeviceType = VirtualEthernetCardType.PCNet32;
else if ("Vmxnet2".equalsIgnoreCase(value))
this._guestNicDeviceType = VirtualEthernetCardType.Vmxnet2;
else if ("Vmxnet3".equalsIgnoreCase(value))
this._guestNicDeviceType = VirtualEthernetCardType.Vmxnet3;
else this._guestNicDeviceType = VirtualEthernetCardType.E1000;
value = configDao.getValue("vmware.host.scan.interval");
_hostScanInterval = NumbersUtil.parseLong(value, DEFAULT_HOST_SCAN_INTERVAL);
s_logger.info("VmwareManagerImpl config - vmware.host.scan.interval: " + _hostScanInterval);
((VmwareStorageManagerImpl) _storageMgr).configure(params);
_agentMgr.registerForHostEvents(this, true, true, true);
s_logger.info("VmwareManagerImpl has been successfully configured");
return true;
}
public class IPAddressUsageParser {
public static final Logger s_logger = Logger.getLogger(IPAddressUsageParser.class.getName());
private static ComponentLocator _locator =
ComponentLocator.getLocator(UsageServer.Name, "usage-components.xml", "log4j-cloud_usage");
private static UsageDao m_usageDao = _locator.getDao(UsageDao.class);
private static UsageIPAddressDao m_usageIPAddressDao = _locator.getDao(UsageIPAddressDao.class);
public static boolean parse(AccountVO account, Date startDate, Date endDate) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Parsing IP Address usage for account: " + account.getId());
}
if ((endDate == null) || endDate.after(new Date())) {
endDate = new Date();
}
// - query usage_ip_address table with the following criteria:
// - look for an entry for accountId with start date in the given range
// - look for an entry for accountId with end date in the given range
// - look for an entry for accountId with end date null (currently running vm or owned IP)
// - look for an entry for accountId with start date before given range *and* end date after
// given range
List<UsageIPAddressVO> usageIPAddress =
m_usageIPAddressDao.getUsageRecords(
account.getId(), account.getDomainId(), startDate, endDate);
if (usageIPAddress.isEmpty()) {
s_logger.debug("No IP Address usage for this period");
return true;
}
// This map has both the running time *and* the usage amount.
Map<String, Pair<Long, Long>> usageMap = new HashMap<String, Pair<Long, Long>>();
Map<String, IpInfo> IPMap = new HashMap<String, IpInfo>();
// loop through all the usage IPs, create a usage record for each
for (UsageIPAddressVO usageIp : usageIPAddress) {
long IpId = usageIp.getId();
String key = "" + IpId;
// store the info in the IP map
IPMap.put(
key, new IpInfo(usageIp.getZoneId(), IpId, usageIp.getAddress(), usageIp.isSourceNat()));
Date IpAssignDate = usageIp.getAssigned();
Date IpReleaseDeleteDate = usageIp.getReleased();
if ((IpReleaseDeleteDate == null) || IpReleaseDeleteDate.after(endDate)) {
IpReleaseDeleteDate = endDate;
}
// clip the start date to the beginning of our aggregation range if the vm has been running
// for a while
if (IpAssignDate.before(startDate)) {
IpAssignDate = startDate;
}
long currentDuration =
(IpReleaseDeleteDate.getTime() - IpAssignDate.getTime())
+ 1; // make sure this is an inclusive check for milliseconds (i.e. use n - m + 1 to
// find total number of millis to charge)
updateIpUsageData(usageMap, key, usageIp.getId(), currentDuration);
}
for (String ipIdKey : usageMap.keySet()) {
Pair<Long, Long> ipTimeInfo = usageMap.get(ipIdKey);
long useTime = ipTimeInfo.second().longValue();
// Only create a usage record if we have a runningTime of bigger than zero.
if (useTime > 0L) {
IpInfo info = IPMap.get(ipIdKey);
createUsageRecord(
info.getZoneId(),
useTime,
startDate,
endDate,
account,
info.getIpId(),
info.getIPAddress(),
info.isSourceNat());
}
}
return true;
}
private static void updateIpUsageData(
Map<String, Pair<Long, Long>> usageDataMap, String key, long ipId, long duration) {
Pair<Long, Long> ipUsageInfo = usageDataMap.get(key);
if (ipUsageInfo == null) {
ipUsageInfo = new Pair<Long, Long>(new Long(ipId), new Long(duration));
} else {
Long runningTime = ipUsageInfo.second();
runningTime = new Long(runningTime.longValue() + duration);
ipUsageInfo = new Pair<Long, Long>(ipUsageInfo.first(), runningTime);
}
usageDataMap.put(key, ipUsageInfo);
}
private static void createUsageRecord(
long zoneId,
long runningTime,
Date startDate,
Date endDate,
AccountVO account,
long IpId,
String IPAddress,
boolean isSourceNat) {
if (s_logger.isDebugEnabled()) {
s_logger.debug("Total usage time " + runningTime + "ms");
}
float usage = runningTime / 1000f / 60f / 60f;
DecimalFormat dFormat = new DecimalFormat("#.######");
String usageDisplay = dFormat.format(usage);
if (s_logger.isDebugEnabled()) {
s_logger.debug(
"Creating IP usage record with id: "
+ IpId
+ ", usage: "
+ usageDisplay
+ ", startDate: "
+ startDate
+ ", endDate: "
+ endDate
+ ", for account: "
+ account.getId());
}
String usageDesc = "IPAddress: " + IPAddress;
// Create the usage record
UsageVO usageRecord =
new UsageVO(
zoneId,
account.getAccountId(),
account.getDomainId(),
usageDesc,
usageDisplay + " Hrs",
UsageTypes.IP_ADDRESS,
new Double(usage),
null,
null,
null,
null,
IpId,
startDate,
endDate,
(isSourceNat ? "SourceNat" : ""));
m_usageDao.persist(usageRecord);
}
private static class IpInfo {
private long zoneId;
private long IpId;
private String IPAddress;
private boolean isSourceNat;
public IpInfo(long zoneId, long IpId, String IPAddress, boolean isSourceNat) {
this.zoneId = zoneId;
this.IpId = IpId;
this.IPAddress = IPAddress;
this.isSourceNat = isSourceNat;
}
public long getZoneId() {
return zoneId;
}
public long getIpId() {
return IpId;
}
public String getIPAddress() {
return IPAddress;
}
public boolean isSourceNat() {
return isSourceNat;
}
}
}