@Override public void execute(){ Pair<List<? extends Network>, Integer> networks = _networkService.searchForNetworks(this); ListResponse<NetworkResponse> response = new ListResponse<NetworkResponse>(); List<NetworkResponse> networkResponses = new ArrayList<NetworkResponse>(); for (Network network : networks.first()) { NetworkResponse networkResponse = _responseGenerator.createNetworkResponse(ResponseView.Full, network); networkResponses.add(networkResponse); } response.setResponses(networkResponses, networks.second()); response.setResponseName(getCommandName()); setResponseObject(response); } }
@Test public void testCreateSuccess() { Configuration cfg = Mockito.mock(Configuration.class); listCfgsByCmd._mgr = mgr; listCfgsByCmd._responseGenerator = responseGenerator; List<Configuration> configList = new ArrayList<Configuration>(); configList.add(cfg); Pair<List<? extends Configuration>, Integer> result = new Pair<List<? extends Configuration>, Integer>(configList, 1); try { Mockito.when(mgr.searchForConfigurations(listCfgsByCmd)).thenReturn(result); } catch (Exception e) { Assert.fail("Received exception when success expected " + e.getMessage()); } ConfigurationResponse cfgResponse = new ConfigurationResponse(); cfgResponse.setName("Test case"); Mockito.when(responseGenerator.createConfigurationResponse(cfg)).thenReturn(cfgResponse); listCfgsByCmd.execute(); Mockito.verify(responseGenerator).createConfigurationResponse(cfg); ListResponse<ConfigurationResponse> actualResponse = (ListResponse<ConfigurationResponse>)listCfgsByCmd.getResponseObject(); Assert.assertEquals(cfgResponse, actualResponse.getResponses().get(0)); }
@Override public void execute() { VirtualRouter router = _routerService.upgradeRouter(this); if (router != null) { DomainRouterResponse routerResponse = _responseGenerator.createDomainRouterResponse(router); routerResponse.setResponseName(getCommandName()); setResponseObject(routerResponse); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to upgrade router"); } } }
if (results != null) { for (NicSecondaryIp r : results) { NicSecondaryIpResponse ipRes = _responseGenerator.createSecondaryIPToNicResponse(r); resList.add(ipRes); res.setSecondaryIpsList(resList); resList = new ArrayList<NicResponse>(results.size()); for (Nic r : results) { NicResponse resp = _responseGenerator.createNicResponse(r); resp.setObjectName("nic"); resList.add(resp);
@Override public void execute() { Pair<List<? extends VirtualMachine>, Integer> systemVMs = _mgr.searchForSystemVm(this); ListResponse<SystemVmResponse> response = new ListResponse<SystemVmResponse>(); List<SystemVmResponse> vmResponses = new ArrayList<SystemVmResponse>(); for (VirtualMachine systemVM : systemVMs.first()) { SystemVmResponse vmResponse = _responseGenerator.createSystemVmResponse(systemVM); vmResponse.setObjectName("systemvm"); vmResponses.add(vmResponse); } response.setResponses(vmResponses, systemVMs.second()); response.setResponseName(getCommandName()); setResponseObject(response); } }
@Override public void execute() { Host result = _resourceService.maintain(this); if (result != null) { HostResponse response = _responseGenerator.createHostResponse(result); response.setResponseName("host"); this.setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to prepare host for maintenance"); } } }
@Override public void execute() { try { ImageStore result = _storageService.createSecondaryStagingStore(this); ImageStoreResponse storeResponse = null; if (result != null) { storeResponse = _responseGenerator.createImageStoreResponse(result); storeResponse.setResponseName(getCommandName()); storeResponse.setObjectName("secondarystorage"); this.setResponseObject(storeResponse); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to add secondary storage"); } } catch (Exception ex) { s_logger.warn("Exception: ", ex); throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, ex.getMessage()); } } }
@Override public void execute() { Pair<List<? extends Snapshot>, Integer> result = _snapshotService.listSnapshots(this); ListResponse<SnapshotResponse> response = new ListResponse<SnapshotResponse>(); List<SnapshotResponse> snapshotResponses = new ArrayList<SnapshotResponse>(); for (Snapshot snapshot : result.first()) { SnapshotResponse snapshotResponse = _responseGenerator.createSnapshotResponse(snapshot); snapshotResponse.setObjectName("snapshot"); snapshotResponses.add(snapshotResponse); } response.setResponses(snapshotResponses, result.second()); response.setResponseName(getCommandName()); setResponseObject(response); }
@Test public void testCreateSuccess() { RegionService regionService = Mockito.mock(RegionService.class); Region region = Mockito.mock(Region.class); Mockito.when(regionService.addRegion(Matchers.anyInt(), Matchers.anyString(), Matchers.anyString())).thenReturn(region); addRegionCmd._regionService = regionService; responseGenerator = Mockito.mock(ResponseGenerator.class); RegionResponse regionResponse = Mockito.mock(RegionResponse.class); Mockito.when(responseGenerator.createRegionResponse(region)).thenReturn(regionResponse); addRegionCmd._responseGenerator = responseGenerator; addRegionCmd.execute(); }
@Override public void execute() throws ServerApiException { if (getAccountType() == null && getRoleId() == null) { throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Both account type and role ID are not provided"); } final CallContext callContext = getCurrentContext(); String finalAccountName = getAccountName(); Long finalDomainId = getDomainId(); callContext.setEventDetails("Account Name: " + finalAccountName + ", Domain Id:" + finalDomainId); try { final LdapUser user = _ldapManager.getUser(username, domainId); validateUser(user); final UserAccount userAccount = createCloudstackUserAccount(user, finalAccountName, finalDomainId); if (userAccount != null) { final AccountResponse response = _responseGenerator.createUserAccountResponse(ResponseView.Full, userAccount); response.setResponseName(getCommandName()); setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to create a user account"); } } catch (NoLdapUserMatchingQueryException e) { throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, "No LDAP user exists with the username of " + username); } }
@Test public void testCreateSuccess() throws ResourceAllocationException, ResourceUnavailableException, ConcurrentOperationException, InsufficientCapacityException { NetworkService networkService = Mockito.mock(NetworkService.class); AddIpToVmNicCmd ipTonicCmd = Mockito.mock(AddIpToVmNicCmd.class); NicSecondaryIp secIp = Mockito.mock(NicSecondaryIp.class); Mockito.when( networkService.allocateSecondaryGuestIP(Matchers.anyLong(), Matchers.any())) .thenReturn(secIp); ipTonicCmd._networkService = networkService; responseGenerator = Mockito.mock(ResponseGenerator.class); NicSecondaryIpResponse ipres = Mockito.mock(NicSecondaryIpResponse.class); Mockito.when(responseGenerator.createSecondaryIPToNicResponse(secIp)).thenReturn(ipres); ipTonicCmd._responseGenerator = responseGenerator; ipTonicCmd.execute(); }
@Override public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException { try { Map<String,Object> resp = _netsclarLbService.deployNetscalerServiceVm(this); if (resp.size() > 0) { SystemVmResponse response = _responseGenerator.createSystemVmResponse((VirtualMachine)resp.get("vm")); response.setGuestVlan((String)resp.get("guestvlan")); response.setPublicVlan((List<String>)resp.get("publicvlan")); response.setResponseName(getCommandName()); setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Fail to start system vm"); } } catch (InvalidParameterValueException invalidParamExcp) { throw new ServerApiException(ApiErrorCode.PARAM_ERROR, invalidParamExcp.getMessage()); } catch (CloudRuntimeException runtimeExcp) { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, runtimeExcp.getMessage()); } }
@Override public void execute() { Host result = _resourceService.cancelMaintenance(this); if (result != null) { HostResponse response = _responseGenerator.createHostResponse(result); response.setResponseName(getCommandName()); this.setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to cancel host maintenance"); } } }
@Test public void testExecuteForResult() throws Exception { StorageService resourceService = Mockito.mock(StorageService.class); addImageStoreCmd._storageService = resourceService; ImageStore store = Mockito.mock(ImageStore.class); Mockito.when(resourceService.discoverImageStore(anyString(), anyString(), anyString(), anyLong(), (Map)anyObject())) .thenReturn(store); ResponseGenerator responseGenerator = Mockito.mock(ResponseGenerator.class); addImageStoreCmd._responseGenerator = responseGenerator; ImageStoreResponse responseHost = new ImageStoreResponse(); responseHost.setName("Test"); Mockito.when(responseGenerator.createImageStoreResponse(store)).thenReturn(responseHost); addImageStoreCmd.execute(); Mockito.verify(responseGenerator).createImageStoreResponse(store); ImageStoreResponse actualResponse = (ImageStoreResponse)addImageStoreCmd.getResponseObject(); Assert.assertEquals(responseHost, actualResponse); Assert.assertEquals("addimagestoreresponse", actualResponse.getResponseName()); }
@Test public void testCreateSuccess() { AccountService accountService = Mockito.mock(AccountService.class); Account account = Mockito.mock(Account.class); Mockito.when(accountService.getAccount(anyLong())).thenReturn(account); VolumeApiService volumeApiService = Mockito.mock(VolumeApiService.class); Snapshot snapshot = Mockito.mock(Snapshot.class); try { Mockito.when(volumeApiService.takeSnapshot(anyLong(), anyLong(), anyLong(), any(Account.class), anyBoolean(), isNull(Snapshot.LocationType.class), anyBoolean())).thenReturn(snapshot); } catch (Exception e) { Assert.fail("Received exception when success expected " + e.getMessage()); } responseGenerator = Mockito.mock(ResponseGenerator.class); SnapshotResponse snapshotResponse = Mockito.mock(SnapshotResponse.class); Mockito.when(responseGenerator.createSnapshotResponse(snapshot)).thenReturn(snapshotResponse); Mockito.doNothing().when(snapshotResponse).setAccountName(anyString()); createSnapshotCmd._accountService = accountService; createSnapshotCmd._responseGenerator = responseGenerator; createSnapshotCmd._volumeService = volumeApiService; try { createSnapshotCmd.execute(); } catch (Exception e) { Assert.fail("Received exception when success expected " + e.getMessage()); } }
@Override public void execute() { List<? extends Region> result = _regionService.listRegions(this); ListResponse<RegionResponse> response = new ListResponse<RegionResponse>(); List<RegionResponse> regionResponses = new ArrayList<RegionResponse>(); for (Region region : result) { RegionResponse regionResponse = _responseGenerator.createRegionResponse(region); regionResponse.setObjectName("region"); regionResponses.add(regionResponse); } response.setResponses(regionResponses); response.setResponseName(getCommandName()); this.setResponseObject(response); } }
@Override public void execute() { validateParams(); CallContext.current().setEventDetails("Account Name: " + getUsername() + ", Domain Id:" + getDomainId()); UserAccount userAccount = _accountService.createUserAccount(getUsername(), getPassword(), getFirstName(), getLastName(), getEmail(), getTimeZone(), getAccountName(), getAccountType(), getRoleId(), getDomainId(), getNetworkDomain(), getDetails(), getAccountUUID(), getUserUUID()); if (userAccount != null) { AccountResponse response = _responseGenerator.createUserAccountResponse(ResponseView.Full, userAccount); response.setResponseName(getCommandName()); setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to create a user account"); } }
@Override public void execute() throws ResourceUnavailableException, ResourceAllocationException, ConcurrentOperationException, InsufficientCapacityException { CallContext.current().setEventDetails("Nic Id: " + this._uuidMgr.getUuid(Nic.class, getNicId())); NicSecondaryIp result = _entityMgr.findById(NicSecondaryIp.class, getEntityId()); if (result != null) { CallContext.current().setEventDetails("secondary Ip Id: " + getEntityUuid()); boolean success = false; success = _networkService.configureNicSecondaryIp(result, isZoneSGEnabled()); if (success == false) { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to set security group rules for the secondary ip"); } NicSecondaryIpResponse response = _responseGenerator.createSecondaryIPToNicResponse(result); response.setResponseName(getCommandName()); this.setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Failed to assign secondary ip to nic"); } }
@Override public void execute() { Pair<List<? extends Network>, Integer> networks = _networkService.searchForNetworks(this); ListResponse<NetworkResponse> response = new ListResponse<NetworkResponse>(); List<NetworkResponse> networkResponses = new ArrayList<NetworkResponse>(); for (Network network : networks.first()) { NetworkResponse networkResponse = _responseGenerator.createNetworkResponse(ResponseView.Restricted, network); networkResponses.add(networkResponse); } response.setResponses(networkResponses, networks.second()); response.setResponseName(getCommandName()); setResponseObject(response); } }
@Override public void execute() { CallContext.current().setEventDetails("Vm Id: " + this._uuidMgr.getUuid(VirtualMachine.class, getId())); VirtualMachine result = _mgr.rebootSystemVM(this); if (result != null) { SystemVmResponse response = _responseGenerator.createSystemVmResponse(result); response.setResponseName(getCommandName()); setResponseObject(response); } else { throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Fail to reboot system vm"); } } }