use of org.xwiki.extension.ResolveException in project xwiki-platform by xwiki.
the class RepositoryManager method importExtension.
public DocumentReference importExtension(String extensionId, ExtensionRepository repository, Type type) throws QueryException, XWikiException, ResolveException {
TreeMap<Version, String> versions = new TreeMap<Version, String>();
Version lastVersion = getVersions(extensionId, repository, type, versions);
if (lastVersion == null) {
throw new ExtensionNotFoundException("Can't find any version for the extension [" + extensionId + "] on repository [" + repository + "]");
} else if (versions.isEmpty()) {
// If no valid version import the last version
versions.put(lastVersion, extensionId);
} else {
// Select the last valid version
lastVersion = versions.lastKey();
}
Extension extension = repository.resolve(new ExtensionId(extensionId, lastVersion));
// Get former ids versions
Collection<ExtensionId> features = extension.getExtensionFeatures();
for (ExtensionId feature : features) {
try {
getVersions(feature.getId(), repository, type, versions);
} catch (ResolveException e) {
// Ignore
}
}
XWikiContext xcontext = this.xcontextProvider.get();
boolean needSave = false;
XWikiDocument document = getExistingExtensionDocumentById(extensionId);
if (document == null) {
// Create document
document = xcontext.getWiki().getDocument(new DocumentReference(xcontext.getWikiId(), Arrays.asList("Extension", extension.getName()), "WebHome"), xcontext);
for (int i = 1; !document.isNew(); ++i) {
document = xcontext.getWiki().getDocument(new DocumentReference(xcontext.getWikiId(), Arrays.asList("Extension", extension.getName() + ' ' + i), "WebHome"), xcontext);
}
document.readFromTemplate(this.currentResolver.resolve(XWikiRepositoryModel.EXTENSION_TEMPLATEREFERENCE), xcontext);
needSave = true;
}
// Update document
BaseObject extensionObject = document.getXObject(XWikiRepositoryModel.EXTENSION_CLASSREFERENCE);
if (extensionObject == null) {
extensionObject = document.newXObject(XWikiRepositoryModel.EXTENSION_CLASSREFERENCE, xcontext);
needSave = true;
}
if (!StringUtils.equals(extensionId, getValue(extensionObject, XWikiRepositoryModel.PROP_EXTENSION_ID, (String) null))) {
extensionObject.set(XWikiRepositoryModel.PROP_EXTENSION_ID, extensionId, xcontext);
needSave = true;
}
// Update extension informations
needSave |= updateExtension(extension, extensionObject, xcontext);
// Proxy marker
BaseObject extensionProxyObject = document.getXObject(XWikiRepositoryModel.EXTENSIONPROXY_CLASSREFERENCE);
if (extensionProxyObject == null) {
extensionProxyObject = document.newXObject(XWikiRepositoryModel.EXTENSIONPROXY_CLASSREFERENCE, xcontext);
extensionProxyObject.setIntValue(XWikiRepositoryModel.PROP_PROXY_AUTOUPDATE, 1);
needSave = true;
}
needSave |= update(extensionProxyObject, XWikiRepositoryModel.PROP_PROXY_REPOSITORYID, repository.getDescriptor().getId());
needSave |= update(extensionProxyObject, XWikiRepositoryModel.PROP_PROXY_REPOSITORYTYPE, repository.getDescriptor().getType());
needSave |= update(extensionProxyObject, XWikiRepositoryModel.PROP_PROXY_REPOSITORYURI, repository.getDescriptor().getURI().toString());
// Remove unexisting versions
Set<String> validVersions = new HashSet<String>();
List<BaseObject> versionObjects = document.getXObjects(XWikiRepositoryModel.EXTENSIONVERSION_CLASSREFERENCE);
if (versionObjects != null) {
for (BaseObject versionObject : versionObjects) {
if (versionObject != null) {
String version = getValue(versionObject, XWikiRepositoryModel.PROP_VERSION_VERSION);
if (StringUtils.isBlank(version) || (isVersionProxyingEnabled(document) && !new DefaultVersion(version).equals(extension.getId().getVersion()))) {
// Empty version OR old versions should be proxied
document.removeXObject(versionObject);
needSave = true;
} else {
if (!versions.containsKey(new DefaultVersion(version))) {
// The version does not exist on remote repository
if (!isVersionValid(document, versionObject, xcontext)) {
// The version is invalid, removing it to not make the whole extension invalid
document.removeXObject(versionObject);
needSave = true;
} else {
// The version is valid, lets keep it
validVersions.add(version);
}
} else {
// This version exist on remote repository
validVersions.add(version);
}
}
}
}
}
List<BaseObject> dependencyObjects = document.getXObjects(XWikiRepositoryModel.EXTENSIONDEPENDENCY_CLASSREFERENCE);
if (dependencyObjects != null) {
for (BaseObject dependencyObject : dependencyObjects) {
if (dependencyObject != null) {
String version = getValue(dependencyObject, XWikiRepositoryModel.PROP_DEPENDENCY_EXTENSIONVERSION);
if (!validVersions.contains(version)) {
// The version is invalid, removing it to not make the whole extension invalid
document.removeXObject(dependencyObject);
needSave = true;
}
}
}
}
for (Map.Entry<Version, String> entry : versions.entrySet()) {
Version version = entry.getKey();
String id = entry.getValue();
try {
Extension versionExtension;
if (version.equals(extension.getId().getVersion())) {
versionExtension = extension;
} else if (isVersionProxyingEnabled(document)) {
continue;
} else {
versionExtension = repository.resolve(new ExtensionId(id, version));
}
// Update version related informations
needSave |= updateExtensionVersion(document, versionExtension);
} catch (Exception e) {
this.logger.error("Failed to resolve extension with id [" + id + "] and version [" + version + "] on repository [" + repository + "]", e);
}
}
if (needSave) {
document.setAuthorReference(xcontext.getUserReference());
if (document.isNew()) {
document.setContentAuthorReference(xcontext.getUserReference());
document.setCreatorReference(xcontext.getUserReference());
}
xcontext.getWiki().saveDocument(document, "Imported extension [" + extensionId + "] from repository [" + repository.getDescriptor() + "]", true, xcontext);
}
return document.getDocumentReference();
}
use of org.xwiki.extension.ResolveException in project xwiki-platform by xwiki.
the class RepositoryManager method getExtensionVersionObject.
/**
* @since 9.5RC1
*/
public BaseObject getExtensionVersionObject(XWikiDocument extensionDocument, String version, boolean allowProxying) {
if (version == null) {
List<BaseObject> objects = extensionDocument.getXObjects(XWikiRepositoryModel.EXTENSIONVERSION_CLASSREFERENCE);
if (objects == null || objects.isEmpty()) {
return null;
} else {
return objects.get(objects.size() - 1);
}
}
BaseObject extensionVersionObject = extensionDocument.getObject(XWikiRepositoryModel.EXTENSIONVERSION_CLASSNAME, "version", version, false);
if (extensionVersionObject == null && allowProxying && isVersionProxyingEnabled(extensionDocument)) {
// no ExtensionVersionClass object so we need to create such object temporarily and delete it
try {
// FIXME - see XWIKI-14138 - this is nasty hack for obtaining ExtensionVersion XObject, when its
// FIXME information should be proxied and not stored permanently behind extension document
// FIXME To be substitude by some better solution in the future
XWikiDocument extensionDocumentClone = extensionDocument.clone();
addExtensionVersionObjectToDocument(extensionDocumentClone, version);
extensionVersionObject = extensionDocumentClone.getObject(XWikiRepositoryModel.EXTENSIONVERSION_CLASSNAME, "version", version, false);
} catch (XWikiException | ResolveException e) {
throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
}
}
return extensionVersionObject;
}
use of org.xwiki.extension.ResolveException in project xwiki-platform by xwiki.
the class ExtensionVersionFileRESTResource method downloadLocalExtension.
private ResponseBuilder downloadLocalExtension(String extensionId, String extensionVersion) throws ResolveException, IOException, QueryException, XWikiException {
XWikiDocument extensionDocument = getExistingExtensionDocumentById(extensionId);
checkRights(extensionDocument);
ResourceReference resourceReference = repositoryManager.getDownloadReference(extensionDocument, extensionVersion);
ResponseBuilder response = null;
if (ResourceType.ATTACHMENT.equals(resourceReference.getType())) {
// It's an attachment
AttachmentReference attachmentReference = this.attachmentResolver.resolve(resourceReference.getReference(), extensionDocument.getDocumentReference());
XWikiContext xcontext = getXWikiContext();
XWikiDocument document = xcontext.getWiki().getDocument(attachmentReference.getDocumentReference(), xcontext);
checkRights(document);
XWikiAttachment xwikiAttachment = document.getAttachment(attachmentReference.getName());
response = getAttachmentResponse(xwikiAttachment);
} else if (ResourceType.URL.equals(resourceReference.getType())) {
// It's an URL
URL url = new URL(resourceReference.getReference());
DefaultHttpClient httpClient = new DefaultHttpClient();
httpClient.getParams().setParameter(CoreProtocolPNames.USER_AGENT, "XWikiExtensionRepository");
httpClient.getParams().setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 60000);
httpClient.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 10000);
ProxySelectorRoutePlanner routePlanner = new ProxySelectorRoutePlanner(httpClient.getConnectionManager().getSchemeRegistry(), ProxySelector.getDefault());
httpClient.setRoutePlanner(routePlanner);
HttpGet getMethod = new HttpGet(url.toString());
HttpResponse subResponse;
try {
subResponse = httpClient.execute(getMethod);
} catch (Exception e) {
throw new IOException("Failed to request [" + getMethod.getURI() + "]", e);
}
response = Response.status(subResponse.getStatusLine().getStatusCode());
// TODO: find a proper way to do a perfect proxy of the URL without directly using Restlet classes.
// Should probably use javax.ws.rs.ext.MessageBodyWriter
HttpEntity entity = subResponse.getEntity();
InputRepresentation content = new InputRepresentation(entity.getContent(), entity.getContentType() != null ? new MediaType(entity.getContentType().getValue()) : MediaType.APPLICATION_OCTET_STREAM, entity.getContentLength());
BaseObject extensionObject = getExtensionObject(extensionDocument);
String type = getValue(extensionObject, XWikiRepositoryModel.PROP_EXTENSION_TYPE);
Disposition disposition = new Disposition(Disposition.TYPE_ATTACHMENT);
disposition.setFilename(extensionId + '-' + extensionVersion + '.' + type);
content.setDisposition(disposition);
response.entity(content);
} else if (ExtensionResourceReference.TYPE.equals(resourceReference.getType())) {
ExtensionResourceReference extensionResource;
if (resourceReference instanceof ExtensionResourceReference) {
extensionResource = (ExtensionResourceReference) resourceReference;
} else {
extensionResource = new ExtensionResourceReference(resourceReference.getReference());
}
response = downloadRemoteExtension(extensionResource);
} else {
throw new WebApplicationException(Status.NOT_FOUND);
}
return response;
}
use of org.xwiki.extension.ResolveException in project xwiki-platform by xwiki.
the class RepairXarJob method getLocalXARExtension.
/**
* @param extensionId the extension unique identifier
* @return the stored local extension
* @throws InstallException failed to store extension
*/
private LocalExtension getLocalXARExtension(ExtensionId extensionId) throws InstallException {
LocalExtension localExtension = this.localRepository.getLocalExtension(extensionId);
if (localExtension == null) {
this.progressManager.pushLevelProgress(2, this);
try {
this.progressManager.startStep(this);
Extension extension = this.repositoryManager.resolve(extensionId);
this.progressManager.endStep(this);
this.progressManager.startStep(this);
if (extension.getType().equals(XarExtensionHandler.TYPE)) {
localExtension = this.localExtensionRepository.storeExtension(extension);
}
this.progressManager.endStep(this);
} catch (ResolveException e) {
throw new InstallException("Failed to find extension", e);
} catch (LocalExtensionRepositoryException e) {
throw new InstallException("Failed save extension in local repository", e);
} finally {
this.progressManager.popLevelProgress(this);
}
} else if (!localExtension.getType().equals(XarExtensionHandler.TYPE)) {
localExtension = null;
}
return localExtension;
}
use of org.xwiki.extension.ResolveException in project xwiki-platform by xwiki.
the class ExtensionRatingScriptService method getRating.
/**
* @param extensionId the extension id
* @param extensionVersion the extension version
* @return the rating of an extension
*/
public ExtensionRating getRating(String extensionId, String extensionVersion) {
setError(null);
Collection<ExtensionRepository> repositories = getRepositories();
for (ExtensionRepository repository : repositories) {
if (repository instanceof Ratable) {
try {
setError(null);
return ((Ratable) repository).getRating(extensionId, extensionVersion);
} catch (ResolveException e) {
setError(e);
// Keep looking. Maybe there's another repository with the same extension.
continue;
}
}
}
return null;
}
Aggregations