gCubeSystem
/
rmp-common-library
13
1
Fork 1
Code Issues Pull Requests Releases Wiki Activity
Browse Source

removed software repository 

git-svn-id: http://svn.research-infrastructures.eu/public/d4science/gcube/trunk/portlets/admin/rmp-common-library@68113 82a268e6-3cf1-43bd-a215-b396298e98cf
master
Massimiliano Assante 10 years ago
parent
277ef4e921
commit
105d216ba8
4 changed files with 1 additions and 866 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      pom.xml
  2. 187
      src/main/java/org/gcube/resourcemanagement/support/server/managers/services/SWRepositoryManager.java
  3. 571
      src/main/java/org/gcube/resourcemanagement/support/server/managers/services/SWRepositoryUpgrader.java
  4. 102
      src/main/java/org/gcube/resourcemanagement/support/server/managers/services/UpgradeListener.java

7
pom.xml
Unescape View File

@ -63,12 +63,7 @@
<groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>org.gcube.resourcemanagement</groupId>
<artifactId>softwarerepository-stubs</artifactId>
<version>1.2.0-SNAPSHOT</version>
</dependency>
</dependency>
<dependency>
<groupId>org.gcube.resourcemanagement</groupId>
<artifactId>resource-manager-stubs</artifactId>

187
src/main/java/org/gcube/resourcemanagement/support/server/managers/services/SWRepositoryManager.java
Unescape View File

@ -1,187 +0,0 @@
/****************************************************************************
* This software is part of the gCube Project.
* Site: http://www.gcube-system.org/
****************************************************************************
* The gCube/gCore software is licensed as Free Open Source software
* conveying to the EUPL (http://ec.europa.eu/idabc/eupl).
* The software and documentation is provided by its authors/distributors
* "as is" and no expressed or
* implied warranty is given for its use, quality or fitness for a
* particular case.
****************************************************************************
* Filename: SWRepositoryManager.java
****************************************************************************
* @author <a href="mailto:daniele.strollo@isti.cnr.it">Daniele Strollo</a>
***************************************************************************/
package org.gcube.resourcemanagement.support.server.managers.services;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Vector;
import org.apache.axis.message.addressing.EndpointReferenceType;
import org.gcube.common.core.contexts.GCUBERemotePortTypeContext;
import org.gcube.common.core.contexts.GHNContext;
import org.gcube.common.core.informationsystem.client.AtomicCondition;
import org.gcube.common.core.informationsystem.client.ISClient;
import org.gcube.common.core.informationsystem.client.queries.GCUBERIQuery;
import org.gcube.common.core.resources.GCUBERunningInstance;
import org.gcube.common.core.scope.GCUBEScope;
import org.gcube.common.core.security.GCUBESecurityManagerImpl;
import org.gcube.resourcemanagement.support.server.exceptions.ResourceAccessException;
import org.gcube.resourcemanagement.support.server.exceptions.ResourceParameterException;
import org.gcube.resourcemanagement.support.server.utils.Assertion;
import org.gcube.resourcemanagement.support.server.utils.ServerConsole;
import org.gcube.vremanagement.softwarerepository.stubs.SoftwareRepositoryPortType;
import org.gcube.vremanagement.softwarerepository.stubs.service.SoftwareRepositoryServiceAddressingLocator;
/**
* A support library to handle and retrieve remote software
* repository manager.
* <br/>
* Useful to handle the proxy for repository manager.
* <br/>Usage:
* <pre>
* <b>SWRepositoryManager</b> repMgr = new SWRepositoryManager();
* // if needed sets the time out for socket connection
* // -- repMgr.setCallTimeOut(240000);
* SoftwareRepositoryPortType swrep = repMgr.getSoftwareRepository(scope);
* // Applies a deploy
* swrep.<i>store(...)</i>;
* </pre>
* @author Daniele Strollo (ISTI-CNR)
*/
public class SWRepositoryManager {
private GCUBESecurityManagerImpl managerSec = null;
private ISClient client = null;
private int callTimeOut = 240000;
private static final String LOG_PREFIX = "[SW-UPDT-MGR]";
public SWRepositoryManager() throws ResourceAccessException {
/**
* Initially the security management is disabled.
*/
this.managerSec = new GCUBESecurityManagerImpl() {
public boolean isSecurityEnabled() {
return false;
}
};
try {
client = GHNContext.getImplementation(ISClient.class);
} catch (Exception e) {
throw new ResourceAccessException("Cannot instantiate the ISClient");
}
}
/**
* Internally used by {@link AbstractResourceManager#getResourceManager(GCUBEScope)}.
* @param scope
* @return a raw list of resource manager descriptors.
* @throws Exception
*/
private List<GCUBERunningInstance> getSoftwareRepositoryFromScope(final GCUBEScope scope)
throws Exception {
GCUBERIQuery query = this.client.getQuery(GCUBERIQuery.class);
query.addAtomicConditions(new AtomicCondition("//Profile/ServiceClass", "VREManagement"));
query.addAtomicConditions(new AtomicCondition("//Profile/ServiceName", "SoftwareRepository"));
List<GCUBERunningInstance> result = client.execute(query, scope);
List<GCUBERunningInstance> toReturn = new ArrayList<GCUBERunningInstance>();
for (GCUBERunningInstance ri : result) {
if (ri.getScopes().containsValue(scope)) {
toReturn.add(ri);
}
}
return toReturn;
}
/**
* The the list of resource managers able to handle the resource in a given scope.
* @param scope the scope in which to operate
* @return all the available managers
* @throws ResourceAccessException if no manager can be instantiated
* @throws ResourceParameterException if the parameters are invalid
*/
private List<SoftwareRepositoryPortType> getSoftwareRepositories(final GCUBEScope scope)
throws ResourceAccessException, ResourceParameterException {
Assertion<ResourceParameterException> checker = new Assertion<ResourceParameterException>();
checker.validate(scope != null, new ResourceParameterException("Invalid scope"));
List<GCUBERunningInstance> resourceManagerList = null;
try {
resourceManagerList = this.getSoftwareRepositoryFromScope(scope);
} catch (Exception e) {
throw new ResourceAccessException("Cannot retrieve the software repository in scope: " + scope.toString());
}
List<SoftwareRepositoryPortType> retval = new Vector<SoftwareRepositoryPortType>();
if (resourceManagerList.isEmpty()) {
throw new ResourceAccessException("Unable to find the software repository in scope: " + scope.toString());
}
EndpointReferenceType endpoint = null;
SoftwareRepositoryPortType pt = null;
for (GCUBERunningInstance resourceManager : resourceManagerList) {
try {
endpoint = resourceManager.getAccessPoint().getEndpoint("gcube/vremanagement/softwarerepository/SoftwareRepository");
pt = GCUBERemotePortTypeContext.getProxy(
new SoftwareRepositoryServiceAddressingLocator()
.getSoftwareRepositoryPortTypePort(endpoint),
scope,
this.callTimeOut,
this.managerSec);
if (pt != null) {
retval.add(pt);
}
} catch (Throwable e) {
// trying on next entry
ServerConsole.error(LOG_PREFIX, e);
}
}
if (retval != null && retval.size() > 0) {
// Return a random manager from the available ones
return retval;
}
// no managers found
throw new ResourceAccessException("Unable to find the software repository in scope: " + scope.toString());
}
/**
* Retrieves form the current scope the list of registered software managers
* and returns one of them (random choice).
* @param scope the scope in which search the sw repository
* @return one randomly chosen repository manager (if many available).
* @throws ResourceAccessException if no sw manager found
* @throws ResourceParameterException if wrong parameters passed
*/
public final SoftwareRepositoryPortType getSoftwareRepository(final GCUBEScope scope)
throws ResourceAccessException, ResourceParameterException {
List<SoftwareRepositoryPortType> retval = this.getSoftwareRepositories(scope);
if (retval != null && retval.size() > 0) {
Random generator = new Random();
// Return a random software repository manager from the available ones
return retval.get(generator.nextInt(retval.size()));
}
// no managers found
throw new ResourceAccessException("Unable to find SoftwareRepository in scope: " + scope.toString());
}
/**
* Used to set the time out for socket connection with the software repository
* to update.
* @param callTimeOut
*/
public final void setCallTimeOut(final int callTimeOut) {
this.callTimeOut = callTimeOut;
}
public final int getCallTimeOut() {
return callTimeOut;
}
}

571
src/main/java/org/gcube/resourcemanagement/support/server/managers/services/SWRepositoryUpgrader.java
Unescape View File

@ -1,571 +0,0 @@
/****************************************************************************
* This software is part of the gCube Project.
* Site: http://www.gcube-system.org/
****************************************************************************
* The gCube/gCore software is licensed as Free Open Source software
* conveying to the EUPL (http://ec.europa.eu/idabc/eupl).
* The software and documentation is provided by its authors/distributors
* "as is" and no expressed or
* implied warranty is given for its use, quality or fitness for a
* particular case.
****************************************************************************
* Filename: SWRepositoryUpgrader.java
****************************************************************************
* @author <a href="mailto:daniele.strollo@isti.cnr.it">Daniele Strollo</a>
***************************************************************************/
package org.gcube.resourcemanagement.support.server.managers.services;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Vector;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.gcube.common.core.types.StringArray;
import org.gcube.resourcemanagement.support.server.exceptions.ResourceAccessException;
import org.gcube.resourcemanagement.support.server.exceptions.ResourceParameterException;
import org.gcube.resourcemanagement.support.server.managers.scope.ScopeManager;
import org.gcube.resourcemanagement.support.server.utils.Assertion;
import org.gcube.resourcemanagement.support.server.utils.ServerConsole;
import org.gcube.vremanagement.softwarerepository.stubs.ListServicePackagesMessage;
import org.gcube.vremanagement.softwarerepository.stubs.SoftwareRepositoryPortType;
import org.gcube.vremanagement.softwarerepository.stubs.Store;
import org.gcube.vremanagement.softwarerepository.stubs.StoreItem;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
class UpgradeStatus implements Serializable {
private static final long serialVersionUID = 2884364307629521252L;
private double currentPackage = 0;
private double totalPackages = 0;
/**
* @deprecated for serialization only
*/
public UpgradeStatus() {
super();
}
public UpgradeStatus(final double currentPackage, final double totalPackages) {
this.currentPackage = currentPackage;
this.totalPackages = totalPackages;
}
public double getCurrentPackage() {
return this.currentPackage;
}
public double getTotalPackages() {
return this.totalPackages;
}
}
/**
* <p>
* Responsible to interact with the repository manager to require
* an update of the infrastructure.
* </p>
* <p>To facilitate the monitoring of main steps involved the
* {@link UpgradeListener} class has been introduced.
* </p>
* <p>
* <b>Notice</b> that one single update per time can be required.
* If a pending update is running the next request will be blocked
* and an exception will be raised.
* </p>
* <p>
* Three files will be created at update request (the folder in which they
* will be created depends on the parameter <i>reportsDir</i>).
* <ul>
* <li><b>swupdt-rept-&lt;timestamp&gt;.txt</b> containing
* the final report of the sw repository update procedure</li>
* <li><b>swupdt-dist-&lt;timestamp&gt;.txt</b> that stores the list of packages to update</li>
* <li><b>swreport.lock</b> represents the lock file and has a double purpose
* <br/>
* <i>i) avoids multiple requests of update</i>
* <br/>
* <i>ii) contains information about the progress status</i>.
* </li>
* </ul>
* </p>
* <b>Usage:</b>
* <pre>
* // [optional]
* // to ensure at least a repository manager is registered in the scope
* new SWRepositoryManager().getSoftwareRepository(scope);
* ServerConsole.info(LOG_PREFIX, "Software repository [FOUND]");
*
* new <b>SWRepositoryUpgrader</b>(
* // The URL containing the list of packages to update
* "http://acme.org/builds/build.txt",
* // The directory to store report files
* "temp",
* // The scope
* "/gcube/devsec")
* // requires the upgrade
* .<b>doUpgrade()</b>;
* </pre>
* @author Daniele Strollo (ISTI-CNR)
*
*/
public class SWRepositoryUpgrader implements Serializable {
private static final long serialVersionUID = 733460314188332825L;
private static final String LOG_PREFIX = "[SW-UPGR]";
private String todeployTxtURL = null;
private String reportFileName = null;
private String distributionFileName = null;
private String scope = null;
private String reportsDir = "temp";
private String lockFile = null;
private List<UpgradeListener> listeners = new Vector<UpgradeListener>();
/**
* @deprecated for internal use only. Required for serialization.
*/
private SWRepositoryUpgrader() {
super();
}
/**
* Builds a new instance of repository update manager.
*
* @param todeployTxtURL the URL to use to retrieve the list of software to update
* @param reportsDir where the reports must be stored
* @throws Exception
*/
public SWRepositoryUpgrader(
final String todeployTxtURL,
final String reportsDir,
final String scope) throws Exception {
this();
// Checks parameters
Assertion<ResourceParameterException> checker = new Assertion<ResourceParameterException>();
checker.validate(todeployTxtURL != null && todeployTxtURL.trim().length() > 0,
new ResourceParameterException("Invalid parameter todeployTxtURL"));
checker.validate(reportsDir != null && reportsDir.trim().length() > 0,
new ResourceParameterException("Invalid parameter reportsDir"));
checker.validate(scope != null && scope.trim().length() > 0 && ScopeManager.getScope(scope) != null,
new ResourceParameterException("Invalid parameter scope"));
this.reportsDir = reportsDir;
// Create the folder if it does not exist
boolean success = (new File(this.reportsDir)).mkdirs();
if (success) {
ServerConsole.trace(LOG_PREFIX, "Directory " + this.reportsDir + " [CREATED]");
}
this.todeployTxtURL = todeployTxtURL;
SimpleDateFormat dateFormatter = new SimpleDateFormat("yyMMdd-hhmm");
Date date = new Date();
String curDate = dateFormatter.format(date);
this.reportFileName = this.reportsDir + File.separator + "swupdt-rept-" + curDate + ".txt";
this.distributionFileName = this.reportsDir + File.separator + "swupdt-dist-" + curDate + ".txt";
this.lockFile = this.reportsDir + File.separator + "swreport.lock";
ServerConsole.trace(LOG_PREFIX, "Setting report file: " + this.reportFileName);
ServerConsole.trace(LOG_PREFIX, "Setting distribution file: " + this.distributionFileName);
this.scope = scope;
}
public final String getScope() {
return this.scope;
}
/**
* Upgrades a software repository.
* @param softwareRepositoryURL the url to contact the service repository
* @param todeployTxtURL the txt file containing software descriptions
* @param reportFileName the filename where report must be stored
* @param distributionFileName the filename where distribution must be stored
* @param scope
*/
public final void doUpgrade() throws Exception {
try {
this.reserve();
} catch (Exception e) {
this.release();
throw new Exception("The required report file already exists. It cannot be replaced.");
}
File reportFile = new File(reportFileName);
if (reportFile.exists()) {
this.release();
throw new Exception("The required report file already exists. It cannot be replaced.");
}
File distributionFile = new File(distributionFileName);
if (distributionFile.exists()) {
this.release();
throw new Exception("The required distribution file already exists. It cannot be replaced.");
}
SoftwareRepositoryPortType swManager = null;
try {
swManager = new SWRepositoryManager().getSoftwareRepository(ScopeManager.getScope(this.scope));
} catch (Exception e) {
this.release();
throw new Exception("The swManager cannot be instantiated. " + e.getMessage());
}
ArrayList<String> listIds = new ArrayList<String>();
List<ListServicePackagesMessage> listServicePackagesMessages = new ArrayList<ListServicePackagesMessage>();
List<StoreItem> storeItemsList = null;
try {
storeItemsList = parseTxtFile(this.todeployTxtURL);
} catch (Exception e) {
this.release();
throw new Exception("The passed update URL is not valid. " + e.getMessage());
}
try {
stringToFile("<Services>\n", reportFile);
} catch (IOException e) {
ServerConsole.error(LOG_PREFIX, "doUpgrade", e);
}
for (int i = 0; i < storeItemsList.size(); i++) {
StoreItem[] storeItems = new StoreItem[1];
storeItems[0] = storeItemsList.get(i);
Store store = new Store();
store.setStoreMessage(storeItems);
try {
String ret = swManager.store(store);
ret = ret.replace("<Services>\n", "");
ret = ret.replace("</Services>\n", "");
listIds.add(parseXMLStoreSoftwareArchive(ret, listServicePackagesMessages));
stringToFile(ret, reportFile);
// -- PROGRESS UPDATE PROCEDURE
// updates the status so that the client can retrieve
// the current update progress (0..1).
UpgradeStatus status = new UpgradeStatus(i + 1, storeItemsList.size());
this.storeStatus(status);
double progress = 1.0d * (status.getCurrentPackage() / status.getTotalPackages());
// Informs the listeners of update progress
for (UpgradeListener listener : this.listeners) {
listener.onProgress(progress);
}
ServerConsole.trace(LOG_PREFIX, "*** UPDATED [" + (i + 1) + "/" + storeItemsList.size() + "]");
// -- ENDOF PROGRESS UPDATE PROCEDURE
} catch (Exception e) {
ServerConsole.error(LOG_PREFIX, e);
}
}
try {
stringToFile("</Services>\n", reportFile);
} catch (IOException e) {
e.printStackTrace();
}
StringBuilder sb = new StringBuilder();
sb.append("<Packages>\n");
for (int k = 0; k < listIds.size(); k++) {
try {
StringArray stringArray = swManager.listUniquesServicePackages(listServicePackagesMessages.get(k));
if (stringArray != null) {
String[] aux = stringArray.getItems();
for (int i = 0; i < aux.length; i++) {
sb.append(aux[i]);
}
} else {
ServerConsole.info(LOG_PREFIX, "listServicePackages return null");
continue;
}
} catch (Exception e) {
ServerConsole.error(LOG_PREFIX, "Error getting package list Service with Class=" +
listServicePackagesMessages.get(k).getServiceClass() +
" Name=" + listServicePackagesMessages.get(k).getServiceName() +
" Version=" + listServicePackagesMessages.get(k).getServiceVersion() + "\n\n");
// Informs the listeners of update exception
for (UpgradeListener listener : this.listeners) {
listener.onError(
// provides the package raising update failure
"Error getting package list Service with Class=" +
listServicePackagesMessages.get(k).getServiceClass() +
" Name=" + listServicePackagesMessages.get(k).getServiceName() +
" Version=" + listServicePackagesMessages.get(k).getServiceVersion(),
e);
}
// Continues to next package
continue;
}
}
sb.append("</Packages>");
try {
stringToFile(sb.toString(), distributionFile);
} catch (IOException e) {
ServerConsole.info(LOG_PREFIX, "Unable to write on output file");
ServerConsole.error(LOG_PREFIX, e);
}
this.release();
ServerConsole.debug(LOG_PREFIX, "Infrastructure Update [DONE]");
// Informs the release has been done
for (UpgradeListener listener : this.listeners) {
listener.onFinish(this.todeployTxtURL, this.reportFileName, this.distributionFileName);
}
}
/**
* Each time a single update can be required.
* For a such reason the repository upgrader must be reserved and
* released at the end of the process.
*/
private void reserve() throws Exception {
if (isReserved()) {
throw new ResourceAccessException("The Infrastracture update cannot be executed. It is already locked by another process. Try later.");
}
// Informs the release has been done
for (UpgradeListener listener : this.listeners) {
listener.onReserve();
}
stringToFile("Reserved by: " + this.reportFileName, new File(this.lockFile));
this.storeStatus(new UpgradeStatus(0, 1));
}
private void storeStatus(final UpgradeStatus status) {
ServerConsole.info(LOG_PREFIX, "Storing status");
try {
File file = new File(this.lockFile);
ObjectOutputStream mine = new ObjectOutputStream(new FileOutputStream(file));
mine.reset();
mine.writeObject(status);
mine.flush();
mine.close();
} catch (Exception e) {
ServerConsole.error(LOG_PREFIX, e);
}
}
/**
* Gives the completed upgrade percentage (0...1).
* @return
*/
public final double getProgressStatus() {
ServerConsole.info(LOG_PREFIX, "Getting status");
if (!this.isReserved()) {
return 1.0;
}
try {
File file = new File(this.lockFile);
ObjectInputStream mine = new ObjectInputStream(new FileInputStream(file));
UpgradeStatus status = (UpgradeStatus) mine.readObject();
mine.close();
double retval = 1.0d * (status.getCurrentPackage() / status.getTotalPackages());
ServerConsole.info(LOG_PREFIX, "Current Status: " + retval);
return retval;
} catch (Exception e) {
return 1;
}
}
/**
* Checks if the software update is locked by another process.
* @return
*/
private boolean isReserved() {
return new File(this.lockFile).exists();
}
/**
* Releases the reservation (removes the lock file).
*/
private void release() {
// Informs the release has been done
for (UpgradeListener listener : this.listeners) {
listener.onRelease();
}
ServerConsole.debug(LOG_PREFIX, "Releasing lock for " + this.reportFileName);
new File(this.lockFile).delete();
}
private List<StoreItem> parseTxtFile(final String txtURL) throws Exception {
List<StoreItem> ret = new ArrayList<StoreItem>();
ServerConsole.info(LOG_PREFIX, "Opening URL connection to " + txtURL);
final URL url = new URL(txtURL);
final HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setRequestMethod("GET");
httpURLConnection.setDoInput(true);
httpURLConnection.setDoOutput(true);
httpURLConnection.setUseCaches(false);
ServerConsole.info(LOG_PREFIX, "Getting data from given URL " + txtURL);
InputStream is = httpURLConnection.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(is));
ServerConsole.info(LOG_PREFIX, "Connection return code: " + httpURLConnection.getResponseCode());
ServerConsole.info(LOG_PREFIX, "Bytes available: " + is.available() + "\n\n\n");
String nextStr = bufferedReader.readLine(); // read a row
while (nextStr != null) {
String row = nextStr.toLowerCase();
if (!row.contains("-servicearchive-")) {
nextStr = bufferedReader.readLine(); // read the next row before continuing
continue;
}
String serviceClass = "Class";
ServerConsole.info(LOG_PREFIX, "Service Class = " + serviceClass);
String serviceName = "Name";
ServerConsole.info(LOG_PREFIX, "Service Name = " + serviceName);
//String version = nextStr.split("-servicearchive-")[1];
String version = "1.0.0";
// version = version.split("-")[0];
ServerConsole.info(LOG_PREFIX, "Version = " + version);
String softwareArchiveURL = nextStr;
ServerConsole.info(LOG_PREFIX, "URL = " + nextStr);
String description = "ETICS Client programmed Description";
ServerConsole.info(LOG_PREFIX, "Description = " + description + "\n\n\n");
String[] scopes = new String[] {scope};
StoreItem storeItem = new StoreItem();
storeItem.setServiceClass(serviceClass);
storeItem.setServiceName(serviceName);
storeItem.setServiceVersion(version);
storeItem.setURL(softwareArchiveURL);
storeItem.setDescription(description);
storeItem.setScopes(scopes);
ret.add(storeItem);
nextStr = bufferedReader.readLine(); // read the next row
}
bufferedReader.close();
httpURLConnection.disconnect();
return ret;
}
/**
*
* @param xml
* @return
*/
private String parseXMLStoreSoftwareArchive(
final String xml,
final List<ListServicePackagesMessage> listServicePackagesMessages) {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = null;
try {
db = dbf.newDocumentBuilder();
} catch (ParserConfigurationException e) {
e.printStackTrace();
}
Document document = null;
try {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(xml.getBytes());
document = db.parse(byteArrayInputStream);
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
Element root = document.getDocumentElement();
NodeList nl = root.getChildNodes();
String id = "";
ListServicePackagesMessage listServicePackagesMessage = new ListServicePackagesMessage();
for (int i = 0; i < nl.getLength(); i++) {
if (!(nl.item(i) instanceof Element)) {
continue;
}
Element el = (Element) nl.item(i);
if (el == null) {
continue;
} else if (el.getTagName().compareTo("ServiceClass") == 0) {
listServicePackagesMessage.setServiceClass(el.getTextContent());
} else if (el.getTagName().compareTo("ID") == 0) {
id = el.getTextContent();
} else if (el.getTagName().compareTo("ServiceName") == 0) {
listServicePackagesMessage.setServiceName(el.getTextContent());
} else if (el.getTagName().compareTo("ServiceVersion") == 0) {
listServicePackagesMessage.setServiceVersion(el.getTextContent());
}
}
listServicePackagesMessages.add(listServicePackagesMessage);
ServerConsole.info(LOG_PREFIX, "required store for SA ID: " + id);
return id;
}
/**
* @param str string
* @param targetFile Target File
* @throws IOException if fails
*/
private void stringToFile(
final String str,
final File targetFile) throws IOException {
try {
FileWriter fw = new FileWriter(targetFile, true);
fw.append(str);
fw.flush();
fw.close();
} catch (IOException e) {
throw e;
}
}
public final void addListener(final UpgradeListener listener) {
if (listener == null) {
return;
}
listener.setUpgrader(this);
this.listeners.add(listener);
}
}

102
src/main/java/org/gcube/resourcemanagement/support/server/managers/services/UpgradeListener.java
Unescape View File

@ -1,102 +0,0 @@
/****************************************************************************
* This software is part of the gCube Project.
* Site: http://www.gcube-system.org/
****************************************************************************
* The gCube/gCore software is licensed as Free Open Source software
* conveying to the EUPL (http://ec.europa.eu/idabc/eupl).
* The software and documentation is provided by its authors/distributors
* "as is" and no expressed or
* implied warranty is given for its use, quality or fitness for a
* particular case.
****************************************************************************
* Filename: UpgradeListener.java
****************************************************************************
* @author <a href="mailto:daniele.strollo@isti.cnr.it">Daniele Strollo</a>
***************************************************************************/
package org.gcube.resourcemanagement.support.server.managers.services;
import org.gcube.resourcemanagement.support.server.utils.ServerConsole;
/**
* @author Daniele Strollo (ISTI-CNR)
*
*/
/**
* To an upgrade process can be attached an handler to perform
* additional operations at the happening of events.
* @author Daniele Strollo (ISTI-CNR)
*
*/
public abstract class UpgradeListener {
protected static final String LOG_PREFIX = "[SW-UPGR-LISTENER]";
private SWRepositoryUpgrader upgrader = null;
public UpgradeListener() {
this.onInit();
}
/**
* Method invoked at construction of listener.
*/
public abstract void onInit();
/**
* Automatically invoked when the listener is attached to an upgrader.
*
* @param upgrader
*/
public final void setUpgrader(final SWRepositoryUpgrader upgrader) {
this.upgrader = upgrader;
}
public final SWRepositoryUpgrader getUpgrader() {
return this.upgrader;
}
/**
* Invoked each time the update progresses.
* @param progress
*/
public abstract void onProgress(final double progress);
/**
* Invoked in case of failure during update operation.
* @param failure
*/
public final void onError(final Exception failure) {
ServerConsole.error(LOG_PREFIX, failure);
}
/**
* Invoked in case of failure during update operation.
* @param failure
*/
public final void onError(final String message, final Exception failure) {
ServerConsole.error(LOG_PREFIX, message, failure);
}
/**
* In successful update, the resulting report files will be
* provided in input.
*/
public abstract void onFinish(
final String deployURL,
final String reportFileName,
final String distributionFileName);
/**
* Invoked once the lock has been acquired.
*/
public final void onReserve() {
ServerConsole.info(LOG_PREFIX, "Software repository lock request [DONE]");
}
/**
* Once finished the lock is released and this event raised.
* The release is called both if the process successfully finish
* or an abort is required.
*/
public void onRelease() {
ServerConsole.info(LOG_PREFIX, "Software repository lock release [DONE]");
}
}
Write Preview
Loading…
Cancel
Save