http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-core/src/main/java/org/apache/airavata/sharing/registry/server/SharingRegistryServerHandler.java ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/main/java/org/apache/airavata/sharing/registry/server/SharingRegistryServerHandler.java b/modules/sharing-registry/sharing-registry-core/src/main/java/org/apache/airavata/sharing/registry/server/SharingRegistryServerHandler.java new file mode 100644 index 0000000..7ae1c64 --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/main/java/org/apache/airavata/sharing/registry/server/SharingRegistryServerHandler.java @@ -0,0 +1,585 @@ +/* + * + * 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.airavata.sharing.registry.server; + +import org.apache.airavata.sharing.registry.db.entities.GroupMembershipEntityPK; +import org.apache.airavata.sharing.registry.db.entities.SharingEntityPK; +import org.apache.airavata.sharing.registry.db.repositories.*; +import org.apache.airavata.sharing.registry.db.utils.DBConstants; +import org.apache.airavata.sharing.registry.models.*; +import org.apache.airavata.sharing.registry.service.cpi.GovRegistryService; +import org.apache.thrift.TException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.lang.reflect.Field; +import java.util.*; + +public class SharingRegistryServerHandler implements GovRegistryService.Iface{ + private final static Logger logger = LoggerFactory.getLogger(SharingRegistryServerHandler.class); + + public static String GLOBAL_PERMISSION_NAME = "GLOBAL"; + + private DomainRepository domainRepository; + private UserRepository userRepository; + private UserGroupRepository userGroupRepository; + private GroupMembershipRepository groupMembershipRepository; + private EntityTypeRepository entityTypeRepository; + private PermissionTypeRepository permissionTypeRepository; + private EntityRepository entityRepository; + private SharingRepository sharingRepository; + + public SharingRegistryServerHandler(){ + this.domainRepository = new DomainRepository(); + this.userRepository = new UserRepository(); + this.userGroupRepository = new UserGroupRepository(); + this.groupMembershipRepository = new GroupMembershipRepository(); + this.entityTypeRepository = new EntityTypeRepository(); + this.permissionTypeRepository = new PermissionTypeRepository(); + this.entityRepository = new EntityRepository(); + this.sharingRepository = new SharingRepository(); + } + + /** + * * Domain Operations + * * + */ + @Override + public String createDomain(Domain domain) throws GovRegistryException, TException { + if(domainRepository.get(domain.domainId) != null) + throw new GovRegistryException("There exist domain with given domain id"); + + domain.setCreatedTime(System.currentTimeMillis()); + domain.setUpdatedTime(System.currentTimeMillis()); + domainRepository.create(domain); + + //create the global permission for the domain + PermissionType permissionType = new PermissionType(); + permissionType.setPermissionTypeId(domain.domainId+":"+GLOBAL_PERMISSION_NAME); + permissionType.setDomainId(domain.domainId); + permissionType.setName(GLOBAL_PERMISSION_NAME); + permissionType.setDescription("GLOBAL permission to " + domain.domainId); + permissionType.setCreatedTime(System.currentTimeMillis()); + permissionType.setUpdatedTime(System.currentTimeMillis()); + permissionTypeRepository.create(permissionType); + + return domain.domainId; + } + + @Override + public boolean updateDomain(Domain domain) throws GovRegistryException, TException { + Domain oldDomain = domainRepository.get(domain.domainId); + domain.setCreatedTime(oldDomain.createdTime); + domain.setUpdatedTime(System.currentTimeMillis()); + domain = getUpdatedObject(oldDomain, domain); + domainRepository.update(domain); + return true; + } + + @Override + public boolean deleteDomain(String domainId) throws GovRegistryException, TException { + domainRepository.delete(domainId); + return true; + } + + @Override + public Domain getDomain(String domainId) throws GovRegistryException, TException { + return domainRepository.get(domainId); + } + + @Override + public List<Domain> getDomains(int offset, int limit) throws TException { + return domainRepository.select(new HashMap<>(), offset, limit); + } + + /** + * * User Operations + * * + */ + @Override + public String createUser(User user) throws GovRegistryException, TException { + if(userRepository.get(user.userId) != null) + throw new GovRegistryException("There exist user with given user id"); + + user.setCreatedTime(System.currentTimeMillis()); + user.setUpdatedTime(System.currentTimeMillis()); + userRepository.create(user); + + UserGroup userGroup = new UserGroup(); + userGroup.setGroupId(user.userId); + userGroup.setDomainId(user.domainId); + userGroup.setName(user.userName); + userGroup.setDescription("user " + user.userName + " group"); + userGroup.setOwnerId(user.userId); + userGroup.setGroupType(GroupType.SINGLE_USER); + createGroup(userGroup); + + return user.userId; + } + + @Override + public boolean updatedUser(User user) throws GovRegistryException, TException { + User oldUser = userRepository.get(user.userId); + user.setCreatedTime(oldUser.createdTime); + user.setUpdatedTime(System.currentTimeMillis()); + user = getUpdatedObject(oldUser, user); + userRepository.update(user); + + UserGroup userGroup = userGroupRepository.get(user.userId); + userGroup.setName(user.userName); + userGroup.setDescription("user " + user.userName + " group"); + updateGroup(userGroup); + return true; + } + + @Override + public boolean deleteUser(String userId) throws GovRegistryException, TException { + userRepository.delete(userId); + userGroupRepository.delete(userId); + return true; + } + + @Override + public User getUser(String userId) throws GovRegistryException, TException { + return userRepository.get(userId); + } + + @Override + public List<User> getUsers(String domain, int offset, int limit) throws GovRegistryException, TException { + HashMap<String, String> filters = new HashMap<>(); + filters.put(DBConstants.UserTable.DOMAIN_ID, domain); + return userRepository.select(filters, offset, limit); + } + + /** + * * Group Operations + * * + */ + @Override + public String createGroup(UserGroup group) throws GovRegistryException, TException { + if(userGroupRepository.get(group.groupId) != null) + throw new GovRegistryException("There exist group with given group id"); + + group.setCreatedTime(System.currentTimeMillis()); + group.setUpdatedTime(System.currentTimeMillis()); + userGroupRepository.create(group); + return group.groupId; + } + + @Override + public boolean updateGroup(UserGroup group) throws GovRegistryException, TException { + group.setUpdatedTime(System.currentTimeMillis()); + UserGroup oldGroup = userGroupRepository.get(group.groupId); + group.setCreatedTime(oldGroup.createdTime); + group = getUpdatedObject(oldGroup, group); + userGroupRepository.update(group); + return true; + } + + @Override + public boolean deleteGroup(String groupId) throws GovRegistryException, TException { + userGroupRepository.delete(groupId); + return true; + } + + @Override + public UserGroup getGroup(String groupId) throws GovRegistryException, TException { + return userGroupRepository.get(groupId); + } + + @Override + public List<UserGroup> getGroups(String domain, int offset, int limit) throws TException { + HashMap<String, String> filters = new HashMap<>(); + filters.put(DBConstants.UserTable.DOMAIN_ID, domain); + return userGroupRepository.select(filters, offset, limit); + } + + @Override + public boolean addUsersToGroup(List<String> userIds, String groupId) throws GovRegistryException, TException { + for(int i=0; i < userIds.size(); i++){ + GroupMembership groupMembership = new GroupMembership(); + groupMembership.setParentId(groupId); + groupMembership.setChildId(userIds.get(i)); + groupMembership.setChildType(GroupChildType.USER); + groupMembership.setCreatedTime(System.currentTimeMillis()); + groupMembership.setUpdatedTime(System.currentTimeMillis()); + groupMembershipRepository.create(groupMembership); + } + return true; + } + + @Override + public boolean removeUsersFromGroup(List<String> userIds, String groupId) throws GovRegistryException, TException { + for(int i=0; i < userIds.size(); i++){ + GroupMembershipEntityPK groupMembershipEntityPK = new GroupMembershipEntityPK(); + groupMembershipEntityPK.setParentId(groupId); + groupMembershipEntityPK.setChildId(userIds.get(i)); + groupMembershipRepository.delete(groupMembershipEntityPK); + } + return true; + } + + @Override + public Map<String, GroupChildType> getGroupMembers(String groupId, int offset, int limit) throws GovRegistryException, TException { + HashMap<String, GroupChildType> groupMembers = new HashMap<>(); + HashMap<String, String> filters = new HashMap<>(); + filters.put(DBConstants.GroupMembershipTable.PARENT_ID, groupId); + List<GroupMembership> groupMembershipList = groupMembershipRepository.select(filters, 0, -1); + groupMembershipList.stream().forEach(gm->{groupMembers.put(gm.getChildId(), gm.getChildType());}); + return groupMembers; + } + + @Override + public boolean addChildGroupToParentGroup(String childId, String groupId) throws GovRegistryException, TException { + //Todo check for cyclic dependencies + GroupMembership groupMembership = new GroupMembership(); + groupMembership.setParentId(groupId); + groupMembership.setChildId(childId); + groupMembership.setChildType(GroupChildType.GROUP); + groupMembership.setCreatedTime(System.currentTimeMillis()); + groupMembership.setUpdatedTime(System.currentTimeMillis()); + groupMembershipRepository.create(groupMembership); + return true; + } + + @Override + public boolean removeChildGroupFromParentGroup(String childId, String groupId) throws GovRegistryException, TException { + GroupMembershipEntityPK groupMembershipEntityPK = new GroupMembershipEntityPK(); + groupMembershipEntityPK.setParentId(groupId); + groupMembershipEntityPK.setChildId(childId); + groupMembershipRepository.delete(groupMembershipEntityPK); + return true; + } + + /** + * * EntityType Operations + * * + */ + @Override + public String createEntityType(EntityType entityType) throws GovRegistryException, TException { + if(entityTypeRepository.get(entityType.entityTypeId) != null) + throw new GovRegistryException("There exist EntityType with given EntityType id"); + + entityType.setCreatedTime(System.currentTimeMillis()); + entityType.setUpdatedTime(System.currentTimeMillis()); + entityTypeRepository.create(entityType); + return entityType.entityTypeId; + } + + @Override + public boolean updateEntityType(EntityType entityType) throws GovRegistryException, TException { + entityType.setUpdatedTime(System.currentTimeMillis()); + EntityType oldEntityType = entityTypeRepository.get(entityType.entityTypeId); + entityType.setCreatedTime(oldEntityType.createdTime); + entityType = getUpdatedObject(oldEntityType, entityType); + entityTypeRepository.update(entityType); + return true; + } + + @Override + public boolean deleteEntityType(String entityTypeId) throws GovRegistryException, TException { + entityTypeRepository.delete(entityTypeId); + return true; + } + + @Override + public EntityType getEntityType(String entityTypeId) throws GovRegistryException, TException { + return entityTypeRepository.get(entityTypeId); + } + + @Override + public List<EntityType> getEntityTypes(String domain, int offset, int limit) throws TException { + HashMap<String, String> filters = new HashMap<>(); + filters.put(DBConstants.EntityTypeTable.DOMAIN_ID, domain); + return entityTypeRepository.select(domain, offset, limit); + } + + /** + * * Permission Operations + * * + */ + @Override + public String createPermissionType(PermissionType permissionType) throws GovRegistryException, TException { + if(permissionTypeRepository.get(permissionType.permissionTypeId) != null) + throw new GovRegistryException("There exist PermissionType with given PermissionType id"); + permissionType.setCreatedTime(System.currentTimeMillis()); + permissionType.setUpdatedTime(System.currentTimeMillis()); + permissionTypeRepository.create(permissionType); + return permissionType.permissionTypeId; + } + + @Override + public boolean updatePermissionType(PermissionType permissionType) throws GovRegistryException, TException { + permissionType.setUpdatedTime(System.currentTimeMillis()); + PermissionType oldPermissionType = permissionTypeRepository.get(permissionType.permissionTypeId); + permissionType = getUpdatedObject(oldPermissionType, permissionType); + permissionTypeRepository.update(permissionType); + return true; + } + + @Override + public boolean deletePermissionType(String entityTypeId) throws GovRegistryException, TException { + permissionTypeRepository.delete(entityTypeId); + return true; + } + + @Override + public PermissionType getPermissionType(String permissionTypeId) throws GovRegistryException, TException { + return permissionTypeRepository.get(permissionTypeId); + } + + @Override + public List<PermissionType> getPermissionTypes(String domain, int offset, int limit) throws GovRegistryException, TException { + HashMap<String, String> filters = new HashMap<>(); + filters.put(DBConstants.PermissionTypeTable.DOMAIN_ID, domain); + return permissionTypeRepository.select(filters, offset, limit); + } + + /** + * * Entity Operations + * * + */ + @Override + public String createEntity(Entity entity) throws GovRegistryException, TException { + if(entityRepository.get(entity.entityId) != null) + throw new GovRegistryException("There exist Entity with given Entity id"); + + entity.setCreatedTime(System.currentTimeMillis()); + entity.setUpdatedTime(System.currentTimeMillis()); + entityRepository.create(entity); + + //Assigning global permission for the owner + Sharing newSharing = new Sharing(); + newSharing.setPermissionTypeId(permissionTypeRepository.getGlobalPermissionTypeIdForDomain(entity.domainId)); + newSharing.setEntityId(entity.entityId); + newSharing.setGroupId(entity.ownerId); + newSharing.setGroupType(GroupType.SINGLE_USER); + newSharing.setSharingType(SharingType.DIRECT); + newSharing.setCreatedTime(System.currentTimeMillis()); + newSharing.setUpdatedTime(System.currentTimeMillis()); + + sharingRepository.create(newSharing); + + //creating records for inherited permissions + if(entity.getParentEntityId() != null && entity.getParentEntityId() != ""){ + List<Sharing> sharings = sharingRepository.getPermissionsForEntity(entity.parentEntityId); + for(Sharing sharing : sharings){ + newSharing = new Sharing(); + newSharing.setPermissionTypeId(sharing.permissionTypeId); + newSharing.setEntityId(entity.entityId); + newSharing.setGroupId(sharing.groupId); + newSharing.setGroupType(sharing.groupType); + newSharing.setSharingType(SharingType.INHERITED); + newSharing.setCreatedTime(System.currentTimeMillis()); + newSharing.setUpdatedTime(System.currentTimeMillis()); + + sharingRepository.create(newSharing); + } + } + + return entity.entityId; + } + + @Override + public boolean updateEntity(Entity entity) throws GovRegistryException, TException { + //TODO Check for permission changes + entity.setUpdatedTime(System.currentTimeMillis()); + Entity oldEntity = entityRepository.get(entity.getEntityId()); + entity.setCreatedTime(oldEntity.createdTime); + entity = getUpdatedObject(oldEntity, entity); + entityRepository.update(entity); + return true; + } + + @Override + public boolean deleteEntity(String entityId) throws GovRegistryException, TException { + //TODO Check for permission changes + entityRepository.delete(entityId); + return true; + } + + @Override + public Entity getEntity(String entityId) throws GovRegistryException, TException { + return entityRepository.get(entityId); + } + + @Override + public List<Entity> searchEntities(String userId, String entityTypeId, Map<EntitySearchFields, String> filters, + int offset, int limit) throws GovRegistryException, TException { + List<String> groupIds = new ArrayList<>(); + groupIds.add(userId); + groupMembershipRepository.getAllParentMembershipsForChild(userId).stream().forEach(gm->groupIds.add(gm.parentId)); + return entityRepository.searchEntities(groupIds, entityTypeId, filters, offset, limit); + } + + /** + * * Sharing Entity with Users and Groups + * * + * + * @param entityId + * @param userList + * @param permissionType + */ + @Override + public boolean shareEntityWithUsers(String entityId, List<String> userList, String permissionTypeId) throws GovRegistryException, TException { + return shareEntity(entityId, userList, permissionTypeId, GroupType.SINGLE_USER); + } + + @Override + public boolean shareEntityWithGroups(String entityId, List<String> groupList, String permissionTypeId) throws GovRegistryException, TException { + return shareEntity(entityId, groupList, permissionTypeId, GroupType.MULTI_USER); + } + + private boolean shareEntity(String entityId, List<String> groupOrUserList, String permissionTypeId, GroupType groupType) throws GovRegistryException, TException { + //Adding permission for the specified users/groups for the specified entity + LinkedList<Entity> temp = new LinkedList<>(); + for(String userId : groupOrUserList){ + Sharing sharing = new Sharing(); + sharing.setPermissionTypeId(permissionTypeId); + sharing.setEntityId(entityId); + sharing.setGroupId(userId); + sharing.setGroupType(groupType); + sharing.setSharingType(SharingType.DIRECT); + sharing.setCreatedTime(System.currentTimeMillis()); + sharing.setUpdatedTime(System.currentTimeMillis()); + + sharingRepository.create(sharing); + } + + //Adding permission for the specified users/groups for all child entities + entityRepository.getChildEntities(entityId).stream().forEach(e-> temp.addLast(e)); + while(temp.size() > 0){ + Entity entity = temp.pop(); + String childEntityId = entity.entityId; + String parentEntityId = entity.parentEntityId; + for(String userId : groupOrUserList){ + Sharing sharing = new Sharing(); + sharing.setPermissionTypeId(permissionTypeId); + sharing.setEntityId(childEntityId); + sharing.setGroupId(userId); + sharing.setGroupType(groupType); + sharing.setSharingType(SharingType.INHERITED); + sharing.setInheritedParentId(parentEntityId); + sharing.setCreatedTime(System.currentTimeMillis()); + sharing.setUpdatedTime(System.currentTimeMillis()); + sharingRepository.create(sharing); + entityRepository.getChildEntities(childEntityId).stream().forEach(e-> temp.addLast(e)); + } + } + return true; + } + + @Override + public boolean revokeEntitySharingFromUsers(String entityId, List<String> userList, String permissionTypeId) throws GovRegistryException, TException { + return revokeEntitySharing(entityId, userList, permissionTypeId); + } + + + @Override + public boolean revokeEntitySharingFromGroups(String entityId, List<String> groupList, String permissionTypeId) throws GovRegistryException, TException { + return revokeEntitySharing(entityId, groupList, permissionTypeId); + } + + @Override + public boolean userHasAccess(String domainId, String userId, String entityId, String permissionTypeId) throws GovRegistryException, TException { + //check whether the user has permission directly or indirectly + List<GroupMembership> parentMemberships = groupMembershipRepository.getAllParentMembershipsForChild(userId); + List<String> groupIds = new ArrayList<>(); + parentMemberships.stream().forEach(pm->groupIds.add(pm.parentId)); + groupIds.add(userId); + return sharingRepository.hasAccess(entityId, groupIds, Arrays.asList(permissionTypeId, + permissionTypeRepository.getGlobalPermissionTypeIdForDomain(domainId))); + } + + public boolean revokeEntitySharing(String entityId, List<String> groupOrUserList, String permissionTypeId) throws GovRegistryException { + //revoking permission for the entity + LinkedList<Sharing> temp = new LinkedList<>(); + sharingRepository.getIndirectSharedChildren(entityId, permissionTypeId).stream().forEach(s->temp.addLast(s)); + for(String groupId : groupOrUserList){ + SharingEntityPK sharingEntityPK = new SharingEntityPK(); + sharingEntityPK.setEntityId(entityId); + sharingEntityPK.setGroupId(groupId); + sharingEntityPK.setPermissionTypeId(permissionTypeId); + + sharingRepository.delete(sharingEntityPK); + } + + //revoking permission from inheritance + while(temp.size() > 0){ + Sharing sharing = temp.pop(); + String childEntityId = sharing.entityId; + sharingRepository.getIndirectSharedChildren(sharing.entityId, permissionTypeId).stream().forEach(s->temp.addLast(s)); + for(String groupId : groupOrUserList){ + SharingEntityPK sharingEntityPK = new SharingEntityPK(); + sharingEntityPK.setEntityId(childEntityId); + sharingEntityPK.setGroupId(groupId); + sharingEntityPK.setPermissionTypeId(permissionTypeId); + + sharingRepository.delete(sharingEntityPK); + } + } + return true; + } + + + + private <T> T getUpdatedObject(T oldEntity, T newEntity) throws GovRegistryException { + Field[] newEntityFields = newEntity.getClass().getDeclaredFields(); + Hashtable newHT = fieldsToHT(newEntityFields, newEntity); + + Class oldEntityClass = oldEntity.getClass(); + Field[] oldEntityFields = oldEntityClass.getDeclaredFields(); + + for (Field field : oldEntityFields){ + field.setAccessible(true); + Object o = newHT.get(field.getName()); + if (o != null){ + Field f = null; + try { + f = oldEntityClass.getDeclaredField(field.getName()); + f.setAccessible(true); + logger.debug("setting " + f.getName()); + f.set(oldEntity, o); + } catch (Exception e) { + throw new GovRegistryException(e.getMessage()); + } + } + } + return oldEntity; + } + + private static Hashtable<String, Object> fieldsToHT(Field[] fields, Object obj){ + Hashtable<String,Object> hashtable = new Hashtable<>(); + for (Field field: fields){ + field.setAccessible(true); + try { + Object retrievedObject = field.get(obj); + if (retrievedObject != null){ + logger.debug("scanning " + field.getName()); + hashtable.put(field.getName(), field.get(obj)); + } + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + return hashtable; + } +} \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-core/src/main/resources/META-INF/persistence.xml ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/main/resources/META-INF/persistence.xml b/modules/sharing-registry/sharing-registry-core/src/main/resources/META-INF/persistence.xml new file mode 100644 index 0000000..a9f808c --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/main/resources/META-INF/persistence.xml @@ -0,0 +1,15 @@ +<?xml version="1.0" encoding="UTF-8"?> +<persistence xmlns="http://java.sun.com/xml/ns/persistence"; version="2.0"> + + <persistence-unit name="airavata-sharing-registry"> + <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider> + <class>org.apache.airavata.sharing.registry.db.entities.DomainEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.EntityEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.EntityTypeEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.GroupMembershipEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.PermissionTypeEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.SharingEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.UserEntity</class> + <class>org.apache.airavata.sharing.registry.db.entities.UserGroupEntity</class> + </persistence-unit> +</persistence> http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-derby.sql ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-derby.sql b/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-derby.sql new file mode 100644 index 0000000..4b046ce --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-derby.sql @@ -0,0 +1,139 @@ +/* + * + * 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. + * +*/ + +CREATE TABLE DOMAIN ( + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (DOMAIN_ID) +); + +CREATE TABLE USER ( + USER_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + USER_NAME VARCHAR(255) NOT NULL, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (USER_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE USER_GROUP ( + GROUP_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + OWNER_ID VARCHAR(255) NOT NULL, + GROUP_TYPE VARCHAR(255) NOT NULL, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (GROUP_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (OWNER_ID) REFERENCES USER(USER_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + + +CREATE TABLE GROUP_MEMBERSHIP ( + PARENT_ID VARCHAR(255) NOT NULL, + CHILD_ID VARCHAR(255) NOT NULL, + CHILD_TYPE VARCHAR(255) NOT NULL, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (PARENT_ID, CHILD_ID), + FOREIGN KEY (PARENT_ID) REFERENCES USER_GROUP(GROUP_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (CHILD_ID) REFERENCES USER_GROUP(GROUP_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE ENTITY_TYPE ( + ENTITY_TYPE_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (ENTITY_TYPE_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE PERMISSION_TYPE ( + PERMISSION_TYPE_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (PERMISSION_TYPE_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE ENTITY ( + ENTITY_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + ENTITY_TYPE_ID VARCHAR(255) NOT NULL, + OWNER_ID VARCHAR(255) NOT NULL, + PARENT_ENTITY_ID VARCHAR(255), + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + FULL_TEXT TEXT, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (ENTITY_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (ENTITY_TYPE_ID) REFERENCES ENTITY_TYPE(ENTITY_TYPE_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (OWNER_ID) REFERENCES USER(USER_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (PARENT_ENTITY_ID) REFERENCES ENTITY(ENTITY_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +ALTER TABLE ENTITY ADD FULLTEXT FULL_TEXT_INDEX(FULL_TEXT); + +CREATE TABLE ENTITY_METADATA ( + ENTITY_ID VARCHAR (255) NOT NULL, + META_KEY VARCHAR (255) NOT NULL, + META_VALUE VARCHAR (255) NOT NULL, + PRIMARY KEY (ENTITY_ID, META_KEY), + FOREIGN KEY (ENTITY_ID) REFERENCES ENTITY(ENTITY_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE SHARING ( + PERMISSION_TYPE_ID VARCHAR(255) NOT NULL, + ENTITY_ID VARCHAR(255) NOT NULL, + GROUP_ID VARCHAR(255) NOT NULL, + GROUP_TYPE VARCHAR(255) NOT NULL, + SHARING_TYPE VARCHAR(255) NOT NULL, + INHERITED_PARENT_ID VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (PERMISSION_TYPE_ID, ENTITY_ID, GROUP_ID), + FOREIGN KEY (PERMISSION_TYPE_ID) REFERENCES PERMISSION_TYPE(PERMISSION_TYPE_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (INHERITED_PARENT_ID) REFERENCES ENTITY(ENTITY_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (GROUP_ID) REFERENCES USER_GROUP(GROUP_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE CONFIGURATION +( + CONFIG_KEY VARCHAR(255) NOT NULL, + CONFIG_VALUE VARCHAR(255) NOT NULL, + PRIMARY KEY(CONFIG_KEY, CONFIG_VALUE) +); + +INSERT INTO CONFIGURATION (CONFIG_KEY, CONFIG_VALUE) VALUES('sharing_reg_version', '0.17'); \ No newline at end of file http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-mysql.sql ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-mysql.sql b/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-mysql.sql new file mode 100644 index 0000000..4b046ce --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/main/resources/sharing-registry-mysql.sql @@ -0,0 +1,139 @@ +/* + * + * 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. + * +*/ + +CREATE TABLE DOMAIN ( + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (DOMAIN_ID) +); + +CREATE TABLE USER ( + USER_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + USER_NAME VARCHAR(255) NOT NULL, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (USER_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE USER_GROUP ( + GROUP_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + OWNER_ID VARCHAR(255) NOT NULL, + GROUP_TYPE VARCHAR(255) NOT NULL, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (GROUP_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (OWNER_ID) REFERENCES USER(USER_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + + +CREATE TABLE GROUP_MEMBERSHIP ( + PARENT_ID VARCHAR(255) NOT NULL, + CHILD_ID VARCHAR(255) NOT NULL, + CHILD_TYPE VARCHAR(255) NOT NULL, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (PARENT_ID, CHILD_ID), + FOREIGN KEY (PARENT_ID) REFERENCES USER_GROUP(GROUP_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (CHILD_ID) REFERENCES USER_GROUP(GROUP_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE ENTITY_TYPE ( + ENTITY_TYPE_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (ENTITY_TYPE_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE PERMISSION_TYPE ( + PERMISSION_TYPE_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (PERMISSION_TYPE_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE ENTITY ( + ENTITY_ID VARCHAR(255) NOT NULL, + DOMAIN_ID VARCHAR(255) NOT NULL, + ENTITY_TYPE_ID VARCHAR(255) NOT NULL, + OWNER_ID VARCHAR(255) NOT NULL, + PARENT_ENTITY_ID VARCHAR(255), + NAME VARCHAR(255) NOT NULL, + DESCRIPTION VARCHAR(255), + FULL_TEXT TEXT, + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (ENTITY_ID), + FOREIGN KEY (DOMAIN_ID) REFERENCES DOMAIN(DOMAIN_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (ENTITY_TYPE_ID) REFERENCES ENTITY_TYPE(ENTITY_TYPE_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (OWNER_ID) REFERENCES USER(USER_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (PARENT_ENTITY_ID) REFERENCES ENTITY(ENTITY_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +ALTER TABLE ENTITY ADD FULLTEXT FULL_TEXT_INDEX(FULL_TEXT); + +CREATE TABLE ENTITY_METADATA ( + ENTITY_ID VARCHAR (255) NOT NULL, + META_KEY VARCHAR (255) NOT NULL, + META_VALUE VARCHAR (255) NOT NULL, + PRIMARY KEY (ENTITY_ID, META_KEY), + FOREIGN KEY (ENTITY_ID) REFERENCES ENTITY(ENTITY_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE SHARING ( + PERMISSION_TYPE_ID VARCHAR(255) NOT NULL, + ENTITY_ID VARCHAR(255) NOT NULL, + GROUP_ID VARCHAR(255) NOT NULL, + GROUP_TYPE VARCHAR(255) NOT NULL, + SHARING_TYPE VARCHAR(255) NOT NULL, + INHERITED_PARENT_ID VARCHAR(255), + CREATED_TIME BIGINT NOT NULL, + UPDATED_TIME BIGINT NOT NULL, + PRIMARY KEY (PERMISSION_TYPE_ID, ENTITY_ID, GROUP_ID), + FOREIGN KEY (PERMISSION_TYPE_ID) REFERENCES PERMISSION_TYPE(PERMISSION_TYPE_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (INHERITED_PARENT_ID) REFERENCES ENTITY(ENTITY_ID) ON DELETE CASCADE ON UPDATE CASCADE, + FOREIGN KEY (GROUP_ID) REFERENCES USER_GROUP(GROUP_ID) ON DELETE CASCADE ON UPDATE CASCADE +); + +CREATE TABLE CONFIGURATION +( + CONFIG_KEY VARCHAR(255) NOT NULL, + CONFIG_VALUE VARCHAR(255) NOT NULL, + PRIMARY KEY(CONFIG_KEY, CONFIG_VALUE) +); + +INSERT INTO CONFIGURATION (CONFIG_KEY, CONFIG_VALUE) VALUES('sharing_reg_version', '0.17'); \ No newline at end of file http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/GovRegistryServerHandlerTest.java ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/GovRegistryServerHandlerTest.java b/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/GovRegistryServerHandlerTest.java new file mode 100644 index 0000000..688117c --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/GovRegistryServerHandlerTest.java @@ -0,0 +1,272 @@ +/* + * + * 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.airavata.sharing.registry; + +import junit.framework.Assert; +import org.apache.airavata.sharing.registry.models.*; +import org.apache.airavata.sharing.registry.server.SharingRegistryServerHandler; +import org.apache.thrift.TException; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +public class GovRegistryServerHandlerTest { + private final static Logger logger = LoggerFactory.getLogger(GovRegistryServerHandlerTest.class); + + @Test + public void test() throws TException { + SharingRegistryServerHandler govRegistryServerHandler = new SharingRegistryServerHandler(); + + //Creating domain + Domain domain = new Domain(); + String domainId = "test-domain."+System.currentTimeMillis(); + domain.setDomainId(domainId); + domain.setName(domainId); + domain.setDescription("test domain description"); + domain.setCreatedTime(System.currentTimeMillis()); + domain.setUpdatedTime(System.currentTimeMillis()); + + Assert.assertNotNull(govRegistryServerHandler.createDomain(domain)); + Assert.assertTrue(govRegistryServerHandler.getDomains(0, 10).size() > 0); + + + //Creating users + User user1 = new User(); + String userName1 = "test-user-1." + System.currentTimeMillis(); + String userId1 = domainId + ":" + userName1; + user1.setUserId(userId1); + user1.setUserName(userName1); + user1.setDomainId(domainId); + user1.setCreatedTime(System.currentTimeMillis()); + user1.setUpdatedTime(System.currentTimeMillis()); + + Assert.assertNotNull(govRegistryServerHandler.createUser(user1)); + + User user2 = new User(); + String userName2 = "test-user-2." + System.currentTimeMillis(); + String userId2 = domainId + ":" + userName2; + user2.setUserId(userId2); + user2.setUserName(userName2); + user2.setDomainId(domainId); + user2.setCreatedTime(System.currentTimeMillis()); + user2.setUpdatedTime(System.currentTimeMillis()); + + Assert.assertNotNull(govRegistryServerHandler.createUser(user2)); + + User user3 = new User(); + String userName3 = "test-user-3." + System.currentTimeMillis(); + String userId3 = domainId + ":" + userName3; + user3.setUserId(userId3); + user3.setUserName(userName3); + user3.setDomainId(domainId); + user3.setCreatedTime(System.currentTimeMillis()); + user3.setUpdatedTime(System.currentTimeMillis()); + + Assert.assertNotNull(govRegistryServerHandler.createUser(user3)); + + Assert.assertTrue(govRegistryServerHandler.getUsers(domainId, 0, 10).size() > 0); + + // Creating user groups + UserGroup userGroup1 = new UserGroup(); + String groupName1 = "test-group-1." + System.currentTimeMillis(); + String groupId1 = domainId + ":" + groupName1; + userGroup1.setGroupId(groupId1); + userGroup1.setDomainId(domainId); + userGroup1.setName(groupName1); + userGroup1.setDescription("test group description"); + userGroup1.setOwnerId(userId1); + userGroup1.setGroupType(GroupType.MULTI_USER); + userGroup1.setCreatedTime(System.currentTimeMillis()); + userGroup1.setUpdatedTime(System.currentTimeMillis()); + + Assert.assertNotNull(govRegistryServerHandler.createGroup(userGroup1)); + + UserGroup userGroup2 = new UserGroup(); + String groupName2 = "test-group-2." + System.currentTimeMillis(); + String groupId2 = domainId + ":" + groupName2; + userGroup2.setGroupId(groupId2); + userGroup2.setDomainId(domainId); + userGroup2.setName(groupName2); + userGroup2.setDescription("test group description"); + userGroup2.setOwnerId(userId2); + userGroup2.setGroupType(GroupType.MULTI_USER); + userGroup2.setCreatedTime(System.currentTimeMillis()); + userGroup2.setUpdatedTime(System.currentTimeMillis()); + + Assert.assertNotNull(govRegistryServerHandler.createGroup(userGroup2)); + + govRegistryServerHandler.addUsersToGroup(Arrays.asList(userId1), groupId1); + govRegistryServerHandler.addUsersToGroup(Arrays.asList(userId2, userId3), groupId2); + govRegistryServerHandler.addChildGroupToParentGroup(groupId2, groupId1); + + Assert.assertTrue(govRegistryServerHandler.getGroupMembers(groupId1, 0, 10).size() == 2); + Assert.assertTrue(govRegistryServerHandler.getGroupMembers(groupId2, 0, 10).size() == 2); + + + //Creating permission types + PermissionType permissionType1 = new PermissionType(); + String permissionName1 = "READ"; + permissionType1.setPermissionTypeId(domainId+":"+permissionName1); + permissionType1.setDomainId(domainId); + permissionType1.setName(permissionName1); + permissionType1.setDescription("READ description"); + permissionType1.setCreatedTime(System.currentTimeMillis()); + permissionType1.setUpdatedTime(System.currentTimeMillis()); + String permissionTypeId1 = govRegistryServerHandler.createPermissionType(permissionType1); + Assert.assertNotNull(permissionTypeId1); + + PermissionType permissionType2 = new PermissionType(); + String permissionName2 = "WRITE"; + permissionType2.setPermissionTypeId(domainId+":"+permissionName2); + permissionType2.setDomainId(domainId); + permissionType2.setName(permissionName2); + permissionType2.setDescription("WRITE description"); + permissionType2.setCreatedTime(System.currentTimeMillis()); + permissionType2.setUpdatedTime(System.currentTimeMillis()); + String permissionTypeId2 = govRegistryServerHandler.createPermissionType(permissionType2); + Assert.assertNotNull(permissionTypeId2); + + //Creating entity types + EntityType entityType1 = new EntityType(); + String entityType1Name = "Project"; + entityType1.setEntityTypeId(domainId+":"+entityType1Name); + entityType1.setDomainId(domainId); + entityType1.setName(entityType1Name); + entityType1.setDescription("test entity type"); + entityType1.setCreatedTime(System.currentTimeMillis()); + entityType1.setUpdatedTime(System.currentTimeMillis()); + String entityTypeId1 = govRegistryServerHandler.createEntityType(entityType1); + Assert.assertNotNull(entityTypeId1); + + EntityType entityType2 = new EntityType(); + String entityType2Name = "Experiment"; + entityType2.setEntityTypeId(domainId+":"+entityType2Name); + entityType2.setDomainId(domainId); + entityType2.setName(entityType2Name); + entityType2.setDescription("test entity type"); + entityType2.setCreatedTime(System.currentTimeMillis()); + entityType2.setUpdatedTime(System.currentTimeMillis()); + String entityTypeId2 = govRegistryServerHandler.createEntityType(entityType2); + Assert.assertNotNull(entityTypeId2); + + EntityType entityType3 = new EntityType(); + String entityType3Name = "FileInput"; + entityType3.setEntityTypeId(domainId+":"+entityType3Name); + entityType3.setDomainId(domainId); + entityType3.setName(entityType3Name); + entityType3.setDescription("file input type"); + entityType3.setCreatedTime(System.currentTimeMillis()); + entityType3.setUpdatedTime(System.currentTimeMillis()); + String entityTypeId3 = govRegistryServerHandler.createEntityType(entityType3); + Assert.assertNotNull(entityTypeId3); + + //Creating Entities + Entity entity1 = new Entity(); + entity1.setEntityId(domainId+":Entity1"); + entity1.setDomainId(domainId); + entity1.setEntityTypeId(entityTypeId1); + entity1.setOwnerId(userId1); + entity1.setName("Project name 1"); + entity1.setDescription("Project description"); + Map<String, String> metadataMap = new HashMap<>(); + metadataMap.put("key", "val"); + entity1.setMetadata(metadataMap); + entity1.setFullText("Project name project description"); + entity1.setCreatedTime(System.currentTimeMillis()); + entity1.setUpdatedTime(System.currentTimeMillis()); + + String entityId1 = govRegistryServerHandler.createEntity(entity1); + Assert.assertNotNull(entityId1); + + Entity entity2 = new Entity(); + entity2.setEntityId(domainId+":Entity2"); + entity2.setDomainId(domainId); + entity2.setEntityTypeId(entityTypeId2); + entity2.setOwnerId(userId1); + entity2.setName("Experiment name"); + entity2.setDescription("Experiment description"); + entity2.setParentEntityId(entityId1); + metadataMap = new HashMap<>(); + metadataMap.put("key", "val"); + entity2.setMetadata(metadataMap); + entity2.setFullText("Project name project description"); + entity2.setCreatedTime(System.currentTimeMillis()); + entity2.setUpdatedTime(System.currentTimeMillis()); + + String entityId2 = govRegistryServerHandler.createEntity(entity2); + Assert.assertNotNull(entityId2); + + Entity entity3 = new Entity(); + entity3.setEntityId(domainId+":Entity3"); + entity3.setDomainId(domainId); + entity3.setEntityTypeId(entityTypeId2); + entity3.setOwnerId(userId1); + entity3.setName("Experiment name"); + entity3.setDescription("Experiment description"); + entity3.setParentEntityId(entityId1); + metadataMap = new HashMap<>(); + metadataMap.put("key", "val"); + entity3.setMetadata(metadataMap); + entity3.setFullText("Project name project description"); + entity3.setCreatedTime(System.currentTimeMillis()); + entity3.setUpdatedTime(System.currentTimeMillis()); + + String entityId3 = govRegistryServerHandler.createEntity(entity3); + Assert.assertNotNull(entityId3); + + govRegistryServerHandler.shareEntityWithUsers(entityId1, Arrays.asList(userId2), permissionTypeId1); + govRegistryServerHandler.shareEntityWithGroups(entityId3, Arrays.asList(groupId2), permissionTypeId1); + + Entity entity4 = new Entity(); + entity4.setEntityId(domainId+":Entity4"); + entity4.setDomainId(domainId); + entity4.setEntityTypeId(entityTypeId3); + entity4.setOwnerId(userId3); + entity4.setName("Input name"); + entity4.setDescription("Input file description"); + entity4.setParentEntityId(entityId3); + metadataMap = new HashMap<>(); + metadataMap.put("key", "val"); + entity4.setMetadata(metadataMap); + entity4.setFullText("Input File"); + entity4.setCreatedTime(System.currentTimeMillis()); + entity4.setUpdatedTime(System.currentTimeMillis()); + + String entityId4 = govRegistryServerHandler.createEntity(entity4); + Assert.assertNotNull(entityId4); + + Assert.assertTrue(govRegistryServerHandler.userHasAccess(domainId, userId3, entityId4, permissionTypeId1)); + Assert.assertTrue(govRegistryServerHandler.userHasAccess(domainId, userId2, entityId4, permissionTypeId1)); + Assert.assertTrue(govRegistryServerHandler.userHasAccess(domainId, userId1, entityId4, permissionTypeId1)); + Assert.assertFalse(govRegistryServerHandler.userHasAccess(domainId, userId3, entityId1, permissionTypeId1)); + + HashMap<EntitySearchFields, String> filters = new HashMap<>(); + filters.put(EntitySearchFields.NAME, "Input"); + Assert.assertTrue(govRegistryServerHandler.searchEntities(userId1, entityTypeId3, filters, 0, -1).size() > 0); + +// govRegistryServerHandler.revokeEntitySharingFromUsers(entityId1, Arrays.asList(userId2), permissionTypeId1); +// govRegistryServerHandler.revokeEntitySharingFromGroups(entityId3, Arrays.asList(groupId2), permissionTypeId1); + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-stubs/pom.xml ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-stubs/pom.xml b/modules/sharing-registry/sharing-registry-stubs/pom.xml new file mode 100644 index 0000000..ff0334c --- /dev/null +++ b/modules/sharing-registry/sharing-registry-stubs/pom.xml @@ -0,0 +1,23 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project xmlns="http://maven.apache.org/POM/4.0.0"; + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd";> + <parent> + <artifactId>airavata-sharing-registry</artifactId> + <groupId>org.apache.airavata</groupId> + <relativePath>../pom.xml</relativePath> + <version>${global.version}</version> + </parent> + <modelVersion>4.0.0</modelVersion> + + <artifactId>airavata-sharing-registry-stubs</artifactId> + <dependencies> + <dependency> + <groupId>org.apache.thrift</groupId> + <artifactId>libthrift</artifactId> + <version>0.9.3</version> + </dependency> + </dependencies> + + +</project> \ No newline at end of file http://git-wip-us.apache.org/repos/asf/airavata/blob/43f228fc/modules/sharing-registry/sharing-registry-stubs/src/main/java/org/apache/airavata/sharing/registry/models/Domain.java ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-stubs/src/main/java/org/apache/airavata/sharing/registry/models/Domain.java b/modules/sharing-registry/sharing-registry-stubs/src/main/java/org/apache/airavata/sharing/registry/models/Domain.java new file mode 100644 index 0000000..367e04f --- /dev/null +++ b/modules/sharing-registry/sharing-registry-stubs/src/main/java/org/apache/airavata/sharing/registry/models/Domain.java @@ -0,0 +1,817 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +package org.apache.airavata.sharing.registry.models; + +import org.apache.thrift.scheme.IScheme; +import org.apache.thrift.scheme.SchemeFactory; +import org.apache.thrift.scheme.StandardScheme; + +import org.apache.thrift.scheme.TupleScheme; +import org.apache.thrift.protocol.TTupleProtocol; +import org.apache.thrift.protocol.TProtocolException; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.server.AbstractNonblockingServer.*; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.EnumMap; +import java.util.Set; +import java.util.HashSet; +import java.util.EnumSet; +import java.util.Collections; +import java.util.BitSet; +import java.nio.ByteBuffer; +import java.util.Arrays; +import javax.annotation.Generated; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2016-10-05") +public class Domain implements org.apache.thrift.TBase<Domain, Domain._Fields>, java.io.Serializable, Cloneable, Comparable<Domain> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Domain"); + + private static final org.apache.thrift.protocol.TField DOMAIN_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("domainId", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short)3); + private static final org.apache.thrift.protocol.TField CREATED_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("createdTime", org.apache.thrift.protocol.TType.I64, (short)4); + private static final org.apache.thrift.protocol.TField UPDATED_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("updatedTime", org.apache.thrift.protocol.TType.I64, (short)5); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new DomainStandardSchemeFactory()); + schemes.put(TupleScheme.class, new DomainTupleSchemeFactory()); + } + + public String domainId; // optional + public String name; // optional + public String description; // optional + public long createdTime; // optional + public long updatedTime; // optional + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + DOMAIN_ID((short)1, "domainId"), + NAME((short)2, "name"), + DESCRIPTION((short)3, "description"), + CREATED_TIME((short)4, "createdTime"), + UPDATED_TIME((short)5, "updatedTime"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } + + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch(fieldId) { + case 1: // DOMAIN_ID + return DOMAIN_ID; + case 2: // NAME + return NAME; + case 3: // DESCRIPTION + return DESCRIPTION; + case 4: // CREATED_TIME + return CREATED_TIME; + case 5: // UPDATED_TIME + return UPDATED_TIME; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __CREATEDTIME_ISSET_ID = 0; + private static final int __UPDATEDTIME_ISSET_ID = 1; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.DOMAIN_ID,_Fields.NAME,_Fields.DESCRIPTION,_Fields.CREATED_TIME,_Fields.UPDATED_TIME}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.DOMAIN_ID, new org.apache.thrift.meta_data.FieldMetaData("domainId", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.CREATED_TIME, new org.apache.thrift.meta_data.FieldMetaData("createdTime", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.UPDATED_TIME, new org.apache.thrift.meta_data.FieldMetaData("updatedTime", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Domain.class, metaDataMap); + } + + public Domain() { + this.domainId = "DO_NOT_SET_AT_CLIENTS_ID"; + + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public Domain(Domain other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetDomainId()) { + this.domainId = other.domainId; + } + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetDescription()) { + this.description = other.description; + } + this.createdTime = other.createdTime; + this.updatedTime = other.updatedTime; + } + + public Domain deepCopy() { + return new Domain(this); + } + + @Override + public void clear() { + this.domainId = "DO_NOT_SET_AT_CLIENTS_ID"; + + this.name = null; + this.description = null; + setCreatedTimeIsSet(false); + this.createdTime = 0; + setUpdatedTimeIsSet(false); + this.updatedTime = 0; + } + + public String getDomainId() { + return this.domainId; + } + + public Domain setDomainId(String domainId) { + this.domainId = domainId; + return this; + } + + public void unsetDomainId() { + this.domainId = null; + } + + /** Returns true if field domainId is set (has been assigned a value) and false otherwise */ + public boolean isSetDomainId() { + return this.domainId != null; + } + + public void setDomainIdIsSet(boolean value) { + if (!value) { + this.domainId = null; + } + } + + public String getName() { + return this.name; + } + + public Domain setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getDescription() { + return this.description; + } + + public Domain setDescription(String description) { + this.description = description; + return this; + } + + public void unsetDescription() { + this.description = null; + } + + /** Returns true if field description is set (has been assigned a value) and false otherwise */ + public boolean isSetDescription() { + return this.description != null; + } + + public void setDescriptionIsSet(boolean value) { + if (!value) { + this.description = null; + } + } + + public long getCreatedTime() { + return this.createdTime; + } + + public Domain setCreatedTime(long createdTime) { + this.createdTime = createdTime; + setCreatedTimeIsSet(true); + return this; + } + + public void unsetCreatedTime() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CREATEDTIME_ISSET_ID); + } + + /** Returns true if field createdTime is set (has been assigned a value) and false otherwise */ + public boolean isSetCreatedTime() { + return EncodingUtils.testBit(__isset_bitfield, __CREATEDTIME_ISSET_ID); + } + + public void setCreatedTimeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CREATEDTIME_ISSET_ID, value); + } + + public long getUpdatedTime() { + return this.updatedTime; + } + + public Domain setUpdatedTime(long updatedTime) { + this.updatedTime = updatedTime; + setUpdatedTimeIsSet(true); + return this; + } + + public void unsetUpdatedTime() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __UPDATEDTIME_ISSET_ID); + } + + /** Returns true if field updatedTime is set (has been assigned a value) and false otherwise */ + public boolean isSetUpdatedTime() { + return EncodingUtils.testBit(__isset_bitfield, __UPDATEDTIME_ISSET_ID); + } + + public void setUpdatedTimeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __UPDATEDTIME_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DOMAIN_ID: + if (value == null) { + unsetDomainId(); + } else { + setDomainId((String)value); + } + break; + + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String)value); + } + break; + + case DESCRIPTION: + if (value == null) { + unsetDescription(); + } else { + setDescription((String)value); + } + break; + + case CREATED_TIME: + if (value == null) { + unsetCreatedTime(); + } else { + setCreatedTime((Long)value); + } + break; + + case UPDATED_TIME: + if (value == null) { + unsetUpdatedTime(); + } else { + setUpdatedTime((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DOMAIN_ID: + return getDomainId(); + + case NAME: + return getName(); + + case DESCRIPTION: + return getDescription(); + + case CREATED_TIME: + return getCreatedTime(); + + case UPDATED_TIME: + return getUpdatedTime(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case DOMAIN_ID: + return isSetDomainId(); + case NAME: + return isSetName(); + case DESCRIPTION: + return isSetDescription(); + case CREATED_TIME: + return isSetCreatedTime(); + case UPDATED_TIME: + return isSetUpdatedTime(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof Domain) + return this.equals((Domain)that); + return false; + } + + public boolean equals(Domain that) { + if (that == null) + return false; + + boolean this_present_domainId = true && this.isSetDomainId(); + boolean that_present_domainId = true && that.isSetDomainId(); + if (this_present_domainId || that_present_domainId) { + if (!(this_present_domainId && that_present_domainId)) + return false; + if (!this.domainId.equals(that.domainId)) + return false; + } + + boolean this_present_name = true && this.isSetName(); + boolean that_present_name = true && that.isSetName(); + if (this_present_name || that_present_name) { + if (!(this_present_name && that_present_name)) + return false; + if (!this.name.equals(that.name)) + return false; + } + + boolean this_present_description = true && this.isSetDescription(); + boolean that_present_description = true && that.isSetDescription(); + if (this_present_description || that_present_description) { + if (!(this_present_description && that_present_description)) + return false; + if (!this.description.equals(that.description)) + return false; + } + + boolean this_present_createdTime = true && this.isSetCreatedTime(); + boolean that_present_createdTime = true && that.isSetCreatedTime(); + if (this_present_createdTime || that_present_createdTime) { + if (!(this_present_createdTime && that_present_createdTime)) + return false; + if (this.createdTime != that.createdTime) + return false; + } + + boolean this_present_updatedTime = true && this.isSetUpdatedTime(); + boolean that_present_updatedTime = true && that.isSetUpdatedTime(); + if (this_present_updatedTime || that_present_updatedTime) { + if (!(this_present_updatedTime && that_present_updatedTime)) + return false; + if (this.updatedTime != that.updatedTime) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_domainId = true && (isSetDomainId()); + list.add(present_domainId); + if (present_domainId) + list.add(domainId); + + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); + + boolean present_description = true && (isSetDescription()); + list.add(present_description); + if (present_description) + list.add(description); + + boolean present_createdTime = true && (isSetCreatedTime()); + list.add(present_createdTime); + if (present_createdTime) + list.add(createdTime); + + boolean present_updatedTime = true && (isSetUpdatedTime()); + list.add(present_updatedTime); + if (present_updatedTime) + list.add(updatedTime); + + return list.hashCode(); + } + + @Override + public int compareTo(Domain other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetDomainId()).compareTo(other.isSetDomainId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDomainId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.domainId, other.domainId); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetName()).compareTo(other.isSetName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDescription()).compareTo(other.isSetDescription()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDescription()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetCreatedTime()).compareTo(other.isSetCreatedTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCreatedTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.createdTime, other.createdTime); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetUpdatedTime()).compareTo(other.isSetUpdatedTime()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUpdatedTime()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.updatedTime, other.updatedTime); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("Domain("); + boolean first = true; + + if (isSetDomainId()) { + sb.append("domainId:"); + if (this.domainId == null) { + sb.append("null"); + } else { + sb.append(this.domainId); + } + first = false; + } + if (isSetName()) { + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + } + if (isSetDescription()) { + if (!first) sb.append(", "); + sb.append("description:"); + if (this.description == null) { + sb.append("null"); + } else { + sb.append(this.description); + } + first = false; + } + if (isSetCreatedTime()) { + if (!first) sb.append(", "); + sb.append("createdTime:"); + sb.append(this.createdTime); + first = false; + } + if (isSetUpdatedTime()) { + if (!first) sb.append(", "); + sb.append("updatedTime:"); + sb.append(this.updatedTime); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_bitfield = 0; + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class DomainStandardSchemeFactory implements SchemeFactory { + public DomainStandardScheme getScheme() { + return new DomainStandardScheme(); + } + } + + private static class DomainStandardScheme extends StandardScheme<Domain> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, Domain struct) throws org.apache.thrift.TException { + org.apache.thrift.protocol.TField schemeField; + iprot.readStructBegin(); + while (true) + { + schemeField = iprot.readFieldBegin(); + if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { + break; + } + switch (schemeField.id) { + case 1: // DOMAIN_ID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.domainId = iprot.readString(); + struct.setDomainIdIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // DESCRIPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // CREATED_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.createdTime = iprot.readI64(); + struct.setCreatedTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // UPDATED_TIME + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.updatedTime = iprot.readI64(); + struct.setUpdatedTimeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); + + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } + + public void write(org.apache.thrift.protocol.TProtocol oprot, Domain struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.domainId != null) { + if (struct.isSetDomainId()) { + oprot.writeFieldBegin(DOMAIN_ID_FIELD_DESC); + oprot.writeString(struct.domainId); + oprot.writeFieldEnd(); + } + } + if (struct.name != null) { + if (struct.isSetName()) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + } + if (struct.description != null) { + if (struct.isSetDescription()) { + oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); + oprot.writeString(struct.description); + oprot.writeFieldEnd(); + } + } + if (struct.isSetCreatedTime()) { + oprot.writeFieldBegin(CREATED_TIME_FIELD_DESC); + oprot.writeI64(struct.createdTime); + oprot.writeFieldEnd(); + } + if (struct.isSetUpdatedTime()) { + oprot.writeFieldBegin(UPDATED_TIME_FIELD_DESC); + oprot.writeI64(struct.updatedTime); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class DomainTupleSchemeFactory implements SchemeFactory { + public DomainTupleScheme getScheme() { + return new DomainTupleScheme(); + } + } + + private static class DomainTupleScheme extends TupleScheme<Domain> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, Domain struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDomainId()) { + optionals.set(0); + } + if (struct.isSetName()) { + optionals.set(1); + } + if (struct.isSetDescription()) { + optionals.set(2); + } + if (struct.isSetCreatedTime()) { + optionals.set(3); + } + if (struct.isSetUpdatedTime()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetDomainId()) { + oprot.writeString(struct.domainId); + } + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetDescription()) { + oprot.writeString(struct.description); + } + if (struct.isSetCreatedTime()) { + oprot.writeI64(struct.createdTime); + } + if (struct.isSetUpdatedTime()) { + oprot.writeI64(struct.updatedTime); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, Domain struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.domainId = iprot.readString(); + struct.setDomainIdIsSet(true); + } + if (incoming.get(1)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(2)) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } + if (incoming.get(3)) { + struct.createdTime = iprot.readI64(); + struct.setCreatedTimeIsSet(true); + } + if (incoming.get(4)) { + struct.updatedTime = iprot.readI64(); + struct.setUpdatedTimeIsSet(true); + } + } + } + +} +
