Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "static", "<", "T", ">", "Observable", "<", "T", ">", "toObservable", "(", "final", "FutureProvider", "<", "T", ">", "provider", ")", "{", "return", "Observable", ".", "create", "(", "new", "FutureProviderToStreamHandler", "<>", "(", "provider", ")", ")", ";", "}" ]

[ "creates", "new", "observable", "given", "future", "provider", "translating", "the", "future", "results", "into", "stream", ".", "the", "sequence", "will", "be", "evaluated", "on", "subscribe", "." ]

[ "public", "static", "AuthenticationCookie", "fromDelimitedString", "(", "final", "String", "delimitedString", ")", "{", "Preconditions", ".", "checkArgument", "(", "delimitedString", "!=", "null", "&&", "delimitedString", ".", "length", "(", ")", ">", "0", ",", "\"delimitedString cannot be empty\"", ")", ";", "final", "String", "[", "]", "cookieElements", "=", "delimitedString", ".", "split", "(", "DELIMITER", ")", ";", "Preconditions", ".", "checkArgument", "(", "cookieElements", ".", "length", "==", "4", ",", "\"delimitedString should contain exactly 4 elements\"", ")", ";", "return", "new", "AuthenticationCookie", "(", "cookieElements", "[", "0", "]", ",", "DateTime", ".", "parse", "(", "cookieElements", "[", "1", "]", ",", "DATE_TIME_FORMATTER", ")", ",", "cookieElements", "[", "2", "]", ",", "cookieElements", "[", "3", "]", ")", ";", "}" ]

[ "Converted", "the", "given", "delimited", "string", "into", "an", "Authentication", "cookie", ".", "Expected", "a", "string", "in", "the", "format", "username", ";", "creationTime", ";", "appId", ";", "authenticatorId" ]

[ "public", "RequestBuilder", "get", "(", "final", "String", "url", ")", "{", "checkNotNull", "(", "url", ",", "\"url may not be null\"", ")", ";", "final", "AsyncHttpClient", ".", "BoundRequestBuilder", "ningRequestBuilder", "=", "asyncHttpClient", ".", "prepareGet", "(", "url", ")", ";", "return", "createNewRequestBuilder", "(", "url", ",", "ningRequestBuilder", ")", ";", "}" ]

[ "Http", "get", "request" ]

[ "public", "RequestBuilder", "post", "(", "final", "String", "url", ")", "{", "checkNotNull", "(", "url", ",", "\"url may not be null\"", ")", ";", "final", "AsyncHttpClient", ".", "BoundRequestBuilder", "ningRequestBuilder", "=", "asyncHttpClient", ".", "preparePost", "(", "url", ")", ";", "return", "createNewRequestBuilder", "(", "url", ",", "ningRequestBuilder", ")", ";", "}" ]

[ "Http", "post", "request" ]

[ "public", "RequestBuilder", "put", "(", "final", "String", "url", ")", "{", "checkNotNull", "(", "url", ",", "\"url may not be null\"", ")", ";", "final", "AsyncHttpClient", ".", "BoundRequestBuilder", "ningRequestBuilder", "=", "asyncHttpClient", ".", "preparePut", "(", "url", ")", ";", "return", "createNewRequestBuilder", "(", "url", ",", "ningRequestBuilder", ")", ";", "}" ]

[ "Http", "put", "request" ]

[ "public", "RequestBuilder", "delete", "(", "final", "String", "url", ")", "{", "checkNotNull", "(", "url", ",", "\"url may not be null\"", ")", ";", "final", "AsyncHttpClient", ".", "BoundRequestBuilder", "ningRequestBuilder", "=", "asyncHttpClient", ".", "prepareDelete", "(", "url", ")", ";", "return", "createNewRequestBuilder", "(", "url", ",", "ningRequestBuilder", ")", ";", "}" ]

[ "Http", "delete", "request" ]

[ "public", "RequestBuilder", "head", "(", "final", "String", "url", ")", "{", "checkNotNull", "(", "url", ",", "\"url may not be null\"", ")", ";", "final", "AsyncHttpClient", ".", "BoundRequestBuilder", "ningRequestBuilder", "=", "asyncHttpClient", ".", "prepareHead", "(", "url", ")", ";", "return", "createNewRequestBuilder", "(", "url", ",", "ningRequestBuilder", ")", ";", "}" ]

[ "Http", "head", "request" ]

[ "@", "Override", "public", "boolean", "acceptInboundMessage", "(", "final", "Object", "msg", ")", "throws", "Exception", "{", "if", "(", "!", "(", "msg", "instanceof", "FullHttpRequest", ")", ")", "return", "false", ";", "final", "FullHttpRequest", "request", "=", "(", "FullHttpRequest", ")", "msg", ";", "final", "String", "uri", "=", "request", ".", "getUri", "(", ")", ";", "return", "pathResolver", ".", "isStaticPath", "(", "uri", ")", ";", "}" ]

[ "here", "to", "make", "sure", "that", "the", "message", "is", "not", "released", "twice", "by", "the", "dispatcherHandler", "and", "by", "this", "handler" ]

[ "private", "static", "void", "setDateHeader", "(", "final", "FullHttpResponse", "response", ")", "{", "final", "SimpleDateFormat", "dateFormatter", "=", "new", "SimpleDateFormat", "(", "HTTP_DATE_FORMAT", ",", "Locale", ".", "US", ")", ";", "dateFormatter", ".", "setTimeZone", "(", "TimeZone", ".", "getTimeZone", "(", "HTTP_DATE_GMT_TIMEZONE", ")", ")", ";", "final", "Calendar", "time", "=", "new", "GregorianCalendar", "(", ")", ";", "response", ".", "headers", "(", ")", ".", "set", "(", "DATE", ",", "dateFormatter", ".", "format", "(", "time", ".", "getTime", "(", ")", ")", ")", ";", "}" ]

[ "Sets", "the", "Date", "header", "for", "the", "HTTP", "response" ]

[ "public", "static", "boolean", "isResolved", "(", "Type", "type", ")", "{", "if", "(", "type", "instanceof", "GenericArrayType", ")", "{", "return", "isResolved", "(", "(", "(", "GenericArrayType", ")", "type", ")", ".", "getGenericComponentType", "(", ")", ")", ";", "}", "if", "(", "type", "instanceof", "ParameterizedType", ")", "{", "for", "(", "Type", "t", ":", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", ")", "{", "if", "(", "!", "isResolved", "(", "t", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "return", "type", "instanceof", "Class", ";", "}" ]

[ "Checks", "if", "the", "given", "type", "is", "fully", "resolved", "." ]

[ "public", "static", "void", "visit", "(", "Object", "instance", ",", "TypeToken", "<", "?", ">", "inspectType", ",", "Visitor", "firstVisitor", ",", "Visitor", "...", "moreVisitors", ")", "{", "try", "{", "List", "<", "Visitor", ">", "visitors", "=", "ImmutableList", ".", "<", "Visitor", ">", "builder", "(", ")", ".", "add", "(", "firstVisitor", ")", ".", "add", "(", "moreVisitors", ")", ".", "build", "(", ")", ";", "for", "(", "TypeToken", "<", "?", ">", "type", ":", "inspectType", ".", "getTypes", "(", ")", ".", "classes", "(", ")", ")", "{", "if", "(", "Object", ".", "class", ".", "equals", "(", "type", ".", "getRawType", "(", ")", ")", ")", "{", "break", ";", "}", "for", "(", "Field", "field", ":", "type", ".", "getRawType", "(", ")", ".", "getDeclaredFields", "(", ")", ")", "{", "if", "(", "!", "field", ".", "isAccessible", "(", ")", ")", "{", "field", ".", "setAccessible", "(", "true", ")", ";", "}", "for", "(", "Visitor", "visitor", ":", "visitors", ")", "{", "visitor", ".", "visit", "(", "instance", ",", "inspectType", ",", "type", ",", "field", ")", ";", "}", "}", "for", "(", "Method", "method", ":", "type", ".", "getRawType", "(", ")", ".", "getDeclaredMethods", "(", ")", ")", "{", "if", "(", "!", "method", ".", "isAccessible", "(", ")", ")", "{", "method", ".", "setAccessible", "(", "true", ")", ";", "}", "for", "(", "Visitor", "visitor", ":", "visitors", ")", "{", "visitor", ".", "visit", "(", "instance", ",", "inspectType", ",", "type", ",", "method", ")", ";", "}", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Inspect", "all", "members", "in", "the", "given", "type", ".", "Fields", "and", "Methods", "that", "are", "given", "to", "Visitor", "are", "always", "having", "accessible", "flag", "being", "set", "." ]

[ "public", "static", "byte", "[", "]", "getQueueRowPrefix", "(", "QueueName", "queueName", ")", "{", "if", "(", "queueName", ".", "isStream", "(", ")", ")", "{", "// NOTE: stream is uniquely identified by table name", "return", "Bytes", ".", "EMPTY_BYTE_ARRAY", ";", "}", "String", "flowlet", "=", "queueName", ".", "getThirdComponent", "(", ")", ";", "String", "output", "=", "queueName", ".", "getSimpleName", "(", ")", ";", "byte", "[", "]", "idWithinFlow", "=", "(", "flowlet", "+", "\"/\"", "+", "output", ")", ".", "getBytes", "(", "Charsets", ".", "US_ASCII", ")", ";", "return", "getQueueRowPrefix", "(", "idWithinFlow", ")", ";", "}" ]

[ "Returns", "a", "byte", "array", "representing", "prefix", "of", "a", "queue", ".", "The", "prefix", "is", "formed", "by", "first", "two", "bytes", "of", "MD5", "of", "the", "queue", "name", "followed", "by", "the", "queue", "name", "." ]

[ "private", "static", "byte", "[", "]", "getQueueRowPrefix", "(", "byte", "[", "]", "queueIdWithinFlow", ")", "{", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "queueIdWithinFlow", ".", "length", "+", "1", "]", ";", "Hashing", ".", "md5", "(", ")", ".", "hashBytes", "(", "queueIdWithinFlow", ")", ".", "writeBytesTo", "(", "bytes", ",", "0", ",", "1", ")", ";", "System", ".", "arraycopy", "(", "queueIdWithinFlow", ",", "0", ",", "bytes", ",", "1", ",", "queueIdWithinFlow", ".", "length", ")", ";", "return", "bytes", ";", "}" ]

[ "Returns", "a", "byte", "array", "representing", "prefix", "of", "a", "queue", ".", "The", "prefix", "is", "formed", "by", "first", "byte", "of", "MD5", "of", "the", "queue", "name", "followed", "by", "the", "queue", "name", "." ]

[ "public", "static", "boolean", "isCommittedProcessed", "(", "byte", "[", "]", "stateBytes", ",", "Transaction", "tx", ")", "{", "long", "writePointer", "=", "Bytes", ".", "toLong", "(", "stateBytes", ",", "0", ",", "Longs", ".", "BYTES", ")", ";", "if", "(", "!", "tx", ".", "isVisible", "(", "writePointer", ")", ")", "{", "return", "false", ";", "}", "byte", "state", "=", "stateBytes", "[", "Longs", ".", "BYTES", "+", "Ints", ".", "BYTES", "]", ";", "return", "state", "==", "ConsumerEntryState", ".", "PROCESSED", ".", "getState", "(", ")", ";", "}" ]

[ "For", "a", "queue", "entry", "consumer", "state", "serialized", "to", "byte", "array", "return", "whether", "it", "is", "processed", "and", "committed", "." ]

[ "private", "String", "[", "]", "getAlternateNames", "(", "String", "name", ")", "{", "String", "oldName", ",", "altNames", "[", "]", "=", "null", ";", "DeprecatedKeyInfo", "keyInfo", "=", "deprecatedKeyMap", ".", "get", "(", "name", ")", ";", "if", "(", "keyInfo", "==", "null", ")", "{", "altNames", "=", "(", "reverseDeprecatedKeyMap", ".", "get", "(", "name", ")", "!=", "null", ")", "?", "new", "String", "[", "]", "{", "reverseDeprecatedKeyMap", ".", "get", "(", "name", ")", "}", ":", "null", ";", "if", "(", "altNames", "!=", "null", "&&", "altNames", ".", "length", ">", "0", ")", "{", "//To help look for other new configs for this deprecated config", "keyInfo", "=", "deprecatedKeyMap", ".", "get", "(", "altNames", "[", "0", "]", ")", ";", "}", "}", "if", "(", "keyInfo", "!=", "null", "&&", "keyInfo", ".", "newKeys", ".", "length", ">", "0", ")", "{", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "if", "(", "altNames", "!=", "null", ")", "{", "list", ".", "addAll", "(", "Arrays", ".", "asList", "(", "altNames", ")", ")", ";", "}", "list", ".", "addAll", "(", "Arrays", ".", "asList", "(", "keyInfo", ".", "newKeys", ")", ")", ";", "altNames", "=", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}", "return", "altNames", ";", "}" ]

[ "Returns", "the", "alternate", "name", "for", "a", "key", "if", "the", "property", "name", "is", "deprecated", "or", "if", "deprecates", "a", "property", "name", "." ]

[ "public", "IntegerRanges", "getRange", "(", "String", "name", ")", "{", "String", "valueString", "=", "get", "(", "name", ")", ";", "Preconditions", ".", "checkNotNull", "(", "valueString", ")", ";", "return", "new", "IntegerRanges", "(", "valueString", ")", ";", "}" ]

[ "Parse", "the", "given", "attribute", "as", "a", "set", "of", "integer", "ranges", "." ]

[ "public", "Map", "<", "String", ",", "String", ">", "getValByRegex", "(", "String", "regex", ")", "{", "Pattern", "p", "=", "Pattern", ".", "compile", "(", "regex", ")", ";", "Map", "<", "String", ",", "String", ">", "result", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "Matcher", "m", ";", "for", "(", "Map", ".", "Entry", "<", "Object", ",", "Object", ">", "item", ":", "getProps", "(", ")", ".", "entrySet", "(", ")", ")", "{", "if", "(", "item", ".", "getKey", "(", ")", "instanceof", "String", "&&", "item", ".", "getValue", "(", ")", "instanceof", "String", ")", "{", "m", "=", "p", ".", "matcher", "(", "(", "String", ")", "item", ".", "getKey", "(", ")", ")", ";", "if", "(", "m", ".", "find", "(", ")", ")", "{", "// match", "result", ".", "put", "(", "(", "String", ")", "item", ".", "getKey", "(", ")", ",", "(", "String", ")", "item", ".", "getValue", "(", ")", ")", ";", "}", "}", "}", "return", "result", ";", "}" ]

[ "get", "keys", "matching", "the", "the", "regex", "." ]

[ "protected", "final", "<", "V", ">", "void", "error", "(", "Throwable", "t", ",", "SettableFuture", "<", "V", ">", "future", ")", "{", "state", ".", "set", "(", "State", ".", "ERROR", ")", ";", "if", "(", "future", "!=", "null", ")", "{", "future", ".", "setException", "(", "t", ")", ";", "}", "caller", ".", "error", "(", "t", ")", ";", "}" ]

[ "Force", "this", "controller", "into", "error", "state", "." ]

[ "protected", "final", "void", "started", "(", ")", "{", "if", "(", "!", "state", ".", "compareAndSet", "(", "State", ".", "STARTING", ",", "State", ".", "ALIVE", ")", ")", "{", "LOG", ".", "info", "(", "\"Program already started {} {}\"", ",", "programName", ",", "runId", ")", ";", "return", ";", "}", "LOG", ".", "info", "(", "\"Program started: {} {}\"", ",", "programName", ",", "runId", ")", ";", "executor", "(", "State", ".", "ALIVE", ")", ".", "execute", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "state", ".", "set", "(", "State", ".", "ALIVE", ")", ";", "caller", ".", "alive", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Children", "call", "this", "method", "to", "signal", "the", "program", "is", "started", "." ]

[ "private", "Arguments", "createProgramArguments", "(", "TwillContext", "context", ",", "Map", "<", "String", ",", "String", ">", "configs", ")", "{", "Map", "<", "String", ",", "String", ">", "args", "=", "ImmutableMap", ".", "<", "String", ",", "String", ">", "builder", "(", ")", ".", "put", "(", "ProgramOptionConstants", ".", "INSTANCE_ID", ",", "Integer", ".", "toString", "(", "context", ".", "getInstanceId", "(", ")", ")", ")", ".", "put", "(", "ProgramOptionConstants", ".", "INSTANCES", ",", "Integer", ".", "toString", "(", "context", ".", "getInstanceCount", "(", ")", ")", ")", ".", "put", "(", "ProgramOptionConstants", ".", "RUN_ID", ",", "context", ".", "getApplicationRunId", "(", ")", ".", "getId", "(", ")", ")", ".", "putAll", "(", "Maps", ".", "filterKeys", "(", "configs", ",", "Predicates", ".", "not", "(", "Predicates", ".", "in", "(", "ImmutableSet", ".", "of", "(", "\"hConf\"", ",", "\"cConf\"", ")", ")", ")", ")", ")", ".", "build", "(", ")", ";", "return", "new", "BasicArguments", "(", "args", ")", ";", "}" ]

[ "Creates", "program", "arguments", ".", "It", "includes", "all", "configurations", "from", "the", "specification", "excluding", "hConf", "and", "cConf", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "protected", "final", "Schema", "doGenerate", "(", "TypeToken", "<", "?", ">", "typeToken", ",", "Set", "<", "String", ">", "knownRecords", ",", "boolean", "acceptRecursion", ")", "throws", "UnsupportedTypeException", "{", "Type", "type", "=", "typeToken", ".", "getType", "(", ")", ";", "Class", "<", "?", ">", "rawType", "=", "typeToken", ".", "getRawType", "(", ")", ";", "if", "(", "SIMPLE_SCHEMAS", ".", "containsKey", "(", "rawType", ")", ")", "{", "return", "SIMPLE_SCHEMAS", ".", "get", "(", "rawType", ")", ";", "}", "// Enum type, simply use all the enum constants for ENUM schema.", "if", "(", "rawType", ".", "isEnum", "(", ")", ")", "{", "return", "Schema", ".", "enumWith", "(", "(", "Class", "<", "Enum", "<", "?", ">", ">", ")", "rawType", ")", ";", "}", "// Java array, use ARRAY schema.", "if", "(", "rawType", ".", "isArray", "(", ")", ")", "{", "Schema", "componentSchema", "=", "doGenerate", "(", "TypeToken", ".", "of", "(", "rawType", ".", "getComponentType", "(", ")", ")", ",", "knownRecords", ",", "acceptRecursion", ")", ";", "if", "(", "rawType", ".", "getComponentType", "(", ")", ".", "isPrimitive", "(", ")", ")", "{", "return", "Schema", ".", "arrayOf", "(", "componentSchema", ")", ";", "}", "return", "Schema", ".", "arrayOf", "(", "Schema", ".", "unionOf", "(", "componentSchema", ",", "Schema", ".", "of", "(", "Schema", ".", "Type", ".", "NULL", ")", ")", ")", ";", "}", "if", "(", "!", "(", "type", "instanceof", "Class", "||", "type", "instanceof", "ParameterizedType", ")", ")", "{", "throw", "new", "UnsupportedTypeException", "(", "\"Type \"", "+", "type", "+", "\" is not supported. \"", "+", "\"Only Class or ParameterizedType are supported.\"", ")", ";", "}", "// Any parameterized Collection class would be represented by ARRAY schema.", "if", "(", "Collection", ".", "class", ".", "isAssignableFrom", "(", "rawType", ")", ")", "{", "if", "(", "!", "(", "type", "instanceof", "ParameterizedType", ")", ")", "{", "throw", "new", "UnsupportedTypeException", "(", "\"Only supports parameterized Collection type.\"", ")", ";", "}", "TypeToken", "<", "?", ">", "componentType", "=", "typeToken", ".", "resolveType", "(", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", "[", "0", "]", ")", ";", "Schema", "componentSchema", "=", "doGenerate", "(", "componentType", ",", "knownRecords", ",", "acceptRecursion", ")", ";", "return", "Schema", ".", "arrayOf", "(", "Schema", ".", "unionOf", "(", "componentSchema", ",", "Schema", ".", "of", "(", "Schema", ".", "Type", ".", "NULL", ")", ")", ")", ";", "}", "// Java Map, use MAP schema.", "if", "(", "Map", ".", "class", ".", "isAssignableFrom", "(", "rawType", ")", ")", "{", "if", "(", "!", "(", "type", "instanceof", "ParameterizedType", ")", ")", "{", "throw", "new", "UnsupportedTypeException", "(", "\"Only supports parameterized Map type.\"", ")", ";", "}", "Type", "[", "]", "typeArgs", "=", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", ";", "TypeToken", "<", "?", ">", "keyType", "=", "typeToken", ".", "resolveType", "(", "typeArgs", "[", "0", "]", ")", ";", "TypeToken", "<", "?", ">", "valueType", "=", "typeToken", ".", "resolveType", "(", "typeArgs", "[", "1", "]", ")", ";", "Schema", "valueSchema", "=", "doGenerate", "(", "valueType", ",", "knownRecords", ",", "acceptRecursion", ")", ";", "return", "Schema", ".", "mapOf", "(", "doGenerate", "(", "keyType", ",", "knownRecords", ",", "acceptRecursion", ")", ",", "Schema", ".", "unionOf", "(", "valueSchema", ",", "Schema", ".", "of", "(", "Schema", ".", "Type", ".", "NULL", ")", ")", ")", ";", "}", "// Any Java class, class name as the record name.", "String", "recordName", "=", "typeToken", ".", "getRawType", "(", ")", ".", "getName", "(", ")", ";", "if", "(", "knownRecords", ".", "contains", "(", "recordName", ")", ")", "{", "// Record already seen before", "if", "(", "acceptRecursion", ")", "{", "// simply create a reference RECORD schema by the name.", "return", "Schema", ".", "recordOf", "(", "recordName", ")", ";", "}", "else", "{", "throw", "new", "UnsupportedTypeException", "(", "\"Recursive type not supported for class \"", "+", "recordName", ")", ";", "}", "}", "// Delegate to child class to generate RECORD schema.", "return", "generateRecord", "(", "typeToken", ",", "knownRecords", ",", "acceptRecursion", ")", ";", "}" ]

[ "Actual", "schema", "generation", ".", "It", "recursively", "resolves", "container", "types", "." ]

[ "void", "open", "(", "int", "groupSize", ")", "{", "try", "{", "close", "(", ")", ";", "ConsumerConfig", "config", "=", "consumerConfig", ";", "if", "(", "groupSize", "!=", "config", ".", "getGroupSize", "(", ")", ")", "{", "config", "=", "new", "ConsumerConfig", "(", "consumerConfig", ".", "getGroupId", "(", ")", ",", "consumerConfig", ".", "getInstanceId", "(", ")", ",", "groupSize", ",", "consumerConfig", ".", "getDequeueStrategy", "(", ")", ",", "consumerConfig", ".", "getHashKey", "(", ")", ")", ";", "}", "if", "(", "queueName", ".", "isQueue", "(", ")", ")", "{", "QueueConsumer", "queueConsumer", "=", "dataFabricFacade", ".", "createConsumer", "(", "queueName", ",", "config", ",", "numGroups", ")", ";", "consumerConfig", "=", "queueConsumer", ".", "getConfig", "(", ")", ";", "consumer", "=", "queueConsumer", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Updates", "number", "of", "instances", "for", "the", "consumer", "group", "that", "this", "instance", "belongs", "to", ".", "It", "ll", "close", "existing", "consumer", "and", "create", "a", "new", "one", "with", "the", "new", "group", "size", "." ]

[ "@", "Override", "public", "void", "close", "(", ")", "throws", "IOException", "{", "try", "{", "if", "(", "consumer", "!=", "null", "&&", "consumer", "instanceof", "Closeable", ")", "{", "// Call close in a new transaction.", "// TODO (terence): Actually need to coordinates with other flowlets to drain the queue.", "TransactionContext", "txContext", "=", "dataFabricFacade", ".", "createTransactionManager", "(", ")", ";", "txContext", ".", "start", "(", ")", ";", "try", "{", "(", "(", "Closeable", ")", "consumer", ")", ".", "close", "(", ")", ";", "txContext", ".", "finish", "(", ")", ";", "}", "catch", "(", "TransactionFailureException", "e", ")", "{", "LOG", ".", "warn", "(", "\"Fail to commit transaction when closing consumer.\"", ")", ";", "txContext", ".", "abort", "(", ")", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "warn", "(", "\"Fail to close queue consumer.\"", ",", "e", ")", ";", "}", "consumer", "=", "null", ";", "}" ]

[ "Close", "the", "current", "consumer", "if", "there", "is", "one", "." ]

[ "public", "boolean", "isCompatible", "(", "Schema", "target", ")", "{", "if", "(", "equals", "(", "target", ")", ")", "{", "return", "true", ";", "}", "Multimap", "<", "String", ",", "String", ">", "recordCompared", "=", "HashMultimap", ".", "create", "(", ")", ";", "return", "checkCompatible", "(", "target", ",", "recordCompared", ")", ";", "}" ]

[ "Checks", "if", "the", "given", "target", "schema", "is", "compatible", "with", "this", "schema", "meaning", "datum", "being", "written", "with", "this", "schema", "could", "be", "projected", "correctly", "into", "the", "given", "target", "schema", "." ]

[ "private", "<", "V", ">", "BiMap", "<", "V", ",", "Integer", ">", "createIndex", "(", "Set", "<", "V", ">", "values", ")", "{", "if", "(", "values", "==", "null", ")", "{", "return", "null", ";", "}", "ImmutableBiMap", ".", "Builder", "<", "V", ",", "Integer", ">", "builder", "=", "ImmutableBiMap", ".", "builder", "(", ")", ";", "int", "idx", "=", "0", ";", "for", "(", "V", "value", ":", "values", ")", "{", "builder", ".", "put", "(", "value", ",", "idx", "++", ")", ";", "}", "return", "builder", ".", "build", "(", ")", ";", "}" ]

[ "Creates", "a", "map", "of", "indexes", "based", "on", "the", "iteration", "order", "of", "the", "given", "set", "." ]

[ "private", "Map", "<", "String", ",", "Field", ">", "populateRecordFields", "(", "Map", "<", "String", ",", "Field", ">", "fields", ")", "{", "if", "(", "fields", "==", "null", ")", "{", "return", "null", ";", "}", "Map", "<", "String", ",", "Schema", ">", "knownRecordSchemas", "=", "Maps", ".", "newHashMap", "(", ")", ";", "knownRecordSchemas", ".", "put", "(", "recordName", ",", "this", ")", ";", "ImmutableMap", ".", "Builder", "<", "String", ",", "Field", ">", "builder", "=", "ImmutableMap", ".", "builder", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "Field", ">", "fieldEntry", ":", "fields", ".", "entrySet", "(", ")", ")", "{", "String", "fieldName", "=", "fieldEntry", ".", "getKey", "(", ")", ";", "Field", "field", "=", "fieldEntry", ".", "getValue", "(", ")", ";", "Schema", "fieldSchema", "=", "resolveSchema", "(", "field", ".", "getSchema", "(", ")", ",", "knownRecordSchemas", ")", ";", "if", "(", "fieldSchema", "==", "field", ".", "getSchema", "(", ")", ")", "{", "builder", ".", "put", "(", "fieldName", ",", "field", ")", ";", "}", "else", "{", "builder", ".", "put", "(", "fieldName", ",", "Field", ".", "of", "(", "fieldName", ",", "fieldSchema", ")", ")", ";", "}", "}", "return", "builder", ".", "build", "(", ")", ";", "}" ]

[ "Resolves", "all", "field", "schemas", "." ]

[ "private", "Schema", "resolveSchema", "(", "final", "Schema", "schema", ",", "final", "Map", "<", "String", ",", "Schema", ">", "knownRecordSchemas", ")", "{", "switch", "(", "schema", ".", "getType", "(", ")", ")", "{", "case", "ARRAY", ":", "Schema", "componentSchema", "=", "resolveSchema", "(", "schema", ".", "getComponentSchema", "(", ")", ",", "knownRecordSchemas", ")", ";", "return", "(", "componentSchema", "==", "schema", ".", "getComponentSchema", "(", ")", ")", "?", "schema", ":", "Schema", ".", "arrayOf", "(", "componentSchema", ")", ";", "case", "MAP", ":", "Map", ".", "Entry", "<", "Schema", ",", "Schema", ">", "entry", "=", "schema", ".", "getMapSchema", "(", ")", ";", "Schema", "keySchema", "=", "resolveSchema", "(", "entry", ".", "getKey", "(", ")", ",", "knownRecordSchemas", ")", ";", "Schema", "valueSchema", "=", "resolveSchema", "(", "entry", ".", "getValue", "(", ")", ",", "knownRecordSchemas", ")", ";", "return", "(", "keySchema", "==", "entry", ".", "getKey", "(", ")", "&&", "valueSchema", "==", "entry", ".", "getValue", "(", ")", ")", "?", "schema", ":", "Schema", ".", "mapOf", "(", "keySchema", ",", "valueSchema", ")", ";", "case", "UNION", ":", "ImmutableList", ".", "Builder", "<", "Schema", ">", "schemaBuilder", "=", "ImmutableList", ".", "builder", "(", ")", ";", "boolean", "changed", "=", "false", ";", "for", "(", "Schema", "input", ":", "schema", ".", "getUnionSchemas", "(", ")", ")", "{", "Schema", "output", "=", "resolveSchema", "(", "input", ",", "knownRecordSchemas", ")", ";", "if", "(", "output", "!=", "input", ")", "{", "changed", "=", "true", ";", "}", "schemaBuilder", ".", "add", "(", "output", ")", ";", "}", "return", "changed", "?", "Schema", ".", "unionOf", "(", "schemaBuilder", ".", "build", "(", ")", ")", ":", "schema", ";", "case", "RECORD", ":", "if", "(", "schema", ".", "fields", "==", "null", ")", "{", "// It is a named record that refers to previously defined record", "Schema", "knownSchema", "=", "knownRecordSchemas", ".", "get", "(", "schema", ".", "recordName", ")", ";", "Preconditions", ".", "checkArgument", "(", "knownSchema", "!=", "null", ",", "\"Undefined schema %s\"", ",", "schema", ".", "recordName", ")", ";", "return", "knownSchema", ";", "}", "else", "{", "// It is a concrete schema", "knownRecordSchemas", ".", "put", "(", "schema", ".", "recordName", ",", "schema", ")", ";", "return", "schema", ";", "}", "}", "return", "schema", ";", "}" ]

[ "This", "method", "is", "to", "recursively", "resolves", "all", "name", "only", "record", "schema", "in", "the", "given", "schema", "." ]

[ "private", "String", "buildString", "(", ")", "{", "if", "(", "type", ".", "isSimpleType", "(", ")", ")", "{", "return", "'", "'", "+", "type", ".", "name", "(", ")", ".", "toLowerCase", "(", ")", "+", "'", "'", ";", "}", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "JsonWriter", "writer", "=", "new", "JsonWriter", "(", "CharStreams", ".", "asWriter", "(", "builder", ")", ")", ";", "try", "{", "new", "SchemaTypeAdapter", "(", ")", ".", "write", "(", "writer", ",", "this", ")", ";", "writer", ".", "close", "(", ")", ";", "return", "builder", ".", "toString", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "// It should never throw IOException on the StringBuilder Writer, if it does, something very wrong.", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Helper", "method", "to", "encode", "this", "schema", "into", "json", "string", "." ]

[ "private", "void", "waitForInstances", "(", "String", "flowletId", ",", "int", "expectedInstances", ")", "throws", "InterruptedException", ",", "TimeoutException", "{", "int", "numRunningFlowlets", "=", "getNumberOfProvisionedInstances", "(", "flowletId", ")", ";", "int", "secondsWaited", "=", "0", ";", "while", "(", "numRunningFlowlets", "!=", "expectedInstances", ")", "{", "LOG", ".", "debug", "(", "\"waiting for {} instances of {} before suspending flowlets\"", ",", "expectedInstances", ",", "flowletId", ")", ";", "TimeUnit", ".", "SECONDS", ".", "sleep", "(", "SECONDS_PER_WAIT", ")", ";", "secondsWaited", "+=", "SECONDS_PER_WAIT", ";", "if", "(", "secondsWaited", ">", "MAX_WAIT_SECONDS", ")", "{", "String", "errmsg", "=", "String", ".", "format", "(", "\"waited %d seconds for instances of %s to reach expected count of %d, but %d are running\"", ",", "secondsWaited", ",", "flowletId", ",", "expectedInstances", ",", "numRunningFlowlets", ")", ";", "LOG", ".", "error", "(", "errmsg", ")", ";", "throw", "new", "TimeoutException", "(", "errmsg", ")", ";", "}", "numRunningFlowlets", "=", "getNumberOfProvisionedInstances", "(", "flowletId", ")", ";", "}", "}" ]

[ "it", "cannot", "change", "instances", "without", "being", "in", "the", "suspended", "state", "." ]

[ "private", "void", "setDefaultConfiguration", "(", "HTableDescriptor", "tableDescriptor", ",", "Configuration", "conf", ")", "{", "String", "compression", "=", "conf", ".", "get", "(", "CFG_HBASE_TABLE_COMPRESSION", ",", "DEFAULT_COMPRESSION_TYPE", ".", "name", "(", ")", ")", ";", "CompressionType", "compressionAlgo", "=", "CompressionType", ".", "valueOf", "(", "compression", ")", ";", "for", "(", "HColumnDescriptor", "hcd", ":", "tableDescriptor", ".", "getColumnFamilies", "(", ")", ")", "{", "setCompression", "(", "hcd", ",", "compressionAlgo", ")", ";", "setBloomFilter", "(", "hcd", ",", "BloomType", ".", "ROW", ")", ";", "}", "}" ]

[ "which", "doesn", "t", "support", "certain", "compression", "type" ]

[ "public", "static", "Map", "<", "String", ",", "CoprocessorInfo", ">", "getCoprocessorInfo", "(", "HTableDescriptor", "tableDescriptor", ")", "{", "Map", "<", "String", ",", "CoprocessorInfo", ">", "info", "=", "Maps", ".", "newHashMap", "(", ")", ";", "// Extract information about existing data janitor coprocessor", "// The following logic is copied from RegionCoprocessorHost in HBase", "for", "(", "Map", ".", "Entry", "<", "ImmutableBytesWritable", ",", "ImmutableBytesWritable", ">", "entry", ":", "tableDescriptor", ".", "getValues", "(", ")", ".", "entrySet", "(", ")", ")", "{", "String", "key", "=", "Bytes", ".", "toString", "(", "entry", ".", "getKey", "(", ")", ".", "get", "(", ")", ")", ".", "trim", "(", ")", ";", "String", "spec", "=", "Bytes", ".", "toString", "(", "entry", ".", "getValue", "(", ")", ".", "get", "(", ")", ")", ".", "trim", "(", ")", ";", "if", "(", "!", "HConstants", ".", "CP_HTD_ATTR_KEY_PATTERN", ".", "matcher", "(", "key", ")", ".", "matches", "(", ")", ")", "{", "continue", ";", "}", "try", "{", "Matcher", "matcher", "=", "HConstants", ".", "CP_HTD_ATTR_VALUE_PATTERN", ".", "matcher", "(", "spec", ")", ";", "if", "(", "!", "matcher", ".", "matches", "(", ")", ")", "{", "continue", ";", "}", "String", "className", "=", "matcher", ".", "group", "(", "2", ")", ".", "trim", "(", ")", ";", "Path", "path", "=", "matcher", ".", "group", "(", "1", ")", ".", "trim", "(", ")", ".", "isEmpty", "(", ")", "?", "null", ":", "new", "Path", "(", "matcher", ".", "group", "(", "1", ")", ".", "trim", "(", ")", ")", ";", "int", "priority", "=", "matcher", ".", "group", "(", "3", ")", ".", "trim", "(", ")", ".", "isEmpty", "(", ")", "?", "Coprocessor", ".", "PRIORITY_USER", ":", "Integer", ".", "valueOf", "(", "matcher", ".", "group", "(", "3", ")", ")", ";", "String", "cfgSpec", "=", "null", ";", "try", "{", "cfgSpec", "=", "matcher", ".", "group", "(", "4", ")", ";", "}", "catch", "(", "IndexOutOfBoundsException", "ex", ")", "{", "// ignore", "}", "Map", "<", "String", ",", "String", ">", "properties", "=", "Maps", ".", "newHashMap", "(", ")", ";", "if", "(", "cfgSpec", "!=", "null", ")", "{", "cfgSpec", "=", "cfgSpec", ".", "substring", "(", "cfgSpec", ".", "indexOf", "(", "'", "'", ")", "+", "1", ")", ";", "// do an explicit deep copy of the passed configuration", "Matcher", "m", "=", "HConstants", ".", "CP_HTD_ATTR_VALUE_PARAM_PATTERN", ".", "matcher", "(", "cfgSpec", ")", ";", "while", "(", "m", ".", "find", "(", ")", ")", "{", "properties", ".", "put", "(", "m", ".", "group", "(", "1", ")", ",", "m", ".", "group", "(", "2", ")", ")", ";", "}", "}", "info", ".", "put", "(", "className", ",", "new", "CoprocessorInfo", "(", "className", ",", "path", ",", "priority", ",", "properties", ")", ")", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "LOG", ".", "warn", "(", "\"Coprocessor attribute '{}' has invalid coprocessor specification '{}'\"", ",", "key", ",", "spec", ",", "ex", ")", ";", "}", "}", "return", "info", ";", "}" ]

[ "Returns", "information", "for", "all", "coprocessor", "configured", "for", "the", "table", "." ]

[ "private", "void", "invoke", "(", "Method", "method", ",", "Object", "event", ",", "InputContext", "inputContext", ")", "throws", "Exception", "{", "if", "(", "needContext", ")", "{", "method", ".", "invoke", "(", "flowlet", ",", "event", ",", "inputContext", ")", ";", "}", "else", "{", "method", ".", "invoke", "(", "flowlet", ",", "event", ")", ";", "}", "}" ]

[ "Calls", "the", "user", "process", "method", "." ]

[ "public", "static", "CConfiguration", "create", "(", ")", "{", "// Create a new configuration instance, but do NOT initialize with", "// the Hadoop default properties.", "CConfiguration", "conf", "=", "new", "CConfiguration", "(", ")", ";", "conf", ".", "addResource", "(", "\"tigon-default.xml\"", ")", ";", "conf", ".", "addResource", "(", "\"tigon-site.xml\"", ")", ";", "return", "conf", ";", "}" ]

[ "Creates", "an", "instance", "of", "configuration", "." ]

[ "protected", "void", "upgradeTable", "(", "String", "tableNameStr", ")", "throws", "IOException", "{", "byte", "[", "]", "tableName", "=", "Bytes", ".", "toBytes", "(", "tableNameStr", ")", ";", "HTableDescriptor", "tableDescriptor", "=", "getAdmin", "(", ")", ".", "getTableDescriptor", "(", "tableName", ")", ";", "// Upgrade any table properties if necessary", "boolean", "needUpgrade", "=", "upgradeTable", "(", "tableDescriptor", ")", ";", "// Get the Tigon version from the table", "ProjectInfo", ".", "Version", "version", "=", "new", "ProjectInfo", ".", "Version", "(", "tableDescriptor", ".", "getValue", "(", "TIGON_VERSION", ")", ")", ";", "if", "(", "!", "needUpgrade", "&&", "version", ".", "compareTo", "(", "ProjectInfo", ".", "getVersion", "(", ")", ")", ">=", "0", ")", "{", "// If the table has greater than or same version, no need to upgrade.", "LOG", ".", "info", "(", "\"Table '{}' was upgraded with same or newer version '{}'. Current version is '{}'\"", ",", "tableNameStr", ",", "version", ",", "ProjectInfo", ".", "getVersion", "(", ")", ")", ";", "return", ";", "}", "// Generate the coprocessor jar", "CoprocessorJar", "coprocessorJar", "=", "createCoprocessorJar", "(", ")", ";", "Location", "jarLocation", "=", "coprocessorJar", ".", "getJarLocation", "(", ")", ";", "// Check if coprocessor upgrade is needed", "Map", "<", "String", ",", "HBaseTableUtil", ".", "CoprocessorInfo", ">", "coprocessorInfo", "=", "HBaseTableUtil", ".", "getCoprocessorInfo", "(", "tableDescriptor", ")", ";", "// For all required coprocessors, check if they've need to be upgraded.", "for", "(", "Class", "<", "?", "extends", "Coprocessor", ">", "coprocessor", ":", "coprocessorJar", ".", "getCoprocessors", "(", ")", ")", "{", "HBaseTableUtil", ".", "CoprocessorInfo", "info", "=", "coprocessorInfo", ".", "get", "(", "coprocessor", ".", "getName", "(", ")", ")", ";", "if", "(", "info", "!=", "null", ")", "{", "// The same coprocessor has been configured, check by the file name hash to see if they are the same.", "if", "(", "!", "jarLocation", ".", "getName", "(", ")", ".", "equals", "(", "info", ".", "getPath", "(", ")", ".", "getName", "(", ")", ")", ")", "{", "needUpgrade", "=", "true", ";", "// Remove old one and add the new one.", "tableDescriptor", ".", "removeCoprocessor", "(", "info", ".", "getClassName", "(", ")", ")", ";", "addCoprocessor", "(", "tableDescriptor", ",", "coprocessor", ",", "jarLocation", ",", "coprocessorJar", ".", "getPriority", "(", "coprocessor", ")", ")", ";", "}", "}", "else", "{", "// The coprocessor is missing from the table, add it.", "needUpgrade", "=", "true", ";", "addCoprocessor", "(", "tableDescriptor", ",", "coprocessor", ",", "jarLocation", ",", "coprocessorJar", ".", "getPriority", "(", "coprocessor", ")", ")", ";", "}", "}", "// Removes all old coprocessors", "Set", "<", "String", ">", "coprocessorNames", "=", "ImmutableSet", ".", "copyOf", "(", "Iterables", ".", "transform", "(", "coprocessorJar", ".", "coprocessors", ",", "CLASS_TO_NAME", ")", ")", ";", "for", "(", "String", "remove", ":", "Sets", ".", "difference", "(", "coprocessorInfo", ".", "keySet", "(", ")", ",", "coprocessorNames", ")", ")", "{", "needUpgrade", "=", "true", ";", "tableDescriptor", ".", "removeCoprocessor", "(", "remove", ")", ";", "}", "if", "(", "!", "needUpgrade", ")", "{", "LOG", ".", "info", "(", "\"No upgrade needed for table '{}'\"", ",", "tableNameStr", ")", ";", "return", ";", "}", "// Add the current version as table properties only if the table needs upgrade", "tableDescriptor", ".", "setValue", "(", "TIGON_VERSION", ",", "ProjectInfo", ".", "getVersion", "(", ")", ".", "toString", "(", ")", ")", ";", "LOG", ".", "info", "(", "\"Upgrading table '{}'...\"", ",", "tableNameStr", ")", ";", "boolean", "enableTable", "=", "false", ";", "try", "{", "getAdmin", "(", ")", ".", "disableTable", "(", "tableName", ")", ";", "enableTable", "=", "true", ";", "}", "catch", "(", "TableNotEnabledException", "e", ")", "{", "LOG", ".", "debug", "(", "\"Table '{}' not enabled when try to disable it.\"", ",", "tableNameStr", ")", ";", "}", "getAdmin", "(", ")", ".", "modifyTable", "(", "tableName", ",", "tableDescriptor", ")", ";", "if", "(", "enableTable", ")", "{", "getAdmin", "(", ")", ".", "enableTable", "(", "tableName", ")", ";", "}", "LOG", ".", "info", "(", "\"Table '{}' upgrade completed.\"", ",", "tableNameStr", ")", ";", "}" ]

[ "Performs", "upgrade", "on", "a", "given", "HBase", "table", "." ]

[ "public", "static", "void", "mkdirsIfNotExists", "(", "Location", "location", ")", "throws", "IOException", "{", "// Need to check && mkdir && check to deal with race condition", "if", "(", "!", "location", ".", "isDirectory", "(", ")", "&&", "!", "location", ".", "mkdirs", "(", ")", "&&", "!", "location", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "IOException", "(", "\"Failed to create directory at \"", "+", "location", ".", "toURI", "(", ")", ")", ";", "}", "}" ]

[ "Create", "the", "directory", "represented", "by", "the", "location", "if", "not", "exists", "." ]

[ "public", "static", "Manifest", "getManifest", "(", "Location", "jarLocation", ")", "throws", "IOException", "{", "URI", "uri", "=", "jarLocation", ".", "toURI", "(", ")", ";", "// Small optimization if the location is local", "if", "(", "\"file\"", ".", "equals", "(", "uri", ".", "getScheme", "(", ")", ")", ")", "{", "JarFile", "jarFile", "=", "new", "JarFile", "(", "new", "File", "(", "uri", ")", ")", ";", "try", "{", "return", "jarFile", ".", "getManifest", "(", ")", ";", "}", "finally", "{", "jarFile", ".", "close", "(", ")", ";", "}", "}", "// Otherwise, need to search it with JarInputStream", "JarInputStream", "is", "=", "new", "JarInputStream", "(", "new", "BufferedInputStream", "(", "jarLocation", ".", "getInputStream", "(", ")", ")", ")", ";", "try", "{", "// This only looks at the first entry, which if is created with jar util, then it'll be there.", "Manifest", "manifest", "=", "is", ".", "getManifest", "(", ")", ";", "if", "(", "manifest", "!=", "null", ")", "{", "return", "manifest", ";", "}", "// Otherwise, slow path. Need to goes through the entries", "JarEntry", "jarEntry", "=", "is", ".", "getNextJarEntry", "(", ")", ";", "while", "(", "jarEntry", "!=", "null", ")", "{", "if", "(", "JarFile", ".", "MANIFEST_NAME", ".", "equals", "(", "jarEntry", ".", "getName", "(", ")", ")", ")", "{", "return", "new", "Manifest", "(", "is", ")", ";", "}", "jarEntry", "=", "is", ".", "getNextJarEntry", "(", ")", ";", "}", "}", "finally", "{", "is", ".", "close", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "Load", "the", "manifest", "inside", "the", "given", "jar", "." ]

[ "protected", "int", "persist", "(", "Iterable", "<", "QueueEntry", ">", "entries", ",", "Transaction", "transaction", ")", "throws", "IOException", "{", "long", "writePointer", "=", "transaction", ".", "getWritePointer", "(", ")", ";", "byte", "[", "]", "rowKeyPrefix", "=", "Bytes", ".", "add", "(", "queueRowPrefix", ",", "Bytes", ".", "toBytes", "(", "writePointer", ")", ")", ";", "int", "count", "=", "0", ";", "List", "<", "Put", ">", "puts", "=", "Lists", ".", "newArrayList", "(", ")", ";", "int", "bytes", "=", "0", ";", "for", "(", "QueueEntry", "entry", ":", "entries", ")", "{", "// Row key = queue_name + writePointer + counter", "byte", "[", "]", "rowKey", "=", "Bytes", ".", "add", "(", "rowKeyPrefix", ",", "Bytes", ".", "toBytes", "(", "count", "++", ")", ")", ";", "rowKey", "=", "HBaseQueueAdmin", ".", "ROW_KEY_DISTRIBUTOR", ".", "getDistributedKey", "(", "rowKey", ")", ";", "rollbackKeys", ".", "add", "(", "rowKey", ")", ";", "// No need to write ts=writePointer, as the row key already contains the writePointer", "Put", "put", "=", "new", "Put", "(", "rowKey", ")", ";", "put", ".", "add", "(", "QueueEntryRow", ".", "COLUMN_FAMILY", ",", "QueueEntryRow", ".", "DATA_COLUMN", ",", "entry", ".", "getData", "(", ")", ")", ";", "put", ".", "add", "(", "QueueEntryRow", ".", "COLUMN_FAMILY", ",", "QueueEntryRow", ".", "META_COLUMN", ",", "QueueEntry", ".", "serializeHashKeys", "(", "entry", ".", "getHashKeys", "(", ")", ")", ")", ";", "puts", ".", "add", "(", "put", ")", ";", "bytes", "+=", "entry", ".", "getData", "(", ")", ".", "length", ";", "}", "hTable", ".", "put", "(", "puts", ")", ";", "hTable", ".", "flushCommits", "(", ")", ";", "return", "bytes", ";", "}" ]

[ "Persist", "queue", "entries", "into", "HBase", "." ]

[ "public", "static", "Credentials", "obtainToken", "(", "Configuration", "hConf", ",", "Credentials", "credentials", ")", "{", "if", "(", "!", "User", ".", "isHBaseSecurityEnabled", "(", "hConf", ")", ")", "{", "return", "credentials", ";", "}", "try", "{", "Class", "c", "=", "Class", ".", "forName", "(", "\"org.apache.hadoop.hbase.security.token.TokenUtil\"", ")", ";", "Method", "method", "=", "c", ".", "getMethod", "(", "\"obtainToken\"", ",", "Configuration", ".", "class", ")", ";", "Token", "<", "?", "extends", "TokenIdentifier", ">", "token", "=", "castToken", "(", "method", ".", "invoke", "(", "null", ",", "hConf", ")", ")", ";", "credentials", ".", "addToken", "(", "token", ".", "getService", "(", ")", ",", "token", ")", ";", "return", "credentials", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "\"Failed to get secure token for HBase.\"", ",", "e", ")", ";", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Gets", "a", "HBase", "delegation", "token", "and", "stores", "it", "in", "the", "given", "Credentials", "." ]

[ "public", "void", "suspend", "(", ")", "{", "if", "(", "suspension", ".", "compareAndSet", "(", "null", ",", "new", "CountDownLatch", "(", "1", ")", ")", ")", "{", "try", "{", "suspendBarrier", ".", "await", "(", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "Thread", ".", "currentThread", "(", ")", ".", "interrupt", "(", ")", ";", "}", "catch", "(", "BrokenBarrierException", "e", ")", "{", "LOG", ".", "error", "(", "\"Exception during suspend: \"", "+", "flowletContext", ",", "e", ")", ";", "}", "}", "}" ]

[ "Suspend", "the", "running", "of", "flowlet", ".", "This", "method", "will", "block", "until", "the", "flowlet", "running", "thread", "actually", "suspended", "." ]

[ "public", "void", "resume", "(", ")", "{", "CountDownLatch", "latch", "=", "suspension", ".", "getAndSet", "(", "null", ")", ";", "if", "(", "latch", "!=", "null", ")", "{", "suspendBarrier", ".", "reset", "(", ")", ";", "latch", ".", "countDown", "(", ")", ";", "}", "}" ]

[ "Resume", "the", "running", "of", "flowlet", "." ]

[ "private", "void", "postProcess", "(", "ProcessMethodCallback", "callback", ",", "TransactionContext", "txContext", ",", "InputDatum", "input", ",", "ProcessMethod", ".", "ProcessResult", "result", ")", "{", "InputContext", "inputContext", "=", "input", ".", "getInputContext", "(", ")", ";", "Throwable", "failureCause", "=", "null", ";", "FailureReason", ".", "Type", "failureType", "=", "FailureReason", ".", "Type", ".", "IO_ERROR", ";", "try", "{", "if", "(", "result", ".", "isSuccess", "(", ")", ")", "{", "// If it is a retry input, force the dequeued entries into current transaction.", "if", "(", "input", ".", "getRetry", "(", ")", ">", "0", ")", "{", "input", ".", "reclaim", "(", ")", ";", "}", "txContext", ".", "finish", "(", ")", ";", "}", "else", "{", "failureCause", "=", "result", ".", "getCause", "(", ")", ";", "failureType", "=", "FailureReason", ".", "Type", ".", "USER", ";", "txContext", ".", "abort", "(", ")", ";", "}", "}", "catch", "(", "Throwable", "e", ")", "{", "LOG", ".", "error", "(", "\"Transaction operation failed: {}\"", ",", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "failureType", "=", "FailureReason", ".", "Type", ".", "IO_ERROR", ";", "if", "(", "failureCause", "==", "null", ")", "{", "failureCause", "=", "e", ";", "}", "try", "{", "if", "(", "result", ".", "isSuccess", "(", ")", ")", "{", "txContext", ".", "abort", "(", ")", ";", "}", "}", "catch", "(", "Throwable", "ex", ")", "{", "LOG", ".", "error", "(", "\"Fail to abort transaction: {}\"", ",", "inputContext", ",", "ex", ")", ";", "}", "}", "try", "{", "if", "(", "failureCause", "==", "null", ")", "{", "callback", ".", "onSuccess", "(", "result", ".", "getEvent", "(", ")", ",", "inputContext", ")", ";", "}", "else", "{", "callback", ".", "onFailure", "(", "result", ".", "getEvent", "(", ")", ",", "inputContext", ",", "new", "FailureReason", "(", "failureType", ",", "failureCause", ".", "getMessage", "(", ")", ",", "failureCause", ")", ",", "createInputAcknowledger", "(", "input", ")", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "LOG", ".", "error", "(", "\"Failed to invoke callback.\"", ",", "t", ")", ";", "}", "}" ]

[ "Process", "the", "process", "result", ".", "This", "method", "never", "throws", "." ]

[ "public", "static", "int", "putBytes", "(", "byte", "[", "]", "tgtBytes", ",", "int", "tgtOffset", ",", "byte", "[", "]", "srcBytes", ",", "int", "srcOffset", ",", "int", "srcLength", ")", "{", "System", ".", "arraycopy", "(", "srcBytes", ",", "srcOffset", ",", "tgtBytes", ",", "tgtOffset", ",", "srcLength", ")", ";", "return", "tgtOffset", "+", "srcLength", ";", "}" ]

[ "Put", "bytes", "at", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "byte", "[", "]", "toBytes", "(", "ByteBuffer", "bb", ")", "{", "int", "length", "=", "bb", ".", "limit", "(", ")", ";", "byte", "[", "]", "result", "=", "new", "byte", "[", "length", "]", ";", "System", ".", "arraycopy", "(", "bb", ".", "array", "(", ")", ",", "bb", ".", "arrayOffset", "(", ")", ",", "result", ",", "0", ",", "length", ")", ";", "return", "result", ";", "}" ]

[ "Returns", "a", "new", "byte", "array", "copied", "from", "the", "passed", "ByteBuffer", "." ]

[ "public", "static", "String", "toStringBinary", "(", "ByteBuffer", "buf", ")", "{", "if", "(", "buf", "==", "null", ")", "{", "return", "\"null\"", ";", "}", "return", "toStringBinary", "(", "buf", ".", "array", "(", ")", ",", "buf", ".", "arrayOffset", "(", ")", ",", "buf", ".", "limit", "(", ")", ")", ";", "}" ]

[ "Converts", "the", "given", "byte", "buffer", "from", "its", "array", "offset", "to", "its", "limit", "to", "a", "string", ".", "The", "position", "and", "the", "mark", "are", "ignored", "." ]

[ "public", "static", "long", "toLong", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "final", "int", "length", ")", "{", "if", "(", "length", "!=", "SIZEOF_LONG", "||", "offset", "+", "length", ">", "bytes", ".", "length", ")", "{", "throw", "explainWrongLengthOrOffset", "(", "bytes", ",", "offset", ",", "length", ",", "SIZEOF_LONG", ")", ";", "}", "long", "l", "=", "0", ";", "for", "(", "int", "i", "=", "offset", ";", "i", "<", "offset", "+", "length", ";", "i", "++", ")", "{", "l", "<<=", "8", ";", "l", "^=", "bytes", "[", "i", "]", "&", "0xFF", ";", "}", "return", "l", ";", "}" ]

[ "Converts", "a", "byte", "array", "to", "a", "long", "value", "." ]

[ "public", "static", "int", "putLong", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "long", "val", ")", "{", "if", "(", "bytes", ".", "length", "-", "offset", "<", "SIZEOF_LONG", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Not enough room to put a long at\"", "+", "\" offset \"", "+", "offset", "+", "\" in a \"", "+", "bytes", ".", "length", "+", "\" byte array\"", ")", ";", "}", "for", "(", "int", "i", "=", "offset", "+", "7", ";", "i", ">", "offset", ";", "i", "--", ")", "{", "bytes", "[", "i", "]", "=", "(", "byte", ")", "val", ";", "val", ">>>=", "8", ";", "}", "bytes", "[", "offset", "]", "=", "(", "byte", ")", "val", ";", "return", "offset", "+", "SIZEOF_LONG", ";", "}" ]

[ "Put", "a", "long", "value", "out", "to", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "int", "putFloat", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "float", "f", ")", "{", "return", "putInt", "(", "bytes", ",", "offset", ",", "Float", ".", "floatToRawIntBits", "(", "f", ")", ")", ";", "}" ]

[ "Put", "a", "float", "value", "out", "to", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "int", "putDouble", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "double", "d", ")", "{", "return", "putLong", "(", "bytes", ",", "offset", ",", "Double", ".", "doubleToLongBits", "(", "d", ")", ")", ";", "}" ]

[ "Put", "a", "double", "value", "out", "to", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "byte", "[", "]", "toBytes", "(", "int", "val", ")", "{", "byte", "[", "]", "b", "=", "new", "byte", "[", "4", "]", ";", "for", "(", "int", "i", "=", "3", ";", "i", ">", "0", ";", "i", "--", ")", "{", "b", "[", "i", "]", "=", "(", "byte", ")", "val", ";", "val", ">>>=", "8", ";", "}", "b", "[", "0", "]", "=", "(", "byte", ")", "val", ";", "return", "b", ";", "}" ]

[ "Convert", "an", "int", "value", "to", "a", "byte", "array", "." ]

[ "public", "static", "int", "putInt", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "int", "val", ")", "{", "if", "(", "bytes", ".", "length", "-", "offset", "<", "SIZEOF_INT", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Not enough room to put an int at\"", "+", "\" offset \"", "+", "offset", "+", "\" in a \"", "+", "bytes", ".", "length", "+", "\" byte array\"", ")", ";", "}", "for", "(", "int", "i", "=", "offset", "+", "3", ";", "i", ">", "offset", ";", "i", "--", ")", "{", "bytes", "[", "i", "]", "=", "(", "byte", ")", "val", ";", "val", ">>>=", "8", ";", "}", "bytes", "[", "offset", "]", "=", "(", "byte", ")", "val", ";", "return", "offset", "+", "SIZEOF_INT", ";", "}" ]

[ "Put", "an", "int", "value", "out", "to", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "short", "toShort", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "final", "int", "length", ")", "{", "if", "(", "length", "!=", "SIZEOF_SHORT", "||", "offset", "+", "length", ">", "bytes", ".", "length", ")", "{", "throw", "explainWrongLengthOrOffset", "(", "bytes", ",", "offset", ",", "length", ",", "SIZEOF_SHORT", ")", ";", "}", "short", "n", "=", "0", ";", "n", "^=", "bytes", "[", "offset", "]", "&", "0xFF", ";", "n", "<<=", "8", ";", "n", "^=", "bytes", "[", "offset", "+", "1", "]", "&", "0xFF", ";", "return", "n", ";", "}" ]

[ "Converts", "a", "byte", "array", "to", "a", "short", "value", "." ]

[ "public", "static", "byte", "[", "]", "getBytes", "(", "ByteBuffer", "buf", ")", "{", "int", "savedPos", "=", "buf", ".", "position", "(", ")", ";", "byte", "[", "]", "newBytes", "=", "new", "byte", "[", "buf", ".", "remaining", "(", ")", "]", ";", "buf", ".", "get", "(", "newBytes", ")", ";", "buf", ".", "position", "(", "savedPos", ")", ";", "return", "newBytes", ";", "}" ]

[ "This", "method", "will", "get", "a", "sequence", "of", "bytes", "from", "pos", "-", ">", "limit", "but", "will", "restore", "pos", "after", "." ]

[ "public", "static", "int", "putShort", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "short", "val", ")", "{", "if", "(", "bytes", ".", "length", "-", "offset", "<", "SIZEOF_SHORT", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Not enough room to put a short at\"", "+", "\" offset \"", "+", "offset", "+", "\" in a \"", "+", "bytes", ".", "length", "+", "\" byte array\"", ")", ";", "}", "bytes", "[", "offset", "+", "1", "]", "=", "(", "byte", ")", "val", ";", "val", ">>=", "8", ";", "bytes", "[", "offset", "]", "=", "(", "byte", ")", "val", ";", "return", "offset", "+", "SIZEOF_SHORT", ";", "}" ]

[ "Put", "a", "short", "value", "out", "to", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "byte", "[", "]", "toBytes", "(", "BigDecimal", "val", ")", "{", "byte", "[", "]", "valueBytes", "=", "val", ".", "unscaledValue", "(", ")", ".", "toByteArray", "(", ")", ";", "byte", "[", "]", "result", "=", "new", "byte", "[", "valueBytes", ".", "length", "+", "SIZEOF_INT", "]", ";", "int", "offset", "=", "putInt", "(", "result", ",", "0", ",", "val", ".", "scale", "(", ")", ")", ";", "putBytes", "(", "result", ",", "offset", ",", "valueBytes", ",", "0", ",", "valueBytes", ".", "length", ")", ";", "return", "result", ";", "}" ]

[ "Convert", "a", "BigDecimal", "value", "to", "a", "byte", "array", "." ]

[ "public", "static", "BigDecimal", "toBigDecimal", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "final", "int", "length", ")", "{", "if", "(", "bytes", "==", "null", "||", "length", "<", "SIZEOF_INT", "+", "1", "||", "(", "offset", "+", "length", ">", "bytes", ".", "length", ")", ")", "{", "return", "null", ";", "}", "int", "scale", "=", "toInt", "(", "bytes", ",", "offset", ")", ";", "byte", "[", "]", "tcBytes", "=", "new", "byte", "[", "length", "-", "SIZEOF_INT", "]", ";", "System", ".", "arraycopy", "(", "bytes", ",", "offset", "+", "SIZEOF_INT", ",", "tcBytes", ",", "0", ",", "length", "-", "SIZEOF_INT", ")", ";", "return", "new", "BigDecimal", "(", "new", "BigInteger", "(", "tcBytes", ")", ",", "scale", ")", ";", "}" ]

[ "Converts", "a", "byte", "array", "to", "a", "BigDecimal", "value", "." ]

[ "public", "static", "int", "putBigDecimal", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "BigDecimal", "val", ")", "{", "if", "(", "bytes", "==", "null", ")", "{", "return", "offset", ";", "}", "byte", "[", "]", "valueBytes", "=", "val", ".", "unscaledValue", "(", ")", ".", "toByteArray", "(", ")", ";", "byte", "[", "]", "result", "=", "new", "byte", "[", "valueBytes", ".", "length", "+", "SIZEOF_INT", "]", ";", "offset", "=", "putInt", "(", "result", ",", "offset", ",", "val", ".", "scale", "(", ")", ")", ";", "return", "putBytes", "(", "result", ",", "offset", ",", "valueBytes", ",", "0", ",", "valueBytes", ".", "length", ")", ";", "}" ]

[ "Put", "a", "BigDecimal", "value", "out", "to", "the", "specified", "byte", "array", "position", "." ]

[ "public", "static", "boolean", "startsWith", "(", "byte", "[", "]", "bytes", ",", "byte", "[", "]", "prefix", ")", "{", "return", "bytes", "!=", "null", "&&", "prefix", "!=", "null", "&&", "bytes", ".", "length", ">=", "prefix", ".", "length", "&&", "LexicographicalComparerHolder", ".", "BEST_COMPARER", ".", "compareTo", "(", "bytes", ",", "0", ",", "prefix", ".", "length", ",", "prefix", ",", "0", ",", "prefix", ".", "length", ")", "==", "0", ";", "}" ]

[ "Return", "true", "if", "the", "byte", "array", "on", "the", "right", "is", "a", "prefix", "of", "the", "byte", "array", "on", "the", "left", "." ]

[ "public", "static", "int", "hashBytes", "(", "byte", "[", "]", "bytes", ",", "int", "offset", ",", "int", "length", ")", "{", "int", "hash", "=", "1", ";", "for", "(", "int", "i", "=", "offset", ";", "i", "<", "offset", "+", "length", ";", "i", "++", ")", "{", "hash", "=", "(", "31", "*", "hash", ")", "+", "bytes", "[", "i", "]", ";", "}", "return", "hash", ";", "}" ]

[ "Compute", "hash", "for", "binary", "data", "." ]

[ "public", "static", "byte", "[", "]", "add", "(", "final", "byte", "[", "]", "a", ",", "final", "byte", "[", "]", "b", ",", "final", "byte", "[", "]", "c", ")", "{", "byte", "[", "]", "result", "=", "new", "byte", "[", "a", ".", "length", "+", "b", ".", "length", "+", "c", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "a", ",", "0", ",", "result", ",", "0", ",", "a", ".", "length", ")", ";", "System", ".", "arraycopy", "(", "b", ",", "0", ",", "result", ",", "a", ".", "length", ",", "b", ".", "length", ")", ";", "System", ".", "arraycopy", "(", "c", ",", "0", ",", "result", ",", "a", ".", "length", "+", "b", ".", "length", ",", "c", ".", "length", ")", ";", "return", "result", ";", "}" ]

[ "Concatenate", "three", "byte", "arrays", "." ]

[ "public", "static", "byte", "[", "]", "[", "]", "split", "(", "final", "byte", "[", "]", "a", ",", "final", "byte", "[", "]", "b", ",", "boolean", "inclusive", ",", "final", "int", "num", ")", "{", "byte", "[", "]", "[", "]", "ret", "=", "new", "byte", "[", "num", "+", "2", "]", "[", "", "]", ";", "int", "i", "=", "0", ";", "Iterable", "<", "byte", "[", "]", ">", "iter", "=", "iterateOnSplits", "(", "a", ",", "b", ",", "inclusive", ",", "num", ")", ";", "if", "(", "iter", "==", "null", ")", "{", "return", "null", ";", "}", "for", "(", "byte", "[", "]", "elem", ":", "iter", ")", "{", "ret", "[", "i", "++", "]", "=", "elem", ";", "}", "return", "ret", ";", "}" ]

[ "Split", "passed", "range", ".", "Expensive", "operation", "relatively", ".", "Uses", "BigInteger", "math", ".", "Useful", "splitting", "ranges", "for", "MapReduce", "jobs", "." ]

[ "public", "static", "Iterable", "<", "byte", "[", "]", ">", "iterateOnSplits", "(", "final", "byte", "[", "]", "a", ",", "final", "byte", "[", "]", "b", ",", "final", "int", "num", ")", "{", "return", "iterateOnSplits", "(", "a", ",", "b", ",", "false", ",", "num", ")", ";", "}" ]

[ "Iterate", "over", "keys", "within", "the", "passed", "range", "splitting", "at", "an", "[", "a", "b", ")", "boundary", "." ]

[ "public", "static", "Iterable", "<", "byte", "[", "]", ">", "iterateOnSplits", "(", "final", "byte", "[", "]", "a", ",", "final", "byte", "[", "]", "b", ",", "boolean", "inclusive", ",", "final", "int", "num", ")", "{", "byte", "[", "]", "aPadded", ";", "byte", "[", "]", "bPadded", ";", "if", "(", "a", ".", "length", "<", "b", ".", "length", ")", "{", "aPadded", "=", "padTail", "(", "a", ",", "b", ".", "length", "-", "a", ".", "length", ")", ";", "bPadded", "=", "b", ";", "}", "else", "if", "(", "b", ".", "length", "<", "a", ".", "length", ")", "{", "aPadded", "=", "a", ";", "bPadded", "=", "padTail", "(", "b", ",", "a", ".", "length", "-", "b", ".", "length", ")", ";", "}", "else", "{", "aPadded", "=", "a", ";", "bPadded", "=", "b", ";", "}", "if", "(", "compareTo", "(", "aPadded", ",", "bPadded", ")", ">=", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"b <= a\"", ")", ";", "}", "if", "(", "num", "<=", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"num cannot be < 0\"", ")", ";", "}", "byte", "[", "]", "prependHeader", "=", "{", "1", ",", "0", "}", ";", "final", "BigInteger", "startBI", "=", "new", "BigInteger", "(", "add", "(", "prependHeader", ",", "aPadded", ")", ")", ";", "final", "BigInteger", "stopBI", "=", "new", "BigInteger", "(", "add", "(", "prependHeader", ",", "bPadded", ")", ")", ";", "BigInteger", "diffBI", "=", "stopBI", ".", "subtract", "(", "startBI", ")", ";", "if", "(", "inclusive", ")", "{", "diffBI", "=", "diffBI", ".", "add", "(", "BigInteger", ".", "ONE", ")", ";", "}", "final", "BigInteger", "splitsBI", "=", "BigInteger", ".", "valueOf", "(", "num", "+", "1", ")", ";", "if", "(", "diffBI", ".", "compareTo", "(", "splitsBI", ")", "<", "0", ")", "{", "return", "null", ";", "}", "final", "BigInteger", "intervalBI", ";", "try", "{", "intervalBI", "=", "diffBI", ".", "divide", "(", "splitsBI", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "null", ";", "}", "final", "Iterator", "<", "byte", "[", "]", ">", "iterator", "=", "new", "Iterator", "<", "byte", "[", "]", ">", "(", ")", "{", "private", "int", "i", "=", "-", "1", ";", "@", "Override", "public", "boolean", "hasNext", "(", ")", "{", "return", "this", ".", "i", "<", "num", "+", "1", ";", "}", "@", "Override", "public", "byte", "[", "]", "next", "(", ")", "{", "this", ".", "i", "++", ";", "if", "(", "this", ".", "i", "==", "0", ")", "{", "return", "a", ";", "}", "if", "(", "this", ".", "i", "==", "num", "+", "1", ")", "{", "return", "b", ";", "}", "BigInteger", "curBI", "=", "startBI", ".", "add", "(", "intervalBI", ".", "multiply", "(", "BigInteger", ".", "valueOf", "(", "this", ".", "i", ")", ")", ")", ";", "byte", "[", "]", "padded", "=", "curBI", ".", "toByteArray", "(", ")", ";", "if", "(", "padded", "[", "1", "]", "==", "0", ")", "{", "padded", "=", "tail", "(", "padded", ",", "padded", ".", "length", "-", "2", ")", ";", "}", "else", "{", "padded", "=", "tail", "(", "padded", ",", "padded", ".", "length", "-", "1", ")", ";", "}", "return", "padded", ";", "}", "@", "Override", "public", "void", "remove", "(", ")", "{", "throw", "new", "UnsupportedOperationException", "(", ")", ";", "}", "}", ";", "return", "new", "Iterable", "<", "byte", "[", "]", ">", "(", ")", "{", "@", "Override", "public", "Iterator", "<", "byte", "[", "]", ">", "iterator", "(", ")", "{", "return", "iterator", ";", "}", "}", ";", "}" ]

[ "Iterate", "over", "keys", "within", "the", "passed", "range", "." ]

[ "public", "static", "byte", "[", "]", "[", "]", "toByteArrays", "(", "final", "String", "[", "]", "t", ")", "{", "byte", "[", "]", "[", "]", "result", "=", "new", "byte", "[", "t", ".", "length", "]", "[", "", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "t", ".", "length", ";", "i", "++", ")", "{", "result", "[", "i", "]", "=", "Bytes", ".", "toBytes", "(", "t", "[", "i", "]", ")", ";", "}", "return", "result", ";", "}" ]

[ "Returns", "an", "array", "of", "byte", "arrays", "made", "from", "passed", "array", "of", "Text", "." ]

[ "public", "static", "void", "writeStringFixedSize", "(", "final", "DataOutput", "out", ",", "String", "s", ",", "int", "size", ")", "throws", "IOException", "{", "byte", "[", "]", "b", "=", "toBytes", "(", "s", ")", ";", "if", "(", "b", ".", "length", ">", "size", ")", "{", "throw", "new", "IOException", "(", "\"Trying to write \"", "+", "b", ".", "length", "+", "\" bytes (\"", "+", "toStringBinary", "(", "b", ")", "+", "\") into a field of length \"", "+", "size", ")", ";", "}", "out", ".", "writeBytes", "(", "s", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", "-", "s", ".", "length", "(", ")", ";", "++", "i", ")", "{", "out", ".", "writeByte", "(", "0", ")", ";", "}", "}" ]

[ "Writes", "a", "string", "as", "a", "fixed", "-", "size", "field", "padded", "with", "zeros", "." ]

[ "private", "Filter", "createFilter", "(", ")", "{", "return", "new", "FilterList", "(", "FilterList", ".", "Operator", ".", "MUST_PASS_ONE", ",", "processedStateFilter", ",", "new", "SingleColumnValueFilter", "(", "QueueEntryRow", ".", "COLUMN_FAMILY", ",", "stateColumnName", ",", "CompareFilter", ".", "CompareOp", ".", "GREATER", ",", "new", "BinaryPrefixComparator", "(", "Bytes", ".", "toBytes", "(", "transaction", ".", "getReadPointer", "(", ")", ")", ")", ")", ")", ";", "}" ]

[ "Creates", "a", "HBase", "filter", "that", "will", "filter", "out", "rows", "that", "that", "has", "committed", "state", "=", "PROCESSED", "." ]

[ "public", "void", "invokeMethods", "(", "String", "queryName", ",", "GDATDecoder", "decoder", ")", "throws", "InvocationTargetException", ",", "IllegalAccessException", "{", "for", "(", "MethodInvoker", "methodInvoker", ":", "methodListMap", ".", "get", "(", "queryName", ")", ")", "{", "// Reset the position to 0 of the underlying ByteBuffer before calling MethodInvoker.invoke()", "decoder", ".", "reset", "(", ")", ";", "methodInvoker", ".", "invoke", "(", "decoder", ")", ";", "}", "}" ]

[ "This", "function", "invokes", "all", "the", "methods", "associated", "with", "the", "provided", "query", "name" ]

[ "public", "Map", ".", "Entry", "<", "String", ",", "GDATDecoder", ">", "getNext", "(", ")", "{", "Map", ".", "Entry", "<", "String", ",", "GDATDecoder", ">", "element", "=", "dataQueue", ".", "poll", "(", ")", ";", "pendingRecords", ".", "add", "(", "element", ")", ";", "return", "element", ";", "}" ]

[ "This", "function", "returns", "the", "next", "entry", "in", "the", "data", "queue", "and", "adds", "it", "to", "a", "queue", "of", "pending", "items", ".", "This", "pendingRecords", "serves", "as", "a", "place", "holder", "for", "all", "the", "items", "of", "the", "current", "transaction", "." ]

[ "public", "String", "getActualTableName", "(", "QueueName", "queueName", ")", "{", "if", "(", "queueName", ".", "isQueue", "(", ")", ")", "{", "// <tigon namespace>.system.queue.<account>.<flow>", "return", "getTableNameForFlow", "(", "queueName", ".", "getFirstComponent", "(", ")", ",", "queueName", ".", "getSecondComponent", "(", ")", ")", ";", "}", "else", "{", "throw", "new", "IllegalArgumentException", "(", "\"'\"", "+", "queueName", "+", "\"' is not a valid name for a queue.\"", ")", ";", "}", "}" ]

[ "This", "determines", "the", "actual", "table", "name", "from", "the", "table", "name", "prefix", "and", "the", "name", "of", "the", "queue", "." ]

[ "public", "static", "long", "generateConsumerGroupId", "(", "String", "flowId", ",", "String", "flowletId", ")", "{", "return", "Hashing", ".", "md5", "(", ")", ".", "newHasher", "(", ")", ".", "putString", "(", "flowId", ")", ".", "putString", "(", "flowletId", ")", ".", "hash", "(", ")", ".", "asLong", "(", ")", ";", "}" ]

[ "Generates", "a", "queue", "consumer", "groupId", "for", "the", "given", "flowlet", "in", "the", "given", "program", "id", "." ]

[ "public", "static", "Multimap", "<", "String", ",", "QueueName", ">", "configureQueue", "(", "Program", "program", ",", "FlowSpecification", "flowSpec", ",", "QueueAdmin", "queueAdmin", ")", "{", "// Generate all queues specifications", "Table", "<", "QueueSpecificationGenerator", ".", "Node", ",", "String", ",", "Set", "<", "QueueSpecification", ">", ">", "queueSpecs", "=", "new", "SimpleQueueSpecificationGenerator", "(", ")", ".", "create", "(", "flowSpec", ")", ";", "// For each queue in the flow, gather a map of consumer groupId to number of instances", "Table", "<", "QueueName", ",", "Long", ",", "Integer", ">", "queueConfigs", "=", "HashBasedTable", ".", "create", "(", ")", ";", "// For storing result from flowletId to queue.", "ImmutableSetMultimap", ".", "Builder", "<", "String", ",", "QueueName", ">", "resultBuilder", "=", "ImmutableSetMultimap", ".", "builder", "(", ")", ";", "// Loop through each flowlet", "for", "(", "Map", ".", "Entry", "<", "String", ",", "FlowletDefinition", ">", "entry", ":", "flowSpec", ".", "getFlowlets", "(", ")", ".", "entrySet", "(", ")", ")", "{", "String", "flowletId", "=", "entry", ".", "getKey", "(", ")", ";", "long", "groupId", "=", "FlowUtils", ".", "generateConsumerGroupId", "(", "program", ",", "flowletId", ")", ";", "int", "instances", "=", "entry", ".", "getValue", "(", ")", ".", "getInstances", "(", ")", ";", "// For each queue that the flowlet is a consumer, store the number of instances for this flowlet", "for", "(", "QueueSpecification", "queueSpec", ":", "Iterables", ".", "concat", "(", "queueSpecs", ".", "column", "(", "flowletId", ")", ".", "values", "(", ")", ")", ")", "{", "queueConfigs", ".", "put", "(", "queueSpec", ".", "getQueueName", "(", ")", ",", "groupId", ",", "instances", ")", ";", "resultBuilder", ".", "put", "(", "flowletId", ",", "queueSpec", ".", "getQueueName", "(", ")", ")", ";", "}", "}", "try", "{", "// For each queue in the flow, configure it through QueueAdmin", "for", "(", "Map", ".", "Entry", "<", "QueueName", ",", "Map", "<", "Long", ",", "Integer", ">", ">", "row", ":", "queueConfigs", ".", "rowMap", "(", ")", ".", "entrySet", "(", ")", ")", "{", "LOG", ".", "info", "(", "\"Queue config for {} : {}\"", ",", "row", ".", "getKey", "(", ")", ",", "row", ".", "getValue", "(", ")", ")", ";", "queueAdmin", ".", "configureGroups", "(", "row", ".", "getKey", "(", ")", ",", "row", ".", "getValue", "(", ")", ")", ";", "}", "return", "resultBuilder", ".", "build", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "\"Failed to configure queues\"", ",", "e", ")", ";", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Configures", "all", "queues", "being", "used", "in", "a", "flow", "." ]

[ "public", "void", "invoke", "(", "Decoder", "decoder", ")", "throws", "InvocationTargetException", ",", "IllegalAccessException", "{", "try", "{", "method", ".", "invoke", "(", "callingObject", ",", "pojoCreator", ".", "decode", "(", "decoder", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "LOG", ".", "error", "(", "\"Skipping invocation of method {}. Cannot instantiate parameter object of type {}\"", ",", "getMethodName", "(", ")", ",", "methodParameterClass", ".", "getName", "(", ")", ",", "e", ")", ";", "}", "}" ]

[ "This", "method", "instantiates", "an", "object", "of", "the", "method", "parameter", "type", "using", "the", "incoming", "decoder", "object", "and", "then", "invokes", "the", "associated", "method", "." ]

[ "private", "void", "writeLengthToStream", "(", "int", "length", ",", "OutputStream", "out", ")", "throws", "IOException", "{", "sharedByteBuffer", ".", "clear", "(", ")", ";", "sharedByteBuffer", ".", "order", "(", "ByteOrder", ".", "BIG_ENDIAN", ")", ".", "putInt", "(", "length", ")", ";", "sharedByteBuffer", ".", "flip", "(", ")", ";", "out", ".", "write", "(", "sharedByteBuffer", ".", "array", "(", ")", ",", "0", ",", "Ints", ".", "BYTES", ")", ";", "sharedByteBuffer", ".", "order", "(", "byteOrder", ")", ";", "}" ]

[ "Write", "Length", "in", "Big", "Endian", "Order", "as", "per", "GDAT", "format", "specification", "." ]

[ "public", "static", "QueueName", "from", "(", "byte", "[", "]", "bytes", ")", "{", "return", "new", "QueueName", "(", "URI", ".", "create", "(", "new", "String", "(", "bytes", ",", "Charsets", ".", "US_ASCII", ")", ")", ")", ";", "}" ]

[ "Constructs", "this", "class", "from", "byte", "array", "of", "queue", "URI", "." ]

[ "public", "static", "QueueName", "fromStream", "(", "String", "stream", ")", "{", "URI", "uri", "=", "URI", ".", "create", "(", "String", ".", "format", "(", "\"stream:///%s\"", ",", "stream", ")", ")", ";", "return", "new", "QueueName", "(", "uri", ")", ";", "}" ]

[ "Generates", "an", "QueueName", "for", "the", "stream", "." ]

[ "private", "void", "generateGetter", "(", "Field", "field", ")", "{", "if", "(", "isPrivate", ")", "{", "invokeReflection", "(", "getMethod", "(", "Object", ".", "class", ",", "\"get\"", ",", "Object", ".", "class", ")", ",", "getterSignature", "(", ")", ")", ";", "}", "else", "{", "directGetter", "(", "field", ")", ";", "}", "if", "(", "field", ".", "getType", "(", ")", ".", "isPrimitive", "(", ")", ")", "{", "primitiveGetter", "(", "field", ")", ";", "}", "}" ]

[ "Generates", "the", "getter", "method", "and", "optionally", "the", "primitive", "getter", "." ]

[ "private", "void", "generateSetter", "(", "Field", "field", ")", "{", "if", "(", "isPrivate", ")", "{", "invokeReflection", "(", "getMethod", "(", "void", ".", "class", ",", "\"set\"", ",", "Object", ".", "class", ",", "Object", ".", "class", ")", ",", "setterSignature", "(", ")", ")", ";", "}", "else", "{", "directSetter", "(", "field", ")", ";", "}", "if", "(", "field", ".", "getType", "(", ")", ".", "isPrimitive", "(", ")", ")", "{", "primitiveSetter", "(", "field", ")", ";", "}", "}" ]

[ "Generates", "the", "setter", "method", "and", "optionally", "the", "primitive", "setter", "." ]

[ "private", "void", "invokeReflection", "(", "Method", "method", ",", "String", "signature", ")", "{", "GeneratorAdapter", "mg", "=", "new", "GeneratorAdapter", "(", "Opcodes", ".", "ACC_PUBLIC", ",", "method", ",", "signature", ",", "new", "Type", "[", "0", "]", ",", "classWriter", ")", ";", "/**\n * try {\n * // Call method\n * } catch (IllegalAccessException e) {\n * throw Throwables.propagate(e);\n * }\n */", "Label", "beginTry", "=", "mg", ".", "newLabel", "(", ")", ";", "Label", "endTry", "=", "mg", ".", "newLabel", "(", ")", ";", "Label", "catchHandle", "=", "mg", ".", "newLabel", "(", ")", ";", "mg", ".", "visitTryCatchBlock", "(", "beginTry", ",", "endTry", ",", "catchHandle", ",", "Type", ".", "getInternalName", "(", "IllegalAccessException", ".", "class", ")", ")", ";", "mg", ".", "mark", "(", "beginTry", ")", ";", "mg", ".", "loadThis", "(", ")", ";", "mg", ".", "getField", "(", "Type", ".", "getObjectType", "(", "className", ")", ",", "\"field\"", ",", "Type", ".", "getType", "(", "Field", ".", "class", ")", ")", ";", "mg", ".", "loadArgs", "(", ")", ";", "mg", ".", "invokeVirtual", "(", "Type", ".", "getType", "(", "Field", ".", "class", ")", ",", "method", ")", ";", "mg", ".", "mark", "(", "endTry", ")", ";", "mg", ".", "returnValue", "(", ")", ";", "mg", ".", "mark", "(", "catchHandle", ")", ";", "int", "exception", "=", "mg", ".", "newLocal", "(", "Type", ".", "getType", "(", "IllegalAccessException", ".", "class", ")", ")", ";", "mg", ".", "storeLocal", "(", "exception", ")", ";", "mg", ".", "loadLocal", "(", "exception", ")", ";", "mg", ".", "invokeStatic", "(", "Type", ".", "getType", "(", "Throwables", ".", "class", ")", ",", "getMethod", "(", "RuntimeException", ".", "class", ",", "\"propagate\"", ",", "Throwable", ".", "class", ")", ")", ";", "mg", ".", "throwException", "(", ")", ";", "mg", ".", "endMethod", "(", ")", ";", "}" ]

[ "Generates", "the", "try", "-", "catch", "block", "that", "wrap", "around", "the", "given", "reflection", "method", "call", "." ]

[ "private", "void", "directGetter", "(", "Field", "field", ")", "{", "GeneratorAdapter", "mg", "=", "new", "GeneratorAdapter", "(", "Opcodes", ".", "ACC_PUBLIC", ",", "getMethod", "(", "Object", ".", "class", ",", "\"get\"", ",", "Object", ".", "class", ")", ",", "getterSignature", "(", ")", ",", "new", "Type", "[", "0", "]", ",", "classWriter", ")", ";", "// Simply access by field", "// return ((classType)object).fieldName;", "mg", ".", "loadArg", "(", "0", ")", ";", "mg", ".", "checkCast", "(", "Type", ".", "getType", "(", "field", ".", "getDeclaringClass", "(", ")", ")", ")", ";", "mg", ".", "getField", "(", "Type", ".", "getType", "(", "field", ".", "getDeclaringClass", "(", ")", ")", ",", "field", ".", "getName", "(", ")", ",", "Type", ".", "getType", "(", "field", ".", "getType", "(", ")", ")", ")", ";", "if", "(", "field", ".", "getType", "(", ")", ".", "isPrimitive", "(", ")", ")", "{", "mg", ".", "valueOf", "(", "Type", ".", "getType", "(", "field", ".", "getType", "(", ")", ")", ")", ";", "}", "mg", ".", "returnValue", "(", ")", ";", "mg", ".", "endMethod", "(", ")", ";", "}" ]

[ "Generates", "a", "getter", "that", "get", "the", "value", "by", "directly", "accessing", "the", "class", "field", "." ]

[ "private", "void", "directSetter", "(", "Field", "field", ")", "{", "GeneratorAdapter", "mg", "=", "new", "GeneratorAdapter", "(", "Opcodes", ".", "ACC_PUBLIC", ",", "getMethod", "(", "void", ".", "class", ",", "\"set\"", ",", "Object", ".", "class", ",", "Object", ".", "class", ")", ",", "setterSignature", "(", ")", ",", "new", "Type", "[", "0", "]", ",", "classWriter", ")", ";", "// Simply access by field", "// ((classType)object).fieldName = (valueType)value;", "mg", ".", "loadArg", "(", "0", ")", ";", "mg", ".", "checkCast", "(", "Type", ".", "getType", "(", "field", ".", "getDeclaringClass", "(", ")", ")", ")", ";", "mg", ".", "loadArg", "(", "1", ")", ";", "if", "(", "field", ".", "getType", "(", ")", ".", "isPrimitive", "(", ")", ")", "{", "mg", ".", "unbox", "(", "Type", ".", "getType", "(", "field", ".", "getType", "(", ")", ")", ")", ";", "}", "else", "{", "mg", ".", "checkCast", "(", "Type", ".", "getType", "(", "field", ".", "getType", "(", ")", ")", ")", ";", "}", "mg", ".", "putField", "(", "Type", ".", "getType", "(", "field", ".", "getDeclaringClass", "(", ")", ")", ",", "field", ".", "getName", "(", ")", ",", "Type", ".", "getType", "(", "field", ".", "getType", "(", ")", ")", ")", ";", "mg", ".", "returnValue", "(", ")", ";", "mg", ".", "endMethod", "(", ")", ";", "}" ]

[ "Generates", "a", "setter", "that", "set", "the", "value", "by", "directly", "accessing", "the", "class", "field", "." ]

[ "@", "Override", "public", "TransactionStateCache", "get", "(", ")", "{", "if", "(", "instance", "==", "null", ")", "{", "synchronized", "(", "lock", ")", "{", "if", "(", "instance", "==", "null", ")", "{", "instance", "=", "new", "DefaultTransactionStateCache", "(", "namespace", ")", ";", "instance", ".", "setConf", "(", "conf", ")", ";", "instance", ".", "start", "(", ")", ";", "}", "}", "}", "return", "instance", ";", "}" ]

[ "Returns", "a", "singleton", "instance", "of", "the", "transaction", "state", "cache", "performing", "lazy", "initialization", "if", "necessary", "." ]

[ "private", "MessageDigest", "updateHash", "(", "MessageDigest", "md5", ",", "Schema", "schema", ",", "Set", "<", "String", ">", "knownRecords", ")", "{", "// Don't use enum.ordinal() as ordering in enum could change", "switch", "(", "schema", ".", "getType", "(", ")", ")", "{", "case", "NULL", ":", "md5", ".", "update", "(", "(", "byte", ")", "0", ")", ";", "break", ";", "case", "BOOLEAN", ":", "md5", ".", "update", "(", "(", "byte", ")", "1", ")", ";", "break", ";", "case", "INT", ":", "md5", ".", "update", "(", "(", "byte", ")", "2", ")", ";", "break", ";", "case", "LONG", ":", "md5", ".", "update", "(", "(", "byte", ")", "3", ")", ";", "break", ";", "case", "FLOAT", ":", "md5", ".", "update", "(", "(", "byte", ")", "4", ")", ";", "break", ";", "case", "DOUBLE", ":", "md5", ".", "update", "(", "(", "byte", ")", "5", ")", ";", "break", ";", "case", "BYTES", ":", "md5", ".", "update", "(", "(", "byte", ")", "6", ")", ";", "break", ";", "case", "STRING", ":", "md5", ".", "update", "(", "(", "byte", ")", "7", ")", ";", "break", ";", "case", "ENUM", ":", "md5", ".", "update", "(", "(", "byte", ")", "8", ")", ";", "for", "(", "String", "value", ":", "schema", ".", "getEnumValues", "(", ")", ")", "{", "md5", ".", "update", "(", "Charsets", ".", "UTF_8", ".", "encode", "(", "value", ")", ")", ";", "}", "break", ";", "case", "ARRAY", ":", "md5", ".", "update", "(", "(", "byte", ")", "9", ")", ";", "updateHash", "(", "md5", ",", "schema", ".", "getComponentSchema", "(", ")", ",", "knownRecords", ")", ";", "break", ";", "case", "MAP", ":", "md5", ".", "update", "(", "(", "byte", ")", "10", ")", ";", "updateHash", "(", "md5", ",", "schema", ".", "getMapSchema", "(", ")", ".", "getKey", "(", ")", ",", "knownRecords", ")", ";", "updateHash", "(", "md5", ",", "schema", ".", "getMapSchema", "(", ")", ".", "getValue", "(", ")", ",", "knownRecords", ")", ";", "break", ";", "case", "RECORD", ":", "md5", ".", "update", "(", "(", "byte", ")", "11", ")", ";", "boolean", "notKnown", "=", "knownRecords", ".", "add", "(", "schema", ".", "getRecordName", "(", ")", ")", ";", "for", "(", "Schema", ".", "Field", "field", ":", "schema", ".", "getFields", "(", ")", ")", "{", "md5", ".", "update", "(", "Charsets", ".", "UTF_8", ".", "encode", "(", "field", ".", "getName", "(", ")", ")", ")", ";", "if", "(", "notKnown", ")", "{", "updateHash", "(", "md5", ",", "field", ".", "getSchema", "(", ")", ",", "knownRecords", ")", ";", "}", "}", "break", ";", "case", "UNION", ":", "md5", ".", "update", "(", "(", "byte", ")", "12", ")", ";", "for", "(", "Schema", "unionSchema", ":", "schema", ".", "getUnionSchemas", "(", ")", ")", "{", "updateHash", "(", "md5", ",", "unionSchema", ",", "knownRecords", ")", ";", "}", "break", ";", "}", "return", "md5", ";", "}" ]

[ "Updates", "md5", "based", "on", "the", "given", "schema", "." ]

[ "private", "Method", "getEncodeMethod", "(", "TypeToken", "<", "?", ">", "outputType", ",", "Schema", "schema", ")", "{", "String", "key", "=", "String", ".", "format", "(", "\"%s%s\"", ",", "normalizeTypeName", "(", "outputType", ")", ",", "schema", ".", "getSchemaHash", "(", ")", ")", ";", "Method", "method", "=", "encodeMethods", ".", "get", "(", "key", ")", ";", "if", "(", "method", "!=", "null", ")", "{", "return", "method", ";", "}", "// Generate the encode method (value, encoder, schema, set)", "TypeToken", "<", "?", ">", "callOutputType", "=", "getCallTypeToken", "(", "outputType", ",", "schema", ")", ";", "String", "methodName", "=", "String", ".", "format", "(", "\"encode%s\"", ",", "key", ")", ";", "method", "=", "getMethod", "(", "void", ".", "class", ",", "methodName", ",", "callOutputType", ".", "getRawType", "(", ")", ",", "Encoder", ".", "class", ",", "Schema", ".", "class", ",", "Set", ".", "class", ")", ";", "// Put the method into map first before generating the body in order to support recursive data type.", "encodeMethods", ".", "put", "(", "key", ",", "method", ")", ";", "String", "methodSignature", "=", "Signatures", ".", "getMethodSignature", "(", "method", ",", "new", "TypeToken", "[", "]", "{", "callOutputType", ",", "null", ",", "null", ",", "new", "TypeToken", "<", "Set", "<", "Object", ">", ">", "(", ")", "{", "}", "}", ")", ";", "GeneratorAdapter", "mg", "=", "new", "GeneratorAdapter", "(", "Opcodes", ".", "ACC_PRIVATE", ",", "method", ",", "methodSignature", ",", "new", "Type", "[", "]", "{", "Type", ".", "getType", "(", "IOException", ".", "class", ")", "}", ",", "classWriter", ")", ";", "generateEncodeBody", "(", "mg", ",", "schema", ",", "outputType", ",", "0", ",", "1", ",", "2", ",", "3", ")", ";", "mg", ".", "returnValue", "(", ")", ";", "mg", ".", "endMethod", "(", ")", ";", "return", "method", ";", "}" ]

[ "Returns", "the", "encode", "method", "for", "the", "given", "type", "and", "schema", ".", "The", "same", "method", "will", "be", "returned", "if", "the", "same", "type", "and", "schema", "has", "been", "passed", "to", "the", "method", "before", "." ]

[ "private", "void", "generateEncodeBody", "(", "GeneratorAdapter", "mg", ",", "Schema", "schema", ",", "TypeToken", "<", "?", ">", "outputType", ",", "int", "value", ",", "int", "encoder", ",", "int", "schemaLocal", ",", "int", "seenRefs", ")", "{", "Schema", ".", "Type", "schemaType", "=", "schema", ".", "getType", "(", ")", ";", "switch", "(", "schemaType", ")", "{", "case", "NULL", ":", "break", ";", "case", "BOOLEAN", ":", "encodeSimple", "(", "mg", ",", "outputType", ",", "schema", ",", "\"writeBool\"", ",", "value", ",", "encoder", ")", ";", "break", ";", "case", "INT", ":", "case", "LONG", ":", "case", "FLOAT", ":", "case", "DOUBLE", ":", "case", "BYTES", ":", "case", "STRING", ":", "String", "encodeMethod", "=", "\"write\"", "+", "schemaType", ".", "name", "(", ")", ".", "charAt", "(", "0", ")", "+", "schemaType", ".", "name", "(", ")", ".", "substring", "(", "1", ")", ".", "toLowerCase", "(", ")", ";", "encodeSimple", "(", "mg", ",", "outputType", ",", "schema", ",", "encodeMethod", ",", "value", ",", "encoder", ")", ";", "break", ";", "case", "ENUM", ":", "encodeEnum", "(", "mg", ",", "outputType", ",", "value", ",", "encoder", ",", "schemaLocal", ")", ";", "break", ";", "case", "ARRAY", ":", "if", "(", "Collection", ".", "class", ".", "isAssignableFrom", "(", "outputType", ".", "getRawType", "(", ")", ")", ")", "{", "Preconditions", ".", "checkArgument", "(", "outputType", ".", "getType", "(", ")", "instanceof", "ParameterizedType", ",", "\"Only support parameterized collection type.\"", ")", ";", "TypeToken", "<", "?", ">", "componentType", "=", "TypeToken", ".", "of", "(", "(", "(", "ParameterizedType", ")", "outputType", ".", "getType", "(", ")", ")", ".", "getActualTypeArguments", "(", ")", "[", "0", "]", ")", ";", "encodeCollection", "(", "mg", ",", "componentType", ",", "schema", ".", "getComponentSchema", "(", ")", ",", "value", ",", "encoder", ",", "schemaLocal", ",", "seenRefs", ")", ";", "}", "else", "if", "(", "outputType", ".", "isArray", "(", ")", ")", "{", "TypeToken", "<", "?", ">", "componentType", "=", "outputType", ".", "getComponentType", "(", ")", ";", "encodeArray", "(", "mg", ",", "componentType", ",", "schema", ".", "getComponentSchema", "(", ")", ",", "value", ",", "encoder", ",", "schemaLocal", ",", "seenRefs", ")", ";", "}", "break", ";", "case", "MAP", ":", "Preconditions", ".", "checkArgument", "(", "Map", ".", "class", ".", "isAssignableFrom", "(", "outputType", ".", "getRawType", "(", ")", ")", ",", "\"Only %s type is supported.\"", ",", "Map", ".", "class", ".", "getName", "(", ")", ")", ";", "Preconditions", ".", "checkArgument", "(", "outputType", ".", "getType", "(", ")", "instanceof", "ParameterizedType", ",", "\"Only support parameterized map type.\"", ")", ";", "java", ".", "lang", ".", "reflect", ".", "Type", "[", "]", "mapArgs", "=", "(", "(", "ParameterizedType", ")", "outputType", ".", "getType", "(", ")", ")", ".", "getActualTypeArguments", "(", ")", ";", "Map", ".", "Entry", "<", "Schema", ",", "Schema", ">", "mapSchema", "=", "schema", ".", "getMapSchema", "(", ")", ";", "encodeMap", "(", "mg", ",", "TypeToken", ".", "of", "(", "mapArgs", "[", "0", "]", ")", ",", "TypeToken", ".", "of", "(", "mapArgs", "[", "1", "]", ")", ",", "mapSchema", ".", "getKey", "(", ")", ",", "mapSchema", ".", "getValue", "(", ")", ",", "value", ",", "encoder", ",", "schemaLocal", ",", "seenRefs", ")", ";", "break", ";", "case", "RECORD", ":", "encodeRecord", "(", "mg", ",", "schema", ",", "outputType", ",", "value", ",", "encoder", ",", "schemaLocal", ",", "seenRefs", ")", ";", "break", ";", "case", "UNION", ":", "encodeUnion", "(", "mg", ",", "outputType", ",", "schema", ",", "value", ",", "encoder", ",", "schemaLocal", ",", "seenRefs", ")", ";", "break", ";", "}", "}" ]

[ "Generates", "the", "encode", "method", "body", "with", "the", "binary", "encoder", "given", "in", "the", "local", "variable", "." ]

[ "private", "void", "encodeInt", "(", "GeneratorAdapter", "mg", ",", "int", "intValue", ",", "int", "encoder", ")", "{", "mg", ".", "loadArg", "(", "encoder", ")", ";", "mg", ".", "push", "(", "intValue", ")", ";", "mg", ".", "invokeInterface", "(", "Type", ".", "getType", "(", "Encoder", ".", "class", ")", ",", "getMethod", "(", "Encoder", ".", "class", ",", "\"writeInt\"", ",", "int", ".", "class", ")", ")", ";", "mg", ".", "pop", "(", ")", ";", "}" ]

[ "Generates", "method", "body", "for", "encoding", "an", "compile", "time", "int", "value", "." ]

[ "private", "void", "encodeSimple", "(", "GeneratorAdapter", "mg", ",", "TypeToken", "<", "?", ">", "type", ",", "Schema", "schema", ",", "String", "encodeMethod", ",", "int", "value", ",", "int", "encoder", ")", "{", "// encoder.writeXXX(value);", "TypeToken", "<", "?", ">", "encodeType", "=", "type", ";", "mg", ".", "loadArg", "(", "encoder", ")", ";", "mg", ".", "loadArg", "(", "value", ")", ";", "if", "(", "Primitives", ".", "isWrapperType", "(", "encodeType", ".", "getRawType", "(", ")", ")", ")", "{", "encodeType", "=", "TypeToken", ".", "of", "(", "Primitives", ".", "unwrap", "(", "encodeType", ".", "getRawType", "(", ")", ")", ")", ";", "mg", ".", "unbox", "(", "Type", ".", "getType", "(", "encodeType", ".", "getRawType", "(", ")", ")", ")", ";", "// A special case since INT type represents (byte, char, short and int).", "if", "(", "schema", ".", "getType", "(", ")", "==", "Schema", ".", "Type", ".", "INT", "&&", "!", "int", ".", "class", ".", "equals", "(", "encodeType", ".", "getRawType", "(", ")", ")", ")", "{", "encodeType", "=", "TypeToken", ".", "of", "(", "int", ".", "class", ")", ";", "}", "}", "else", "if", "(", "schema", ".", "getType", "(", ")", "==", "Schema", ".", "Type", ".", "STRING", "&&", "!", "String", ".", "class", ".", "equals", "(", "encodeType", ".", "getRawType", "(", ")", ")", ")", "{", "// For non-string object that has a String schema, invoke toString().", "mg", ".", "invokeVirtual", "(", "Type", ".", "getType", "(", "encodeType", ".", "getRawType", "(", ")", ")", ",", "getMethod", "(", "String", ".", "class", ",", "\"toString\"", ")", ")", ";", "encodeType", "=", "TypeToken", ".", "of", "(", "String", ".", "class", ")", ";", "}", "else", "if", "(", "schema", ".", "getType", "(", ")", "==", "Schema", ".", "Type", ".", "BYTES", "&&", "UUID", ".", "class", ".", "equals", "(", "encodeType", ".", "getRawType", "(", ")", ")", ")", "{", "// Special case UUID, encode as byte array", "// ByteBuffer buf = ByteBuffer.allocate(Longs.BYTES * 2)", "// .putLong(uuid.getMostSignificantBits())", "// .putLong(uuid.getLeastSignificantBits());", "// encoder.writeBytes((ByteBuffer) buf.flip());", "Type", "byteBufferType", "=", "Type", ".", "getType", "(", "ByteBuffer", ".", "class", ")", ";", "Type", "uuidType", "=", "Type", ".", "getType", "(", "UUID", ".", "class", ")", ";", "mg", ".", "push", "(", "Longs", ".", "BYTES", "*", "2", ")", ";", "mg", ".", "invokeStatic", "(", "byteBufferType", ",", "getMethod", "(", "ByteBuffer", ".", "class", ",", "\"allocate\"", ",", "int", ".", "class", ")", ")", ";", "mg", ".", "swap", "(", ")", ";", "mg", ".", "invokeVirtual", "(", "uuidType", ",", "getMethod", "(", "long", ".", "class", ",", "\"getMostSignificantBits\"", ")", ")", ";", "mg", ".", "invokeVirtual", "(", "byteBufferType", ",", "getMethod", "(", "ByteBuffer", ".", "class", ",", "\"putLong\"", ",", "long", ".", "class", ")", ")", ";", "mg", ".", "loadArg", "(", "value", ")", ";", "mg", ".", "invokeVirtual", "(", "uuidType", ",", "getMethod", "(", "long", ".", "class", ",", "\"getLeastSignificantBits\"", ")", ")", ";", "mg", ".", "invokeVirtual", "(", "byteBufferType", ",", "getMethod", "(", "ByteBuffer", ".", "class", ",", "\"putLong\"", ",", "long", ".", "class", ")", ")", ";", "mg", ".", "invokeVirtual", "(", "Type", ".", "getType", "(", "Buffer", ".", "class", ")", ",", "getMethod", "(", "Buffer", ".", "class", ",", "\"flip\"", ")", ")", ";", "mg", ".", "checkCast", "(", "byteBufferType", ")", ";", "encodeType", "=", "TypeToken", ".", "of", "(", "ByteBuffer", ".", "class", ")", ";", "}", "mg", ".", "invokeInterface", "(", "Type", ".", "getType", "(", "Encoder", ".", "class", ")", ",", "getMethod", "(", "Encoder", ".", "class", ",", "encodeMethod", ",", "encodeType", ".", "getRawType", "(", ")", ")", ")", ";", "mg", ".", "pop", "(", ")", ";", "}" ]

[ "Generates", "method", "body", "for", "encoding", "simple", "schema", "type", "by", "calling", "corresponding", "write", "method", "in", "Encoder", "." ]

[ "private", "void", "encodeEnum", "(", "GeneratorAdapter", "mg", ",", "TypeToken", "<", "?", ">", "outputType", ",", "int", "value", ",", "int", "encoder", ",", "int", "schemaLocal", ")", "{", "// encoder.writeInt(this.schema.getEnumIndex(value.name()));", "mg", ".", "loadArg", "(", "encoder", ")", ";", "mg", ".", "loadArg", "(", "schemaLocal", ")", ";", "mg", ".", "loadArg", "(", "value", ")", ";", "mg", ".", "invokeVirtual", "(", "Type", ".", "getType", "(", "outputType", ".", "getRawType", "(", ")", ")", ",", "getMethod", "(", "String", ".", "class", ",", "\"name\"", ")", ")", ";", "mg", ".", "invokeVirtual", "(", "Type", ".", "getType", "(", "Schema", ".", "class", ")", ",", "getMethod", "(", "int", ".", "class", ",", "\"getEnumIndex\"", ",", "String", ".", "class", ")", ")", ";", "mg", ".", "invokeInterface", "(", "Type", ".", "getType", "(", "Encoder", ".", "class", ")", ",", "getMethod", "(", "Encoder", ".", "class", ",", "\"writeInt\"", ",", "int", ".", "class", ")", ")", ";", "mg", ".", "pop", "(", ")", ";", "}" ]

[ "Generates", "method", "body", "for", "encoding", "enum", "value", "." ]

[ "private", "TypeToken", "<", "?", ">", "getCallTypeToken", "(", "TypeToken", "<", "?", ">", "outputType", ",", "Schema", "schema", ")", "{", "Schema", ".", "Type", "schemaType", "=", "schema", ".", "getType", "(", ")", ";", "if", "(", "schemaType", "==", "Schema", ".", "Type", ".", "RECORD", "||", "schemaType", "==", "Schema", ".", "Type", ".", "UNION", ")", "{", "return", "TypeToken", ".", "of", "(", "Object", ".", "class", ")", ";", "}", "if", "(", "schemaType", "==", "Schema", ".", "Type", ".", "ARRAY", "&&", "outputType", ".", "isArray", "(", ")", ")", "{", "return", "getArrayType", "(", "getCallTypeToken", "(", "outputType", ".", "getComponentType", "(", ")", ",", "schema", ".", "getComponentSchema", "(", ")", ")", ")", ";", "}", "return", "outputType", ";", "}" ]

[ "Returns", "the", "type", "to", "be", "used", "on", "the", "encode", "method", ".", "This", "is", "needed", "to", "work", "with", "private", "classes", "that", "the", "generated", "DatumWriter", "doesn", "t", "have", "access", "to", "." ]

[ "private", "synchronized", "void", "changeInstances", "(", "String", "flowletId", ",", "int", "newInstanceCount", ",", "int", "oldInstanceCount", ")", "throws", "Exception", "{", "instanceUpdater", ".", "update", "(", "flowletId", ",", "newInstanceCount", ",", "oldInstanceCount", ")", ";", "}" ]

[ "Change", "the", "number", "of", "instances", "of", "the", "running", "flowlet", ".", "Notice", "that", "this", "method", "needs", "to", "be", "synchronized", "as", "change", "of", "instances", "involves", "multiple", "steps", "that", "need", "to", "be", "completed", "all", "at", "once", "." ]

[ "public", "ImmutableSet", "<", "ClassInfo", ">", "getTopLevelClasses", "(", ")", "{", "return", "FluentIterable", ".", "from", "(", "resources", ")", ".", "filter", "(", "ClassInfo", ".", "class", ")", ".", "filter", "(", "IS_TOP_LEVEL", ")", ".", "toImmutableSet", "(", ")", ";", "}" ]

[ "Returns", "all", "top", "level", "classes", "loadable", "from", "the", "current", "class", "path", "." ]

[ "private", "Service", "createServiceHook", "(", "String", "flowletName", ",", "Iterable", "<", "ConsumerSupplier", "<", "?", ">", ">", "consumerSuppliers", ",", "AtomicReference", "<", "FlowletProgramController", ">", "controller", ")", "{", "final", "List", "<", "String", ">", "streams", "=", "Lists", ".", "newArrayList", "(", ")", ";", "for", "(", "ConsumerSupplier", "<", "?", ">", "consumerSupplier", ":", "consumerSuppliers", ")", "{", "QueueName", "queueName", "=", "consumerSupplier", ".", "getQueueName", "(", ")", ";", "if", "(", "queueName", ".", "isStream", "(", ")", ")", "{", "streams", ".", "add", "(", "queueName", ".", "getSimpleName", "(", ")", ")", ";", "}", "}", "// If no stream, returns a no-op Service", "if", "(", "streams", ".", "isEmpty", "(", ")", ")", "{", "return", "new", "AbstractService", "(", ")", "{", "@", "Override", "protected", "void", "doStart", "(", ")", "{", "notifyStarted", "(", ")", ";", "}", "@", "Override", "protected", "void", "doStop", "(", ")", "{", "notifyStopped", "(", ")", ";", "}", "}", ";", "}", "return", "new", "FlowletServiceHook", "(", "flowletName", ",", "streams", ",", "controller", ")", ";", "}" ]

[ "Create", "a", "initializer", "to", "be", "executed", "during", "the", "flowlet", "driver", "initialization", "." ]

[ "public", "static", "Manifest", "getManifestWithMainClass", "(", "Class", "<", "?", ">", "klass", ")", "{", "Manifest", "manifest", "=", "new", "Manifest", "(", ")", ";", "manifest", ".", "getMainAttributes", "(", ")", ".", "put", "(", "ManifestFields", ".", "MANIFEST_VERSION", ",", "\"1.0\"", ")", ";", "manifest", ".", "getMainAttributes", "(", ")", ".", "put", "(", "ManifestFields", ".", "MAIN_CLASS", ",", "klass", ".", "getName", "(", ")", ")", ";", "return", "manifest", ";", "}" ]

[ "Given", "a", "class", "generates", "a", "manifest", "file", "with", "main", "-", "class", "as", "class", "." ]

[ "public", "static", "Map", "<", "String", ",", "String", ">", "fromPosixArray", "(", "Iterable", "<", "String", ">", "args", ")", "{", "Map", "<", "String", ",", "String", ">", "kvMap", "=", "Maps", ".", "newHashMap", "(", ")", ";", "for", "(", "String", "arg", ":", "args", ")", "{", "kvMap", ".", "putAll", "(", "Splitter", ".", "on", "(", "\"--\"", ")", ".", "omitEmptyStrings", "(", ")", ".", "trimResults", "(", ")", ".", "withKeyValueSeparator", "(", "\"=\"", ")", ".", "split", "(", "arg", ")", ")", ";", "}", "return", "kvMap", ";", "}" ]

[ "Converts", "a", "POSIX", "compliant", "program", "argument", "array", "to", "a", "String", "-", "to", "-", "String", "Map", "." ]

[ "public", "CConfiguration", "read", "(", "Type", "type", ",", "String", "namespace", ")", "throws", "IOException", "{", "String", "tableName", "=", "getTableName", "(", "namespace", ")", ";", "CConfiguration", "conf", "=", "null", ";", "HTable", "table", "=", "null", ";", "try", "{", "table", "=", "new", "HTable", "(", "hbaseConf", ",", "tableName", ")", ";", "Get", "get", "=", "new", "Get", "(", "Bytes", ".", "toBytes", "(", "type", ".", "name", "(", ")", ")", ")", ";", "get", ".", "addFamily", "(", "FAMILY", ")", ";", "Result", "result", "=", "table", ".", "get", "(", "get", ")", ";", "int", "propertyCnt", "=", "0", ";", "if", "(", "result", "!=", "null", "&&", "!", "result", ".", "isEmpty", "(", ")", ")", "{", "conf", "=", "CConfiguration", ".", "create", "(", ")", ";", "conf", ".", "clear", "(", ")", ";", "Map", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", "kvs", "=", "result", ".", "getFamilyMap", "(", "FAMILY", ")", ";", "for", "(", "Map", ".", "Entry", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", "e", ":", "kvs", ".", "entrySet", "(", ")", ")", "{", "conf", ".", "set", "(", "Bytes", ".", "toString", "(", "e", ".", "getKey", "(", ")", ")", ",", "Bytes", ".", "toString", "(", "e", ".", "getValue", "(", ")", ")", ")", ";", "propertyCnt", "++", ";", "}", "}", "LOG", ".", "info", "(", "\"Read \"", "+", "propertyCnt", "+", "\" properties from configuration table = \"", "+", "tableName", "+", "\", row = \"", "+", "type", ".", "name", "(", ")", ")", ";", "}", "catch", "(", "TableNotFoundException", "e", ")", "{", "// it's expected that this may occur when tables are created before Tigon has started", "LOG", ".", "warn", "(", "\"Configuration table \"", "+", "tableName", "+", "\" does not yet exist.\"", ")", ";", "}", "finally", "{", "if", "(", "table", "!=", "null", ")", "{", "try", "{", "table", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "ioe", ")", "{", "LOG", ".", "error", "(", "\"Error closing HTable for \"", "+", "tableName", ",", "ioe", ")", ";", "}", "}", "}", "return", "conf", ";", "}" ]

[ "Reads", "the", "given", "configuration", "type", "from", "the", "HBase", "table", "looking", "for", "the", "HBase", "table", "name", "under", "the", "given", "namespace", "." ]

[ "protected", "final", "void", "setSystemTag", "(", "String", "name", ",", "String", "value", ")", "{", "systemTags", ".", "put", "(", "name", ",", "new", "SystemTagImpl", "(", "name", ",", "value", ")", ")", ";", "}" ]

[ "Sets", "system", "tag", "." ]

[ "public", "static", "int", "getRandomPort", "(", ")", "{", "try", "{", "ServerSocket", "socket", "=", "new", "ServerSocket", "(", "0", ")", ";", "try", "{", "return", "socket", ".", "getLocalPort", "(", ")", ";", "}", "finally", "{", "socket", ".", "close", "(", ")", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "return", "-", "1", ";", "}", "}" ]

[ "Find", "a", "random", "free", "port", "in", "localhost", "for", "binding", "." ]

[ "public", "synchronized", "void", "updateCache", "(", ")", "{", "Map", "<", "byte", "[", "]", ",", "QueueConsumerConfig", ">", "newCache", "=", "Maps", ".", "newTreeMap", "(", "Bytes", ".", "BYTES_COMPARATOR", ")", ";", "long", "now", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "HTable", "table", "=", "null", ";", "try", "{", "table", "=", "new", "HTable", "(", "hConf", ",", "configTableName", ")", ";", "Scan", "scan", "=", "new", "Scan", "(", ")", ";", "scan", ".", "addFamily", "(", "QueueEntryRow", ".", "COLUMN_FAMILY", ")", ";", "ResultScanner", "scanner", "=", "table", ".", "getScanner", "(", "scan", ")", ";", "int", "configCnt", "=", "0", ";", "for", "(", "Result", "result", ":", "scanner", ")", "{", "if", "(", "!", "result", ".", "isEmpty", "(", ")", ")", "{", "NavigableMap", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", "familyMap", "=", "result", ".", "getFamilyMap", "(", "QueueEntryRow", ".", "COLUMN_FAMILY", ")", ";", "if", "(", "familyMap", "!=", "null", ")", "{", "configCnt", "++", ";", "Map", "<", "ConsumerInstance", ",", "byte", "[", "]", ">", "consumerInstances", "=", "new", "HashMap", "<", "ConsumerInstance", ",", "byte", "[", "]", ">", "(", ")", ";", "// Gather the startRow of all instances across all consumer groups.", "int", "numGroups", "=", "0", ";", "Long", "groupId", "=", "null", ";", "for", "(", "Map", ".", "Entry", "<", "byte", "[", "]", ",", "byte", "[", "]", ">", "entry", ":", "familyMap", ".", "entrySet", "(", ")", ")", "{", "long", "gid", "=", "Bytes", ".", "toLong", "(", "entry", ".", "getKey", "(", ")", ")", ";", "int", "instanceId", "=", "Bytes", ".", "toInt", "(", "entry", ".", "getKey", "(", ")", ",", "LONG_BYTES", ")", ";", "consumerInstances", ".", "put", "(", "new", "ConsumerInstance", "(", "gid", ",", "instanceId", ")", ",", "entry", ".", "getValue", "(", ")", ")", ";", "// Columns are sorted by groupId, hence if it change, then numGroups would get +1", "if", "(", "groupId", "==", "null", "||", "groupId", "!=", "gid", ")", "{", "numGroups", "++", ";", "groupId", "=", "gid", ";", "}", "}", "byte", "[", "]", "queueName", "=", "result", ".", "getRow", "(", ")", ";", "newCache", ".", "put", "(", "queueName", ",", "new", "QueueConsumerConfig", "(", "consumerInstances", ",", "numGroups", ")", ")", ";", "}", "}", "}", "long", "elapsed", "=", "System", ".", "currentTimeMillis", "(", ")", "-", "now", ";", "this", ".", "configCache", "=", "newCache", ";", "this", ".", "lastUpdated", "=", "now", ";", "if", "(", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "LOG", ".", "debug", "(", "\"Updated consumer config cache with {} entries, took {} msec\"", ",", "configCnt", ",", "elapsed", ")", ";", "}", "}", "catch", "(", "IOException", "ioe", ")", "{", "LOG", ".", "warn", "(", "\"Error updating queue consumer config cache: {}\"", ",", "ioe", ".", "getMessage", "(", ")", ")", ";", "}", "finally", "{", "if", "(", "table", "!=", "null", ")", "{", "try", "{", "table", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "ioe", ")", "{", "LOG", ".", "error", "(", "\"Error closing table {}\"", ",", "Bytes", ".", "toString", "(", "configTableName", ")", ",", "ioe", ")", ";", "}", "}", "}", "}" ]

[ "This", "forces", "an", "immediate", "update", "of", "the", "config", "cache", ".", "It", "should", "only", "be", "called", "from", "the", "refresh", "thread", "or", "from", "tests", "to", "avoid", "having", "to", "add", "a", "sleep", "for", "the", "duration", "of", "the", "refresh", "interval", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "private", "void", "setValue", "(", "Object", "instance", ",", "Field", "field", ",", "String", "value", ")", "throws", "IllegalAccessException", "{", "if", "(", "!", "field", ".", "isAccessible", "(", ")", ")", "{", "field", ".", "setAccessible", "(", "true", ")", ";", "}", "Class", "<", "?", ">", "fieldType", "=", "field", ".", "getType", "(", ")", ";", "// Currently only String, primitive (or boxed type) and Enum type are supported.", "if", "(", "String", ".", "class", ".", "equals", "(", "fieldType", ")", ")", "{", "field", ".", "set", "(", "instance", ",", "value", ")", ";", "return", ";", "}", "if", "(", "fieldType", ".", "isEnum", "(", ")", ")", "{", "field", ".", "set", "(", "instance", ",", "Enum", ".", "valueOf", "(", "(", "Class", "<", "?", "extends", "Enum", ">", ")", "fieldType", ",", "value", ")", ")", ";", "return", ";", "}", "if", "(", "fieldType", ".", "isPrimitive", "(", ")", ")", "{", "fieldType", "=", "com", ".", "google", ".", "common", ".", "primitives", ".", "Primitives", ".", "wrap", "(", "fieldType", ")", ";", "}", "try", "{", "// All box type has the valueOf(String) method.", "field", ".", "set", "(", "instance", ",", "fieldType", ".", "getMethod", "(", "\"valueOf\"", ",", "String", ".", "class", ")", ".", "invoke", "(", "null", ",", "value", ")", ")", ";", "}", "catch", "(", "NoSuchMethodException", "e", ")", "{", "// Should never happen, as boxed type always have the valueOf(String) method.", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "catch", "(", "InvocationTargetException", "e", ")", "{", "// Also should never happen, as calling method on Java bootstrap classes should always succeed.", "throw", "Throwables", ".", "propagate", "(", "e", ")", ";", "}", "}" ]

[ "Sets", "the", "value", "of", "the", "field", "in", "the", "given", "instance", "by", "converting", "the", "value", "from", "String", "to", "the", "field", "type", ".", "Currently", "only", "allows", "primitive", "types", "boxed", "types", "String", "and", "Enum", "." ]

[ "@", "Override", "protected", "void", "startUp", "(", ")", "{", "try", "{", "startRTS", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cannot initiate RTS. Missing or bad arguments\"", ")", ";", "}", "try", "{", "startHFTA", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cannot initiate HFTA processes. Missing or bad arguments\"", ")", ";", "}", "try", "{", "startGSEXIT", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cannot initiate GSEXIT processes. Missing or bad arguments\"", ")", ";", "}", "}" ]

[ "Sequentially", "invokes", "the", "required", "Streaming", "Engine", "processes", "." ]

[ "public", "void", "startRTS", "(", ")", "throws", "IOException", "{", "List", "<", "HubDataSource", ">", "dataSources", "=", "hubDataStore", ".", "getHubDataSources", "(", ")", ";", "List", "<", "String", ">", "com", "=", "Lists", ".", "newArrayList", "(", ")", ";", "com", ".", "add", "(", "getHostPort", "(", "hubDataStore", ".", "getHubAddress", "(", ")", ")", ")", ";", "com", ".", "add", "(", "hubDataStore", ".", "getInstanceName", "(", ")", ")", ";", "for", "(", "HubDataSource", "source", ":", "dataSources", ")", "{", "com", ".", "add", "(", "source", ".", "getName", "(", ")", ")", ";", "}", "ExternalProgramExecutor", "executorService", "=", "new", "ExternalProgramExecutor", "(", "\"RTS\"", ",", "new", "File", "(", "binLocation", ",", "\"rts\"", ")", ",", "com", ".", "toArray", "(", "new", "String", "[", "com", ".", "size", "(", ")", "]", ")", ")", ";", "rtsExecutor", ".", "add", "(", "executorService", ")", ";", "LOG", ".", "info", "(", "\"Starting RTS : {}\"", ",", "executorService", ")", ";", "executorService", ".", "startAndWait", "(", ")", ";", "}" ]

[ "Starts", "RTS", "process", "." ]

[ "public", "void", "startHFTA", "(", ")", "throws", "IOException", "{", "int", "hftaCount", "=", "MetaInformationParser", ".", "getHFTACount", "(", "new", "File", "(", "this", ".", "hubDataStore", ".", "getBinaryLocation", "(", ")", ".", "toURI", "(", ")", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "hftaCount", ";", "i", "++", ")", "{", "List", "<", "String", ">", "com", "=", "Lists", ".", "newArrayList", "(", ")", ";", "com", ".", "add", "(", "getHostPort", "(", "hubDataStore", ".", "getHubAddress", "(", ")", ")", ")", ";", "com", ".", "add", "(", "hubDataStore", ".", "getInstanceName", "(", ")", ")", ";", "ExternalProgramExecutor", "executorService", "=", "new", "ExternalProgramExecutor", "(", "\"HFTA-\"", "+", "i", ",", "new", "File", "(", "binLocation", ",", "\"hfta_\"", "+", "i", ")", ",", "com", ".", "toArray", "(", "new", "String", "[", "com", ".", "size", "(", ")", "]", ")", ")", ";", "hftaExecutor", ".", "add", "(", "executorService", ")", ";", "LOG", ".", "info", "(", "\"Starting HFTA : {}\"", ",", "executorService", ")", ";", "executorService", ".", "startAndWait", "(", ")", ";", "}", "}" ]

[ "Starts", "HFTA", "processes", "." ]