webui/src/org/apache/ace/server/AssociationServiceImpl.java - ace - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.ace.server;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import javax.servlet.http.HttpServletRequest;

 import org.apache.ace.client.repository.RepositoryAdmin;
 import org.apache.ace.client.repository.RepositoryObject;
 import org.apache.ace.client.repository.helper.bundle.BundleHelper;
 import org.apache.ace.client.repository.object.ArtifactObject;
 import org.apache.ace.client.repository.object.GatewayObject;
 import org.apache.ace.client.repository.object.GroupObject;
 import org.apache.ace.client.repository.object.LicenseObject;
 import org.apache.ace.client.repository.repository.Artifact2GroupAssociationRepository;
 import org.apache.ace.client.repository.repository.Group2LicenseAssociationRepository;
 import org.apache.ace.client.repository.repository.License2GatewayAssociationRepository;
 import org.apache.ace.client.repository.stateful.StatefulGatewayObject;
 import org.apache.ace.client.services.AssociationService;
 import org.apache.ace.client.services.BundleDescriptor;
 import org.apache.ace.client.services.Descriptor;
 import org.apache.ace.client.services.GroupDescriptor;
 import org.apache.ace.client.services.LicenseDescriptor;
 import org.apache.ace.client.services.TargetDescriptor;
 import org.osgi.service.log.LogService;

 import com.google.gwt.user.server.rpc.RemoteServiceServlet;

 /**
  * Allows the linking of objects; will find the {@link RepositoryAdmin}'s representation for
  * each of the descriptor objects.
  */
 public class AssociationServiceImpl extends RemoteServiceServlet implements AssociationService {

     /**
      * Generated serialVersionUID
      */
     private static final long serialVersionUID = 2413722456179463935L;
     private AssocationType m_assocationType = AssocationType.DYNAMIC;

     public void setAssocationType(AssocationType type) {
         m_assocationType  = type;
     }
     public AssocationType getAssocationType() {
         return m_assocationType;
     }

     public void link(BundleDescriptor bundle, GroupDescriptor group) throws Exception {
         HttpServletRequest request = getThreadLocalRequest();
         Artifact2GroupAssociationRepository a2gr = Activator.getService(request, Artifact2GroupAssociationRepository.class);

         ArtifactObject a = (ArtifactObject) ObjectMapping.unwrap(request, bundle);
         GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);

         switch (m_assocationType) {
             case STATIC:
                 a2gr.create(a, g);
                 break;
             case DYNAMIC:
                 Map<String, String> properties = new HashMap<String, String>();
                 properties.put(BundleHelper.KEY_ASSOCIATION_VERSIONSTATEMENT, "0.0.0");
                 a2gr.create(a, properties, g, null);
                 break;
         }
     }

     private void unlink(BundleDescriptor bundle, GroupDescriptor group) throws Exception {
         HttpServletRequest request = getThreadLocalRequest();
         Artifact2GroupAssociationRepository a2gr = Activator.getService(request, Artifact2GroupAssociationRepository.class);

         ArtifactObject a = (ArtifactObject) ObjectMapping.unwrap(request, bundle);
         GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);

         a2gr.remove(a.getAssociationsWith(g).get(0));
     }

     public void link(GroupDescriptor group, LicenseDescriptor license) throws Exception {
         HttpServletRequest request = getThreadLocalRequest();
         Group2LicenseAssociationRepository g2lr = Activator.getService(request, Group2LicenseAssociationRepository.class);

         GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);
         LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);

         g2lr.create(g, l);
     }

     private void unlink(GroupDescriptor group, LicenseDescriptor license) throws Exception {
         HttpServletRequest request = getThreadLocalRequest();
         Group2LicenseAssociationRepository g2lr = Activator.getService(request, Group2LicenseAssociationRepository.class);

         GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);
         LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);

         g2lr.remove(g.getAssociationsWith(l).get(0));
     }

     public void link(LicenseDescriptor license, TargetDescriptor target) throws Exception {
         HttpServletRequest request = getThreadLocalRequest();
         License2GatewayAssociationRepository l2tr = Activator.getService(request, License2GatewayAssociationRepository.class);

         LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);
         StatefulGatewayObject g = (StatefulGatewayObject) ObjectMapping.unwrap(request, target);

         if (!g.isRegistered()) {
             g.register();
             g.setAutoApprove(true);
         }

         l2tr.create(l, g.getGatewayObject());
     }

     private void unlink(LicenseDescriptor license, TargetDescriptor target) throws Exception {
         HttpServletRequest request = getThreadLocalRequest();
         License2GatewayAssociationRepository l2tr = Activator.getService(request, License2GatewayAssociationRepository.class);

         LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);
         StatefulGatewayObject g = (StatefulGatewayObject) ObjectMapping.unwrap(request, target);

         l2tr.remove(l.getAssociationsWith(g.getGatewayObject()).get(0));
     }

     public void unlink(Descriptor one, Descriptor other) throws Exception {
         _unlink(one, other);
         _unlink(other, one);
     }

     /**
      * Helper method for the unlink method, which allows easier checking of 'both ways' of an association.
      */
     private void _unlink(Descriptor one, Descriptor other) throws Exception {
         if (one instanceof BundleDescriptor && other instanceof GroupDescriptor) {
             unlink((BundleDescriptor) one, (GroupDescriptor) other);
         }
         else if (one instanceof GroupDescriptor && other instanceof LicenseDescriptor) {
             unlink((GroupDescriptor) one, (LicenseDescriptor) other);
         }
         else if (one instanceof LicenseDescriptor && other instanceof TargetDescriptor) {
             unlink((LicenseDescriptor) one, (TargetDescriptor) other);
         }
     }

     public Descriptor[] getRelated(Descriptor o) throws Exception {
         try {
             HttpServletRequest request = getThreadLocalRequest();
             RepositoryObject a = ObjectMapping.unwrap(request, o);
             List<RepositoryObject> relatedObjects = getRelated(request, a);
             List<Descriptor> descriptors = ObjectMapping.wrap(relatedObjects);
             return descriptors.toArray(new Descriptor[descriptors.size()]);
         }
         catch (Exception e) {
             Activator.instance().getLog().log(LogService.LOG_ERROR, "Error getting related objects", e);
             throw e;
         }
     }

     /**
      * Helper method that finds all related {@link RepositoryObject}s for a given one.
      */
     private List<RepositoryObject> getRelated(HttpServletRequest request, RepositoryObject object) throws Exception {
         List<RepositoryObject> result = new ArrayList<RepositoryObject>();
         if (object instanceof ArtifactObject) {
             List<GroupObject> groups = getRelated(object, GroupObject.class);
             List<LicenseObject> licenses = getRelated(groups, LicenseObject.class);
             List<GatewayObject> targets = getRelated(licenses, GatewayObject.class);
             result.addAll(groups);
             result.addAll(licenses);
             result.addAll(TargetServiceImpl.instance().findSGOs(request, targets));
         }
         else if (object instanceof GroupObject) {
             List<ArtifactObject> artifacts = getRelated(object, ArtifactObject.class);
             List<LicenseObject> licenses = getRelated(object, LicenseObject.class);
             List<GatewayObject> targets = getRelated(licenses, GatewayObject.class);
             result.addAll(artifacts);
             result.addAll(licenses);
             result.addAll(TargetServiceImpl.instance().findSGOs(request, targets));
         }
         else if (object instanceof LicenseObject) {
             List<GroupObject> groups = getRelated(object, GroupObject.class);
             List<ArtifactObject> artifacts = getRelated(groups, ArtifactObject.class);
             List<GatewayObject> targets = getRelated(object, GatewayObject.class);
             result.addAll(artifacts);
             result.addAll(groups);
             result.addAll(TargetServiceImpl.instance().findSGOs(request, targets));
         }
         else if (object instanceof StatefulGatewayObject && ((StatefulGatewayObject) object).isRegistered()) {
             // We can ignore any non-registered SGO's, since these will never have any associations.
             List<LicenseObject> licenses = getRelated(object, LicenseObject.class);
             List<GroupObject> groups = getRelated(licenses, GroupObject.class);
             List<ArtifactObject> artifacts = getRelated(groups, ArtifactObject.class);
             result.addAll(artifacts);
             result.addAll(groups);
             result.addAll(licenses);
         }
         return result;
     }

     /**
      * Helper method to find all related {@link RepositoryObject}s in a given 'direction'
      */
     private <FROM extends RepositoryObject, TO extends RepositoryObject> List<TO> getRelated(FROM from, Class<TO> toClass) {
         return from.getAssociations(toClass);
     }

     /**
      * Helper method to find all related {@link RepositoryObject}s in a given 'direction', starting with a list of objects
      */
     private <FROM extends RepositoryObject, TO extends RepositoryObject> List<TO> getRelated(List<FROM> from, Class<TO> toClass) {
         List<TO> result = new ArrayList<TO>();
         for (RepositoryObject o : from) {
             result.addAll(getRelated(o, toClass));
         }
         return result;
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.ace.server;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import javax.servlet.http.HttpServletRequest;

	import org.apache.ace.client.repository.RepositoryAdmin;
	import org.apache.ace.client.repository.RepositoryObject;
	import org.apache.ace.client.repository.helper.bundle.BundleHelper;
	import org.apache.ace.client.repository.object.ArtifactObject;
	import org.apache.ace.client.repository.object.GatewayObject;
	import org.apache.ace.client.repository.object.GroupObject;
	import org.apache.ace.client.repository.object.LicenseObject;
	import org.apache.ace.client.repository.repository.Artifact2GroupAssociationRepository;
	import org.apache.ace.client.repository.repository.Group2LicenseAssociationRepository;
	import org.apache.ace.client.repository.repository.License2GatewayAssociationRepository;
	import org.apache.ace.client.repository.stateful.StatefulGatewayObject;
	import org.apache.ace.client.services.AssociationService;
	import org.apache.ace.client.services.BundleDescriptor;
	import org.apache.ace.client.services.Descriptor;
	import org.apache.ace.client.services.GroupDescriptor;
	import org.apache.ace.client.services.LicenseDescriptor;
	import org.apache.ace.client.services.TargetDescriptor;
	import org.osgi.service.log.LogService;

	import com.google.gwt.user.server.rpc.RemoteServiceServlet;

	/**
	* Allows the linking of objects; will find the {@link RepositoryAdmin}'s representation for
	* each of the descriptor objects.
	*/
	public class AssociationServiceImpl extends RemoteServiceServlet implements AssociationService {

	/**
	* Generated serialVersionUID
	*/
	private static final long serialVersionUID = 2413722456179463935L;
	private AssocationType m_assocationType = AssocationType.DYNAMIC;

	public void setAssocationType(AssocationType type) {
	m_assocationType = type;
	}
	public AssocationType getAssocationType() {
	return m_assocationType;
	}

	public void link(BundleDescriptor bundle, GroupDescriptor group) throws Exception {
	HttpServletRequest request = getThreadLocalRequest();
	Artifact2GroupAssociationRepository a2gr = Activator.getService(request, Artifact2GroupAssociationRepository.class);

	ArtifactObject a = (ArtifactObject) ObjectMapping.unwrap(request, bundle);
	GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);

	switch (m_assocationType) {
	case STATIC:
	a2gr.create(a, g);
	break;
	case DYNAMIC:
	Map<String, String> properties = new HashMap<String, String>();
	properties.put(BundleHelper.KEY_ASSOCIATION_VERSIONSTATEMENT, "0.0.0");
	a2gr.create(a, properties, g, null);
	break;
	}
	}

	private void unlink(BundleDescriptor bundle, GroupDescriptor group) throws Exception {
	HttpServletRequest request = getThreadLocalRequest();
	Artifact2GroupAssociationRepository a2gr = Activator.getService(request, Artifact2GroupAssociationRepository.class);

	ArtifactObject a = (ArtifactObject) ObjectMapping.unwrap(request, bundle);
	GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);

	a2gr.remove(a.getAssociationsWith(g).get(0));
	}

	public void link(GroupDescriptor group, LicenseDescriptor license) throws Exception {
	HttpServletRequest request = getThreadLocalRequest();
	Group2LicenseAssociationRepository g2lr = Activator.getService(request, Group2LicenseAssociationRepository.class);

	GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);
	LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);

	g2lr.create(g, l);
	}

	private void unlink(GroupDescriptor group, LicenseDescriptor license) throws Exception {
	HttpServletRequest request = getThreadLocalRequest();
	Group2LicenseAssociationRepository g2lr = Activator.getService(request, Group2LicenseAssociationRepository.class);

	GroupObject g = (GroupObject) ObjectMapping.unwrap(request, group);
	LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);

	g2lr.remove(g.getAssociationsWith(l).get(0));
	}

	public void link(LicenseDescriptor license, TargetDescriptor target) throws Exception {
	HttpServletRequest request = getThreadLocalRequest();
	License2GatewayAssociationRepository l2tr = Activator.getService(request, License2GatewayAssociationRepository.class);

	LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);
	StatefulGatewayObject g = (StatefulGatewayObject) ObjectMapping.unwrap(request, target);

	if (!g.isRegistered()) {
	g.register();
	g.setAutoApprove(true);
	}

	l2tr.create(l, g.getGatewayObject());
	}

	private void unlink(LicenseDescriptor license, TargetDescriptor target) throws Exception {
	HttpServletRequest request = getThreadLocalRequest();
	License2GatewayAssociationRepository l2tr = Activator.getService(request, License2GatewayAssociationRepository.class);

	LicenseObject l = (LicenseObject) ObjectMapping.unwrap(request, license);
	StatefulGatewayObject g = (StatefulGatewayObject) ObjectMapping.unwrap(request, target);

	l2tr.remove(l.getAssociationsWith(g.getGatewayObject()).get(0));
	}

	public void unlink(Descriptor one, Descriptor other) throws Exception {
	_unlink(one, other);
	_unlink(other, one);
	}

	/**
	* Helper method for the unlink method, which allows easier checking of 'both ways' of an association.
	*/
	private void _unlink(Descriptor one, Descriptor other) throws Exception {
	if (one instanceof BundleDescriptor && other instanceof GroupDescriptor) {
	unlink((BundleDescriptor) one, (GroupDescriptor) other);
	}
	else if (one instanceof GroupDescriptor && other instanceof LicenseDescriptor) {
	unlink((GroupDescriptor) one, (LicenseDescriptor) other);
	}
	else if (one instanceof LicenseDescriptor && other instanceof TargetDescriptor) {
	unlink((LicenseDescriptor) one, (TargetDescriptor) other);
	}
	}

	public Descriptor[] getRelated(Descriptor o) throws Exception {
	try {
	HttpServletRequest request = getThreadLocalRequest();
	RepositoryObject a = ObjectMapping.unwrap(request, o);
	List<RepositoryObject> relatedObjects = getRelated(request, a);
	List<Descriptor> descriptors = ObjectMapping.wrap(relatedObjects);
	return descriptors.toArray(new Descriptor[descriptors.size()]);
	}
	catch (Exception e) {
	Activator.instance().getLog().log(LogService.LOG_ERROR, "Error getting related objects", e);
	throw e;
	}
	}

	/**
	* Helper method that finds all related {@link RepositoryObject}s for a given one.
	*/
	private List<RepositoryObject> getRelated(HttpServletRequest request, RepositoryObject object) throws Exception {
	List<RepositoryObject> result = new ArrayList<RepositoryObject>();
	if (object instanceof ArtifactObject) {
	List<GroupObject> groups = getRelated(object, GroupObject.class);
	List<LicenseObject> licenses = getRelated(groups, LicenseObject.class);
	List<GatewayObject> targets = getRelated(licenses, GatewayObject.class);
	result.addAll(groups);
	result.addAll(licenses);
	result.addAll(TargetServiceImpl.instance().findSGOs(request, targets));
	}
	else if (object instanceof GroupObject) {
	List<ArtifactObject> artifacts = getRelated(object, ArtifactObject.class);
	List<LicenseObject> licenses = getRelated(object, LicenseObject.class);
	List<GatewayObject> targets = getRelated(licenses, GatewayObject.class);
	result.addAll(artifacts);
	result.addAll(licenses);
	result.addAll(TargetServiceImpl.instance().findSGOs(request, targets));
	}
	else if (object instanceof LicenseObject) {
	List<GroupObject> groups = getRelated(object, GroupObject.class);
	List<ArtifactObject> artifacts = getRelated(groups, ArtifactObject.class);
	List<GatewayObject> targets = getRelated(object, GatewayObject.class);
	result.addAll(artifacts);
	result.addAll(groups);
	result.addAll(TargetServiceImpl.instance().findSGOs(request, targets));
	}
	else if (object instanceof StatefulGatewayObject && ((StatefulGatewayObject) object).isRegistered()) {
	// We can ignore any non-registered SGO's, since these will never have any associations.
	List<LicenseObject> licenses = getRelated(object, LicenseObject.class);
	List<GroupObject> groups = getRelated(licenses, GroupObject.class);
	List<ArtifactObject> artifacts = getRelated(groups, ArtifactObject.class);
	result.addAll(artifacts);
	result.addAll(groups);
	result.addAll(licenses);
	}
	return result;
	}

	/**
	* Helper method to find all related {@link RepositoryObject}s in a given 'direction'
	*/
	private <FROM extends RepositoryObject, TO extends RepositoryObject> List<TO> getRelated(FROM from, Class<TO> toClass) {
	return from.getAssociations(toClass);
	}

	/**
	* Helper method to find all related {@link RepositoryObject}s in a given 'direction', starting with a list of objects
	*/
	private <FROM extends RepositoryObject, TO extends RepositoryObject> List<TO> getRelated(List<FROM> from, Class<TO> toClass) {
	List<TO> result = new ArrayList<TO>();
	for (RepositoryObject o : from) {
	result.addAll(getRelated(o, toClass));
	}
	return result;
	}

	}