Java tutorial
/* * The contents of this file are subject to the Mozilla Public License * Version 1.1 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the * License for the specific language governing rights and limitations * under the License. * * The Original Code is available at http://www.abiquo.com/..... * * The Initial Developer of the Original Code is Soluciones Grid, S.L. (www.abiquo.com), * Consell de Cent 296, Principal 2, 08007 Barcelona, Spain. * * No portions of the Code have been created by third parties. * All Rights Reserved. * * Contributor(s): ______________________________________. * * Graphical User Interface of this software may be used under the terms * of the Common Public Attribution License Version 1.0 (the "CPAL License", * available at http://cpal.abiquo.com/), in which case the * provisions of CPAL License are applicable instead of those above. In relation * of this portions of the Code, a Legal Notice according to Exhibits A and B of * CPAL Licence should be provided in any distribution of the corresponding Code * to Graphical User Interface. */ package com.abiquo.abiserver.commands; import java.util.ArrayList; import java.util.Date; import com.abiquo.abiserver.business.authentication.SessionUtil; import com.abiquo.abiserver.business.hibernate.pojohb.infrastructure.SoHB; import com.abiquo.abiserver.business.hibernate.pojohb.infrastructure.VirtualmachineHB; import com.abiquo.abiserver.business.hibernate.pojohb.user.UserHB; import com.abiquo.abiserver.business.hibernate.pojohb.virtualappliance.NodeHB; import com.abiquo.abiserver.business.hibernate.pojohb.virtualimage.CategoryHB; import com.abiquo.abiserver.business.hibernate.pojohb.virtualimage.IconHB; import com.abiquo.abiserver.business.hibernate.pojohb.virtualimage.RepositoryHB; import com.abiquo.abiserver.business.hibernate.pojohb.virtualimage.VirtualimageHB; import com.abiquo.abiserver.business.hibernate.pojohb.virtualimage.VirtualimageTypeHB; import com.abiquo.abiserver.business.hibernate.util.HibernateUtil; import com.abiquo.abiserver.pojo.authentication.UserSession; import com.abiquo.abiserver.pojo.result.BasicResult; import com.abiquo.abiserver.pojo.result.DataResult; import com.abiquo.abiserver.pojo.virtualimage.Category; import com.abiquo.abiserver.pojo.virtualimage.Icon; import com.abiquo.abiserver.pojo.virtualimage.Repository; import com.abiquo.abiserver.pojo.virtualimage.VirtualImage; import com.abiquo.abiserver.pojo.virtualimage.VirtualImageResult; import com.abiquo.abiserver.pojo.virtualimage.VirtualImageType; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.criterion.Restrictions; import com.abiquo.util.resources.ResourceManager; /** * This command collects all actions related to Virtual Images * * @author Oliver */ public class VirtualImageCommand extends BasicCommand { private static final ResourceManager resourceManager = new ResourceManager(VirtualImageCommand.class); protected BasicResult editRepository(UserSession userSession, Repository repository) { BasicResult basicResult = new BasicResult(); Session session = null; Transaction transaction = null; try { // Retrieving the user that has called this method UserHB userHB = SessionUtil.findUserHBByName(userSession.getUser()); session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Retrieving the Repository that will be edited RepositoryHB repositoryHB = (RepositoryHB) session.get(RepositoryHB.class, repository.getId()); // Updating changes repositoryHB.setName(repository.getName()); repositoryHB.setUrl(repository.getURL()); repositoryHB.setLastModificationDate(new Date()); repositoryHB.setUserHBByIdUserLastModification(userHB); session.update(repositoryHB); transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, basicResult, "editRepository", e); return basicResult; } // Everything went fine basicResult.setSuccess(true); basicResult.setMessage(VirtualImageCommand.resourceManager.getMessage("editRepository.success")); return basicResult; } /** * Returns Repositories, Categories and icons stored in the Data Base TODO: Retrieve only * information that belongs to a user * * @return a DataResult object containing a VirtualImageResult with repositories and categories */ @SuppressWarnings("unchecked") protected DataResult<VirtualImageResult> getVirtualImagesInformation() { DataResult<VirtualImageResult> dataResult = new DataResult<VirtualImageResult>(); ArrayList<Repository> repositories = new ArrayList<Repository>(); ArrayList<Category> categories = new ArrayList<Category>(); ArrayList<Icon> icons = new ArrayList<Icon>(); ArrayList<VirtualImageType> virtualImageTypes = new ArrayList<VirtualImageType>(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); ArrayList<RepositoryHB> repositoriesHB = (ArrayList<RepositoryHB>) session .createCriteria(RepositoryHB.class).list(); ArrayList<CategoryHB> categoriesHB = (ArrayList<CategoryHB>) session.createCriteria(CategoryHB.class) .list(); ArrayList<IconHB> iconsHB = (ArrayList<IconHB>) session.createCriteria(IconHB.class).list(); ArrayList<VirtualimageTypeHB> virtualImageTypesHB = (ArrayList<VirtualimageTypeHB>) session .createCriteria(VirtualimageTypeHB.class).list(); Repository repository; for (RepositoryHB respositoryHB : repositoriesHB) { repository = (Repository) respositoryHB.toPojo(); repositories.add(repository); } Category category; for (CategoryHB categoryHB : categoriesHB) { category = (Category) categoryHB.toPojo(); categories.add(category); } Icon icon; for (IconHB iconHB : iconsHB) { icon = (Icon) iconHB.toPojo(); icons.add(icon); } VirtualImageType virtualImageType; for (VirtualimageTypeHB virtualImageTypeHB : virtualImageTypesHB) { virtualImageType = (VirtualImageType) virtualImageTypeHB.toPojo(); virtualImageTypes.add(virtualImageType); } transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, dataResult, "getVirtualImagesInformation", e); return dataResult; } VirtualImageResult virtualImageResult = new VirtualImageResult(); virtualImageResult.setCategories(categories); virtualImageResult.setRepositories(repositories); virtualImageResult.setIcons(icons); virtualImageResult.setVirtualImageTypes(virtualImageTypes); dataResult.setSuccess(true); dataResult .setMessage(VirtualImageCommand.resourceManager.getMessage("getVirtualImagesInformation.success")); dataResult.setData(virtualImageResult); return dataResult; } /** * Returns Virtual Images stored in the Data Base TODO: Get only Virtual Images from public * repositories or from repositories that belongs to the user who called this method * (session.user) * * @param session * @return a DataResult object containing an ArrayList of VirtualImage */ @SuppressWarnings("unchecked") protected DataResult<ArrayList<VirtualImage>> getVirtualImagesByUser(UserSession userSession) { DataResult<ArrayList<VirtualImage>> dataResult = new DataResult<ArrayList<VirtualImage>>(); ArrayList<VirtualImage> virtualImages = new ArrayList<VirtualImage>(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the user who is asking for the Virtual Images // UserHB userHB = // (UserHB)session.createCriteria(UserHB.class).add(Restrictions.eq("user", // userSession.getUser())).uniqueResult(); // Getting the WHOLE list of virtual images ArrayList<VirtualimageHB> virtualImagesHB = (ArrayList<VirtualimageHB>) session .createCriteria(VirtualimageHB.class).list(); VirtualImage virtualImage; for (VirtualimageHB virtualImageHB : virtualImagesHB) { virtualImage = (VirtualImage) virtualImageHB.toPojo(); virtualImages.add(virtualImage); } transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, dataResult, "getVirtualImagesByUser", e); return dataResult; } // Virtual Images retrieved succesfull dataResult.setSuccess(true); dataResult.setMessage(VirtualImageCommand.resourceManager.getMessage("getVirtualImagesByUser.success")); dataResult.setData(virtualImages); return dataResult; } /** * Creates a new Virtual Image * * @param userSession The user's session that has called this service * @param virtualImage The new Virtual Image that will be created * @return A DataResult object containing a VirtualImage object with the virtual image created, * if the creation process was successful. Otherwise, a BasicResult object with the * reason why the virtual image could not be created */ protected DataResult<VirtualImage> createVirtualImage(UserSession userSession, VirtualImage virtualImage) { DataResult<VirtualImage> dataResult = new DataResult<VirtualImage>(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the user that called this method UserHB userHB = (UserHB) session.createCriteria(UserHB.class) .add(Restrictions.eq("user", userSession.getUser())).uniqueResult(); // Creating the object that will be saved in Data Base VirtualimageHB virtualimageHB = (VirtualimageHB) virtualImage.toPojoHB(); // Append the path // RepositoryHB repository = virtualimageHB.getRepository(); virtualimageHB.setPathName(virtualImage.getPath()); virtualimageHB.setUserHBByIdUserCreation(userHB); virtualimageHB.setCreationDate(new Date()); // Saving the new virtual image session.save(virtualimageHB); transaction.commit(); // Creating the result that will be returned dataResult.setSuccess(true); dataResult.setData((VirtualImage) virtualimageHB.toPojo()); dataResult.setMessage(VirtualImageCommand.resourceManager.getMessage("createVirtualImage.success")); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); // Generating the result with the error this.errorManager.reportError(VirtualImageCommand.resourceManager, dataResult, "createVirtualImage", e); ; } return dataResult; } /** * Edits virtualImage information in the DataBase * * @param virtualImage * @return a BasicResult object, announcing if the edition had success */ protected BasicResult editVirtualImage(UserSession userSession, VirtualImage virtualImage) { Session session = null; Transaction transaction = null; BasicResult basicResult = new BasicResult(); try { UserHB userHB = SessionUtil.findUserHBByName(userSession.getUser()); session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Retrieving the Virtual Image that user wants to edit VirtualimageHB virtualImageHB = (VirtualimageHB) session.get(VirtualimageHB.class, virtualImage.getId()); // Updating attributes for the VirtualImage RepositoryHB newRepositoryHB = (RepositoryHB) session.get(RepositoryHB.class, virtualImage.getRepository().getId()); CategoryHB newCategoryHB = (CategoryHB) session.get(CategoryHB.class, virtualImage.getCategory().getId()); SoHB newSOHB = (SoHB) session.get(SoHB.class, virtualImage.getSo().getId()); IconHB newIconHB = null; if (virtualImage.getIcon() != null) newIconHB = (IconHB) session.get(IconHB.class, virtualImage.getIcon().getId()); VirtualimageTypeHB newVirtualImageTypeHB = (VirtualimageTypeHB) session.get(VirtualimageTypeHB.class, virtualImage.getVirtualImageType().getId()); virtualImageHB.setName(virtualImage.getName()); virtualImageHB.setDescription(virtualImage.getDescription()); virtualImageHB.setVirtualimageTypeHB(newVirtualImageTypeHB); // Append the URL + relative path virtualImageHB.setPathName(virtualImage.getPath()); virtualImageHB.setCategory(newCategoryHB); virtualImageHB.setRepository(newRepositoryHB); virtualImageHB.setSo(newSOHB); virtualImageHB.setRamRequired(virtualImage.getRamRequired()); virtualImageHB.setCpuRequired(virtualImage.getCpuRequired()); virtualImageHB.setHdRequired(virtualImage.getHdRequired()); virtualImageHB.setIcon(newIconHB); // User and Date modification virtualImageHB.setLastModificationDate(new Date()); virtualImageHB.setUserHBByIdUserLastModification(userHB); session.update(virtualImageHB); transaction.commit(); } catch (HibernateException e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, basicResult, "editVirtualImage", e); return basicResult; } basicResult.setSuccess(true); basicResult.setMessage(VirtualImageCommand.resourceManager.getMessage("editVirtualImage.success")); return basicResult; } /** * Deletes a virtual image from the Data base * * @param virtualImage The Virtual Image that will be deleted. This virtual image can not be * being used by any Virtual Machine or Virtual Appliance's Node. If so, the deletion * will not be allowed and an error will be returned with code * BasicResult.VIRTUAL_IMAGE_IN_USE * @return A BasicResult object containing the result of the virtual image deletion */ @SuppressWarnings("unchecked") protected BasicResult deleteVirtualImage(VirtualImage virtualImage) { BasicResult basicResult = new BasicResult(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the Virtual Image that we want to delete VirtualimageHB virtualImageHB = (VirtualimageHB) session.get(VirtualimageHB.class, virtualImage.getId()); // Checking if the virtual image is being used by any virtual machine or node ArrayList<VirtualmachineHB> virtualMachinesInUse = (ArrayList<VirtualmachineHB>) session .createCriteria(VirtualmachineHB.class).add(Restrictions.eq("image", virtualImageHB)).list(); ArrayList<NodeHB> nodesInUse = (ArrayList<NodeHB>) session.createCriteria(NodeHB.class) .add(Restrictions.eq("virtualimage", virtualImageHB)).list(); if (virtualMachinesInUse.size() == 0 && nodesInUse.size() == 0) { // The virtual image is not being used. We can safely delete it session.delete(virtualImageHB); basicResult.setSuccess(true); basicResult .setMessage(VirtualImageCommand.resourceManager.getMessage("deleteVirtualImage.success")); } else { // The Virtual Image is being used. We can not delete it basicResult.setResultCode(BasicResult.VIRTUAL_IMAGE_IN_USE); basicResult.setSuccess(false); } transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, basicResult, "deleteVirtualImage", e); } return basicResult; } /** * Creates a new Category * * @param userSession The user's session that has called this service * @param category The new category that will be created * @return A DataResult object containing a Category object with the category created, if the * creation process was successful. Otherwise, a BasicResult object with the reason why * the category could not be created */ protected DataResult<Category> createCategory(UserSession userSession, Category category) { DataResult<Category> dataResult = new DataResult<Category>(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the user that called this method UserHB userHB = (UserHB) session.createCriteria(UserHB.class) .add(Restrictions.eq("user", userSession.getUser())).uniqueResult(); // Creating the object that will be saved in Data Base CategoryHB categoryHB = (CategoryHB) category.toPojoHB(); categoryHB.setUserHBByIdUserCreation(userHB); categoryHB.setCreationDate(new Date()); // Saving the new category session.save(categoryHB); transaction.commit(); // Creating the result that will be returned dataResult.setSuccess(true); dataResult.setData((Category) categoryHB.toPojo()); dataResult.setMessage(VirtualImageCommand.resourceManager.getMessage("createCategory.success")); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); // Generating the result with the error this.errorManager.reportError(VirtualImageCommand.resourceManager, dataResult, "createCategory", e); } return dataResult; } /** * Deletes a category in the data base * * @param userSession The UserSession that called this method * @param category The category that will be deleted * @return A BasicResult object containing the result of the category deletion */ @SuppressWarnings("unchecked") protected BasicResult deleteCategory(UserSession userSession, Category category) { BasicResult basicResult = new BasicResult(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the user that called this method UserHB userHB = (UserHB) session.createCriteria(UserHB.class) .add(Restrictions.eq("user", userSession.getUser())).uniqueResult(); // Getting the category that will be deleted CategoryHB categoryHBToDelete = (CategoryHB) session.get(CategoryHB.class, category.getId()); // First, we have to check if there are any virtual image assigned to this category ArrayList<VirtualimageHB> virtualImageHBAssigned = (ArrayList<VirtualimageHB>) session .createCriteria(VirtualimageHB.class).add(Restrictions.eq("category", categoryHBToDelete)) .list(); if (virtualImageHBAssigned != null && virtualImageHBAssigned.size() > 0) { // Setting all the virtual images that belong to this category to the default // category CategoryHB defaultCategoryHB = (CategoryHB) session.createCriteria(CategoryHB.class) .add(Restrictions.eq("isDefault", 1)).uniqueResult(); for (VirtualimageHB virtualImageHB : virtualImageHBAssigned) { virtualImageHB.setCategory(defaultCategoryHB); virtualImageHB.setUserHBByIdUserLastModification(userHB); virtualImageHB.setLastModificationDate(new Date()); session.update(virtualImageHB); } } // Now, we can delete the selected category session.delete(categoryHBToDelete); basicResult.setSuccess(true); basicResult.setMessage(VirtualImageCommand.resourceManager.getMessage("deleteCategory.success")); transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, basicResult, "deleteCategory", e); } return basicResult; } /** * Creates a new Icon * * @param userSession The UserSession that called this method * @param icon The Icon that will be created * @return A DataResult object containing the Icon created in the Data Base, if the creation had * success. */ protected DataResult<Icon> createIcon(UserSession userSession, Icon icon) { DataResult<Icon> dataResult = new DataResult<Icon>(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the user that called this method UserHB userHB = (UserHB) session.createCriteria(UserHB.class) .add(Restrictions.eq("user", userSession.getUser())).uniqueResult(); // Creating the object that will be saved IconHB iconHB = (IconHB) icon.toPojoHB(); iconHB.setUserHBByIdUserCreation(userHB); iconHB.setCreationDate(new Date()); session.save(iconHB); transaction.commit(); dataResult.setSuccess(true); dataResult.setData((Icon) iconHB.toPojo()); dataResult.setMessage(VirtualImageCommand.resourceManager.getMessage("createIcon.success")); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, dataResult, "createIcon", e); } return dataResult; } /** * Deletes an icon from the Data Base * * @param session The UserSession that called this method * @param icon The Icon that will be deleted from the Data Base * @return A BasicResult object containing the result from the deletion */ @SuppressWarnings("unchecked") protected BasicResult deleteIcon(UserSession userSession, Icon icon) { BasicResult basicResult = new BasicResult(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the icon to delete IconHB iconHBToDelete = (IconHB) session.get(IconHB.class, icon.getId()); // Checking if this icon is being used by a VirtualImage ArrayList<VirtualimageHB> virtualimageHBList = (ArrayList<VirtualimageHB>) session .createCriteria(VirtualimageHB.class).add(Restrictions.eq("icon", iconHBToDelete)).list(); if (virtualimageHBList.size() > 0) { // The icon is being used. We cannot delete it basicResult.setSuccess(false); basicResult.setMessage( VirtualImageCommand.resourceManager.getMessage("deleteIcon.iconBeingUsedError")); } else { // We can delete the icon session.delete(iconHBToDelete); basicResult.setSuccess(true); basicResult.setMessage(VirtualImageCommand.resourceManager.getMessage("deleteIcon.success")); } transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, basicResult, "deleteIcon", e); } return basicResult; } /** * Updated an icon in Data Base with new values * * @param session The UserSession that called this method * @param icon The icon that will be updated in Data Base * @return A BasicResult object containing the result of the edition (success = true if the * edition was successful, or false otherwise) */ protected BasicResult editIcon(UserSession userSession, Icon icon) { BasicResult basicResult = new BasicResult(); Session session = null; Transaction transaction = null; try { session = HibernateUtil.getSession(); transaction = session.beginTransaction(); // Getting the user that called this method UserHB userHB = (UserHB) session.createCriteria(UserHB.class) .add(Restrictions.eq("user", userSession.getUser())).uniqueResult(); // Getting the icon to edit IconHB iconHBToEdit = (IconHB) session.get(IconHB.class, icon.getId()); // Updating fields iconHBToEdit.setName(icon.getName()); iconHBToEdit.setPath(icon.getPath()); iconHBToEdit.setLastModificationDate(new Date()); iconHBToEdit.setUserHBByIdUserLastModification(userHB); session.update(iconHBToEdit); basicResult.setSuccess(true); basicResult.setMessage(VirtualImageCommand.resourceManager.getMessage("editIcon.success")); transaction.commit(); } catch (Exception e) { if (transaction != null && transaction.isActive()) transaction.rollback(); this.errorManager.reportError(VirtualImageCommand.resourceManager, basicResult, "editIcon", e); } return basicResult; } }