http://git-wip-us.apache.org/repos/asf/airavata/blob/82e57526/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/SharingRegistryServerHandlerTest.java ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/SharingRegistryServerHandlerTest.java b/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/SharingRegistryServerHandlerTest.java new file mode 100644 index 0000000..b35bfef --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/SharingRegistryServerHandlerTest.java @@ -0,0 +1,282 @@ +/* + * + * 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.common.exception.ApplicationSettingsException; +import org.apache.airavata.sharing.registry.models.*; +import org.apache.airavata.sharing.registry.server.SharingRegistryServerHandler; +import org.apache.airavata.sharing.registry.util.Initialize; +import org.apache.thrift.TException; +import org.junit.BeforeClass; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.SQLException; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +public class SharingRegistryServerHandlerTest { + private final static Logger logger = LoggerFactory.getLogger(SharingRegistryServerHandlerTest.class); + + @BeforeClass + public static void setup() throws SharingRegistryException, SQLException { + Initialize initialize = new Initialize("sharing-registry-derby.sql"); + initialize.initializeDB(); + } + + @Test + public void test() throws TException, ApplicationSettingsException { + 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, true); + govRegistryServerHandler.shareEntityWithGroups(entityId3, Arrays.asList(groupId2), permissionTypeId1, true); + + 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/82e57526/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/util/Initialize.java ---------------------------------------------------------------------- diff --git a/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/util/Initialize.java b/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/util/Initialize.java new file mode 100644 index 0000000..4a89094 --- /dev/null +++ b/modules/sharing-registry/sharing-registry-core/src/test/java/org/apache/airavata/sharing/registry/util/Initialize.java @@ -0,0 +1,298 @@ +/* + * + * 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.util; + +import org.apache.airavata.common.exception.ApplicationSettingsException; +import org.apache.airavata.common.utils.ServerSettings; +import org.apache.airavata.sharing.registry.db.utils.JPAUtils; +import org.apache.derby.drda.NetworkServerControl; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.InetAddress; +import java.net.URI; +import java.sql.*; +import java.util.StringTokenizer; + +public class Initialize { + private static final Logger logger = LoggerFactory.getLogger(Initialize.class); + public static final String DERBY_SERVER_MODE_SYS_PROPERTY = "derby.drda.startNetworkServer"; + public String scriptName ; + private NetworkServerControl server; + private static final String delimiter = ";"; + public static final String PERSISTANT_DATA = "Configuration"; + + public Initialize(String scriptName) { + this.scriptName = scriptName; + } + + public static boolean checkStringBufferEndsWith(StringBuffer buffer, String suffix) { + if (suffix.length() > buffer.length()) { + return false; + } + // this loop is done on purpose to avoid memory allocation performance + // problems on various JDKs + // StringBuffer.lastIndexOf() was introduced in jdk 1.4 and + // implementation is ok though does allocation/copying + // StringBuffer.toString().endsWith() does massive memory + // allocation/copying on JDK 1.5 + // See http://issues.apache.org/bugzilla/show_bug.cgi?id=37169 + int endIndex = suffix.length() - 1; + int bufferIndex = buffer.length() - 1; + while (endIndex >= 0) { + if (buffer.charAt(bufferIndex) != suffix.charAt(endIndex)) { + return false; + } + bufferIndex--; + endIndex--; + } + return true; + } + + private static boolean isServerStarted(NetworkServerControl server, int ntries) + { + for (int i = 1; i <= ntries; i ++) + { + try { + Thread.sleep(500); + server.ping(); + return true; + } + catch (Exception e) { + if (i == ntries) + return false; + } + } + return false; + } + + public void initializeDB() throws SQLException{ + String jdbcUrl = null; + String jdbcUser = null; + String jdbcPassword = null; + try{ + jdbcUrl = ServerSettings.getSetting("sharingcatalog.jdbc.url"); + jdbcUser = ServerSettings.getSetting("sharingcatalog.jdbc.user"); + jdbcPassword = ServerSettings.getSetting("sharingcatalog.jdbc.password"); + jdbcUrl = jdbcUrl + "?" + "user=" + jdbcUser + "&" + "password=" + jdbcPassword; + } catch (ApplicationSettingsException e) { + logger.error("Unable to read properties", e); + } + startDerbyInServerMode(); + if(!isServerStarted(server, 20)){ + throw new RuntimeException("Derby server cound not started within five seconds..."); + } + + Connection conn = null; + try { + Class.forName(JPAUtils.readServerProperties(JPAUtils.SHARING_REG_JDBC_DRIVER)).newInstance(); + conn = DriverManager.getConnection(jdbcUrl, jdbcUser, jdbcPassword); + if (!isDatabaseStructureCreated(PERSISTANT_DATA, conn)) { + executeSQLScript(conn); + logger.info("New Database created for Registry"); + } else { + logger.debug("Database already created for Registry!"); + } + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new RuntimeException("Database failure", e); + } finally { + try { + if (conn != null){ + if (!conn.getAutoCommit()) { + conn.commit(); + } + conn.close(); + } + } catch (SQLException e) { + logger.error(e.getMessage(), e); + } + } + } + + public static boolean isDatabaseStructureCreated(String tableName, Connection conn) { + try { + System.out.println("Running a query to test the database tables existence."); + // check whether the tables are already created with a query + Statement statement = null; + try { + statement = conn.createStatement(); + ResultSet rs = statement.executeQuery("select * from " + tableName); + if (rs != null) { + rs.close(); + } + } finally { + try { + if (statement != null) { + statement.close(); + } + } catch (SQLException e) { + return false; + } + } + } catch (SQLException e) { + return false; + } + + return true; + } + + private void executeSQLScript(Connection conn) throws Exception { + StringBuffer sql = new StringBuffer(); + BufferedReader reader = null; + try{ + + InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(scriptName); + reader = new BufferedReader(new InputStreamReader(inputStream)); + String line; + while ((line = reader.readLine()) != null) { + line = line.trim(); + if (line.startsWith("//")) { + continue; + } + if (line.startsWith("--")) { + continue; + } + StringTokenizer st = new StringTokenizer(line); + if (st.hasMoreTokens()) { + String token = st.nextToken(); + if ("REM".equalsIgnoreCase(token)) { + continue; + } + } + sql.append(" ").append(line); + + // SQL defines "--" as a comment to EOL + // and in Oracle it may contain a hint + // so we cannot just remove it, instead we must end it + if (line.indexOf("--") >= 0) { + sql.append("\n"); + } + if ((checkStringBufferEndsWith(sql, delimiter))) { + executeSQL(sql.substring(0, sql.length() - delimiter.length()), conn); + sql.replace(0, sql.length(), ""); + } + } + // Catch any statements not followed by ; + if (sql.length() > 0) { + executeSQL(sql.toString(), conn); + } + }catch (IOException e){ + logger.error("Error occurred while executing SQL script for creating Airavata database", e); + throw new Exception("Error occurred while executing SQL script for creating Airavata database", e); + }finally { + if (reader != null) { + reader.close(); + } + + } + + } + + private static void executeSQL(String sql, Connection conn) throws Exception { + // Check and ignore empty statements + if ("".equals(sql.trim())) { + return; + } + + Statement statement = null; + try { + logger.debug("SQL : " + sql); + + boolean ret; + int updateCount = 0, updateCountTotal = 0; + statement = conn.createStatement(); + ret = statement.execute(sql); + updateCount = statement.getUpdateCount(); + do { + if (!ret) { + if (updateCount != -1) { + updateCountTotal += updateCount; + } + } + ret = statement.getMoreResults(); + if (ret) { + updateCount = statement.getUpdateCount(); + } + } while (ret); + + logger.debug(sql + " : " + updateCountTotal + " rows affected"); + + SQLWarning warning = conn.getWarnings(); + while (warning != null) { + logger.warn(warning + " sql warning"); + warning = warning.getNextWarning(); + } + conn.clearWarnings(); + } catch (SQLException e) { + if (e.getSQLState().equals("X0Y32")) { + // eliminating the table already exception for the derby + // database + logger.info("Table Already Exists", e); + } else { + throw new Exception("Error occurred while executing : " + sql, e); + } + } finally { + if (statement != null) { + try { + statement.close(); + } catch (SQLException e) { + logger.error("Error occurred while closing result set.", e); + } + } + } + } + + private void startDerbyInServerMode() { + try { + System.setProperty(DERBY_SERVER_MODE_SYS_PROPERTY, "true"); + String jdbcURL = JPAUtils.readServerProperties(JPAUtils.SHARING_REG_JDBC_URL); + String cleanURI = jdbcURL.substring(5); + URI uri = URI.create(cleanURI); + server = new NetworkServerControl(InetAddress.getByName(uri.getHost()), + 20000, + JPAUtils.readServerProperties(JPAUtils.SHARING_REG_JDBC_USER), JPAUtils.readServerProperties(JPAUtils.SHARING_REG_JDBC_USER)); + java.io.PrintWriter consoleWriter = new java.io.PrintWriter(System.out, true); + server.start(consoleWriter); + } catch (IOException e) { + logger.error("Unable to start Apache derby in the server mode! Check whether " + + "specified port is available"); + } catch (Exception e) { + logger.error("Unable to start Apache derby in the server mode! Check whether " + + "specified port is available"); + } + + } + + public void stopDerbyServer() throws SQLException{ + try { + server.shutdown(); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw new SQLException("Error while stopping derby server", e); + } + } +} http://git-wip-us.apache.org/repos/asf/airavata/blob/82e57526/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/82e57526/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..eb30e38 --- /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-06") +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); + } + } + } + +} +
