diff --git a/downloads/discovery/luna/modeling.xmi b/downloads/discovery/luna/modeling.xmi
index edcf5ff..bbe490f 100755
--- a/downloads/discovery/luna/modeling.xmi
+++ b/downloads/discovery/luna/modeling.xmi
@@ -14,7 +14,7 @@
         description="Acceleo is a standard-based template language focused on usability and pragmatism."
         license="EPL"
         image32="images/acceleo.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary=" Acceleo is a pragmatic implementation of the Object Management Group (OMG) MOF Model to Text Language (MTL) standard.&#xA;&#xA;You do not need to be an expert to start using the plug-ins and create your first code generator : using the provided example projects and the powerful completion feature of the Acceleo editor, it is very easy to get started once you understand the basic principles. "
           screenshot="images/acceleo-screenshot-320x240.png"/>
@@ -26,7 +26,7 @@
         description="Xpand is an efficient code generation framework with a statically-typed template language and support for arbitrary input model types."
         license="EPL"
         image32="images/xpand.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="Xpand allows to write code generators for many different types of models. These&#xA;models include EMF models, UML models, XML documents and textual DSL models.&#xA;Any type of source code can be generated from the model sources. Xpand has&#xA;strong emphasize on reducing the effort to create industry-strength code&#xA;generators and provides outstanding Eclipse integration.&#xA;&#xA;Xpand's features include:&#xA; &#x2022; support of various modeling tools&#xA; &#x2022; support of EMF (Eclipse Modeling Framework)&#xA; &#x2022; model-to-code transformations&#xA; &#x2022; model-to-model transformations             &#xA; &#x2022; model validation&#xA; &#x2022; expression language&#xA; &#x2022; static code analysis&#xA; &#x2022; aspect oriented programming&#xA; &#x2022; support for standalone execution"
           screenshot="images/xpand-screenshot-320x240.png"/>
@@ -44,7 +44,7 @@
         description="ATL is a model transformation language and toolkit, including an ATL transformation engine and an IDE for ATL."
         license="EPL"
         image32="images/atl.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="The ATL component of the M2M project provides ways to produce a set of target models from a set of source models. An ATL transformation program is composed of rules that define how source model elements are matched and navigated to create and initialize the elements of the target models. Developed on top of the Eclipse platform, the ATL toolkit provides a number of standard development tools (advanced editor, debugger, profiler, etc.) that aims to ease development of ATL transformations."
           screenshot="images/atl-screenshot-320x240.png"
@@ -61,7 +61,7 @@
         image32="images/qvtd.png"
         incubation="true"
         visible="false">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="QVTd project currently provides Editors for&#xA;&#xA;- QVT Relational documents&#xA;- QVT Core documents&#xA;&#xA;QVTc and QVTr execution is work in progress"
           screenshot="images/qvtd-screenshot-320x240.png"
@@ -74,7 +74,7 @@
         description="Implementation of the Operational part of the OMG QVT (Query/View/Transformation) open standard"
         license="EPL"
         image32="images/qvto.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="Based on MDT OCL, the Operational QVT project aims to be fully compliant with the OMG QVT standard providing a powerful Eclipse IDE with feature-rich editor (code completion, outline, navigation, etc.), debugger, project builders, launch configurations, deployment facilities and Ant support."
           screenshot="images/qvto-screenshot-320x240.png"
@@ -93,7 +93,7 @@
         license="EPL"
         groups="//@filters.0"
         image32="images/sirius.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="A modeling workbench created with Sirius is composed of a set of Eclipse editors (diagrams, tables and trees) which allow the users to create, edit and visualize EMF models.&#xA;The editors are defined by a model which defines the complete structure of the modeling workbench, its behavior and all the edition and navigation tools. This description of a Sirius modeling workbench is dynamically interpreted by a runtime within the Eclipse IDE.&#xA;For supporting specific need for customization, Sirius is extensible in many ways, notably by providing new kinds of representations, new query languages and by being able to call Java code to interact with Eclipse or any other system."
           screenshot="images/sirius-screenshot-320x240.png"
@@ -112,7 +112,7 @@
         description="EEF (Extended Editing Framework) is a presentation framework for EMF models. "
         license="EPL"
         image32="images/eef.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="The Extended Editing Framework aims at giving another way to improve the EMF model creation phase by providing new services dedicated to editing and using more appealing editing elements. The way to obtain these services and elements is based on a generative approach similar to the EMF.Edit one. The framework provides advanced editing components for the properties of EMF elements and a default generation based on standard metamodels using these components."
           screenshot="images/eef-screenshot-320x240.png"
@@ -125,7 +125,7 @@
         description="GMF Tooling is a framework to generate functional graphical editors based on the GMF Runtime."
         license="EPL"
         image32="images/gmf.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <id>org.eclipse.gmf.sdk</id>
     </components>
     <components
@@ -136,7 +136,7 @@
         groups="//@filters.0"
         image32="images/graphiti.png"
         incubation="true">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="The goal of Graphiti is to support the fast and easy creation of graphical tools, which can display and edit underlying domain models using a tool-defined graphical notation. Graphiti supports the developer in getting to a first version of an editor with very low effort by:&#xA;- Hiding platform specific technology (e.g. GEF / Draw2D on Eclipse)&#xA;- Providing rich default implementations inside the framework&#xA;- Providing a default look and feel that was designed in close co-operation with usability specialists"
           screenshot="images/graphiti-screenshot-320x240.png"
@@ -150,7 +150,7 @@
         license="EPL"
         groups="//@filters.0"
         image32="images/xtext.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="Xtext is a framework for development of programming languages and domain&#xA;specific languages (DSLs). Just describe your very own DSL using Xtext's simple&#xA;EBNF grammar language and the generator will create a parser, an AST-meta model&#xA;(implemented in EMF) as well as a full-featured Eclipse text editor from that.&#xA;&#xA;The Framework integrates with frameworks from Eclipse Modeling such as EMF, GMF&#xA;and M2T as well as other Eclipse based technologies. Development with Xtext is&#xA;optimized for short turn-arounds, so that adding new features to an existing&#xA;DSL is a matter of minutes. Still sophisticated programming languages can be&#xA;implemented."
           screenshot="images/xtext-screenshot-320x240.png"/>
@@ -167,8 +167,8 @@
         description="Class diagrams and rich editing capabilities for your domain models."
         license="EPL"
         image32="images/sirius.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
       <sitesURLS>http://download.eclipse.org/ecoretools/updates/nightly/2.0.x/luna</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="EcoreTools is a graphical modeler to create, edit and analyze Ecore models.&#xA;&#xA;It provides several a class diagram editor (similar to UML Class Diagrams), a package dependencies diagram editor and several table editors to design your Ecore model."
           screenshot="images/ecoretools-screenshot-320x240.png"
@@ -197,7 +197,7 @@
         image32=""
         incubation="true"
         visible="false">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="UML2Tools provides support for Class, Composite Structure, Component,&#xA;Deployment, UseCase, Activity and StateMachine diagram. It also contains&#xA;supplementary Profile Definition diagram, enabling the visual integration of&#xA;the custom defined stereotypes with the other supported diagrams."
           screenshot="images/uml2tools-screenshot-320x240.png"/>
@@ -216,7 +216,7 @@
         groups="//@filters.0"
         image32="images/modisco.png"
         incubation="true">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="MoDisco provides standard metamodels to describe existing systems, discoverers&#xA;to automaticaly create models from Java and XML source code, and generic tools&#xA;to understand and transform complex models.&#xA;"
           screenshot="images/modisco-screenshot-320x240.png"
@@ -234,7 +234,7 @@
         provider="Eclipse.org"
         license="EPL"
         visible="false">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
     </components>
     <components
         name="Agent Modeling Platform"
@@ -245,7 +245,7 @@
         image32="images/amp.png"
         incubation="true"
         visible="false">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <sitesURLS>http://lwjgl.org/update</sitesURLS>
       <sitesURLS>http://ascape.sourceforge.net/eclipse</sitesURLS>
       <sitesURLS>http://download.eclipse.org/amp/updates/releases</sitesURLS>
@@ -263,7 +263,7 @@
         groups="//@filters.0"
         incubation="true"
         visible="false">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
     </components>
     <components
         name="EGF"
@@ -272,7 +272,7 @@
         license="EPL"
         groups="//@filters.0"
         image32="images/egf.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="In order to improve the software development industrialization, a major step consists in mass-producing software. This mass-production must be customizable, and must be able to support complex, large-scale and heterogeneous generations. Given the today's available Eclipse tools, the issue here is not to provide either a new transformation engine (model-to-model, model-to-text, text-to-model, text-to-text) or DSL (Domain-Specific Language) editor but to realize their integration for flexible software mass-production."
           screenshot="images/egf-screenshot-320x240.png"
@@ -300,7 +300,7 @@
         description="Teneo is a Model-Relational mapping and runtime database persistence solution for the Eclipse Modeling Framework (EMF) using Hibernate and EclipseLink."
         license="EPL"
         visible="false">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="The EMF &#x2013; Hibernate integration supports all EMF features and standard EclipseLink and Hibernate features. EMF objects can be persisted in most major relational databases and retrieved using an EMF resource approach or HQL/JPA queries. A distinctive feature of Teneo is that you can override/extend the Model-Relational mapping using JPA annotations in the model."
           screenshot="images/teneo-screenshot-320x240.png"
@@ -314,7 +314,7 @@
         description="An evaluation Console for OCL expressions, and Xtext Editors for Complete OCL documents, Combined OCL in Ecore Models and for individual OCL expressions"
         license="EPL"
         image32="images/ocl.png">
-      <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
+      <sitesURLS>http://download.eclipse.org/releases/luna/201502271000</sitesURLS>
       <overview
           summary="The Examples for the Object Constraint Language provide&#xA;&#xA;Xtext Editors for&#xA;- CompleteOCL documents to enhance Ecore or UML models&#xA;- OCL in Ecore documents defining OCL and Ecore at once&#xA;- Individual Expressions for use by other tools&#xA;- the OCL Standard Library"
           screenshot="images/ocl-screenshot-320x240.png"
