eagle-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From yonzhang2...@apache.org
Subject [1/7] incubator-eagle git commit: EAGLE-120 EAGLE-100 initial system and hadoop metric initial system and hadoop metric https://issues.apache.org/jira/browse/EAGLE-120 Author: qingwen220 qingwzhao@ebay.com Reviewer: yonzhang2012 yonzhang2012@apache.org C
Date Wed, 13 Jan 2016 01:08:08 GMT
Repository: incubator-eagle
Updated Branches:
  refs/heads/master 178d06646 -> db2bbf91b


http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-external/hadoop_jmx_collector/lib/six/six.py
----------------------------------------------------------------------
diff --git a/eagle-external/hadoop_jmx_collector/lib/six/six.py b/eagle-external/hadoop_jmx_collector/lib/six/six.py
new file mode 100644
index 0000000..21b0e80
--- /dev/null
+++ b/eagle-external/hadoop_jmx_collector/lib/six/six.py
@@ -0,0 +1,762 @@
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+# Copyright (c) 2010-2014 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import absolute_import
+
+import functools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.8.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result) # Invokes __set__.
+        # This is a bit ugly, but it avoids running this again.
+        delattr(obj.__class__, self.name)
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+    MovedModule("winreg", "_winreg"),
+]
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+else:
+    def iterkeys(d, **kw):
+        return iter(d.iterkeys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.itervalues(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.iteritems(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.iterlists(**kw))
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+    def u(s):
+        return s
+    unichr = chr
+    if sys.version_info[1] <= 1:
+        def int2byte(i):
+            return bytes((i,))
+    else:
+        # This is about 2x faster than the implementation above on 3.2+
+        int2byte = operator.methodcaller("to_bytes", 1, "big")
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+    def byte2int(bs):
+        return ord(bs[0])
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    def iterbytes(buf):
+        return (ord(byte) for byte in buf)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+
+    def reraise(tp, value, tb=None):
+        if value is None:
+            value = tp()
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+
+    exec_("""def reraise(tp, value, tb=None):
+    raise tp, value, tb
+""")
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                isinstance(data, unicode) and
+                fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        def wrapper(f):
+            f = functools.wraps(wrapped)(f)
+            f.__wrapped__ = wrapped
+            return f
+        return wrapper
+else:
+    wraps = functools.wraps
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+            importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-external/hadoop_jmx_collector/lib/six/test_six.py
----------------------------------------------------------------------
diff --git a/eagle-external/hadoop_jmx_collector/lib/six/test_six.py b/eagle-external/hadoop_jmx_collector/lib/six/test_six.py
new file mode 100644
index 0000000..0125d6b
--- /dev/null
+++ b/eagle-external/hadoop_jmx_collector/lib/six/test_six.py
@@ -0,0 +1,736 @@
+import operator
+import sys
+import types
+
+import py
+
+import six
+
+
+def test_add_doc():
+    def f():
+        """Icky doc"""
+        pass
+    six._add_doc(f, """New doc""")
+    assert f.__doc__ == "New doc"
+
+
+def test_import_module():
+    from logging import handlers
+    m = six._import_module("logging.handlers")
+    assert m is handlers
+
+
+def test_integer_types():
+    assert isinstance(1, six.integer_types)
+    assert isinstance(-1, six.integer_types)
+    assert isinstance(six.MAXSIZE + 23, six.integer_types)
+    assert not isinstance(.1, six.integer_types)
+
+
+def test_string_types():
+    assert isinstance("hi", six.string_types)
+    assert isinstance(six.u("hi"), six.string_types)
+    assert issubclass(six.text_type, six.string_types)
+
+
+def test_class_types():
+    class X:
+        pass
+    class Y(object):
+        pass
+    assert isinstance(X, six.class_types)
+    assert isinstance(Y, six.class_types)
+    assert not isinstance(X(), six.class_types)
+
+
+def test_text_type():
+    assert type(six.u("hi")) is six.text_type
+
+
+def test_binary_type():
+    assert type(six.b("hi")) is six.binary_type
+
+
+def test_MAXSIZE():
+    try:
+        # This shouldn't raise an overflow error.
+        six.MAXSIZE.__index__()
+    except AttributeError:
+        # Before Python 2.6.
+        pass
+    py.test.raises(
+        (ValueError, OverflowError),
+        operator.mul, [None], six.MAXSIZE + 1)
+
+
+def test_lazy():
+    if six.PY3:
+        html_name = "html.parser"
+    else:
+        html_name = "HTMLParser"
+    assert html_name not in sys.modules
+    mod = six.moves.html_parser
+    assert sys.modules[html_name] is mod
+    assert "htmlparser" not in six._MovedItems.__dict__
+
+
+try:
+    import _tkinter
+except ImportError:
+    have_tkinter = False
+else:
+    have_tkinter = True
+
+have_gdbm = True
+try:
+    import gdbm
+except ImportError:
+    try:
+        import dbm.gnu
+    except ImportError:
+        have_gdbm = False
+
+@py.test.mark.parametrize("item_name",
+                          [item.name for item in six._moved_attributes])
+def test_move_items(item_name):
+    """Ensure that everything loads correctly."""
+    try:
+        item = getattr(six.moves, item_name)
+        if isinstance(item, types.ModuleType):
+            __import__("six.moves." + item_name)
+    except AttributeError:
+        if item_name == "zip_longest" and sys.version_info < (2, 6):
+            py.test.skip("zip_longest only available on 2.6+")
+    except ImportError:
+        if item_name == "winreg" and not sys.platform.startswith("win"):
+            py.test.skip("Windows only module")
+        if item_name.startswith("tkinter"):
+            if not have_tkinter:
+                py.test.skip("requires tkinter")
+            if item_name == "tkinter_ttk" and sys.version_info[:2] <= (2, 6):
+                py.test.skip("ttk only available on 2.7+")
+        if item_name.startswith("dbm_gnu") and not have_gdbm:
+            py.test.skip("requires gdbm")
+        raise
+    if sys.version_info[:2] >= (2, 6):
+        assert item_name in dir(six.moves)
+
+
+@py.test.mark.parametrize("item_name",
+                          [item.name for item in six._urllib_parse_moved_attributes])
+def test_move_items_urllib_parse(item_name):
+    """Ensure that everything loads correctly."""
+    if item_name == "ParseResult" and sys.version_info < (2, 5):
+        py.test.skip("ParseResult is only found on 2.5+")
+    if item_name in ("parse_qs", "parse_qsl") and sys.version_info < (2, 6):
+        py.test.skip("parse_qs[l] is new in 2.6")
+    if sys.version_info[:2] >= (2, 6):
+        assert item_name in dir(six.moves.urllib.parse)
+    getattr(six.moves.urllib.parse, item_name)
+
+
+@py.test.mark.parametrize("item_name",
+                          [item.name for item in six._urllib_error_moved_attributes])
+def test_move_items_urllib_error(item_name):
+    """Ensure that everything loads correctly."""
+    if sys.version_info[:2] >= (2, 6):
+        assert item_name in dir(six.moves.urllib.error)
+    getattr(six.moves.urllib.error, item_name)
+
+
+@py.test.mark.parametrize("item_name",
+                          [item.name for item in six._urllib_request_moved_attributes])
+def test_move_items_urllib_request(item_name):
+    """Ensure that everything loads correctly."""
+    if sys.version_info[:2] >= (2, 6):
+        assert item_name in dir(six.moves.urllib.request)
+    getattr(six.moves.urllib.request, item_name)
+
+
+@py.test.mark.parametrize("item_name",
+                          [item.name for item in six._urllib_response_moved_attributes])
+def test_move_items_urllib_response(item_name):
+    """Ensure that everything loads correctly."""
+    if sys.version_info[:2] >= (2, 6):
+        assert item_name in dir(six.moves.urllib.response)
+    getattr(six.moves.urllib.response, item_name)
+
+
+@py.test.mark.parametrize("item_name",
+                          [item.name for item in six._urllib_robotparser_moved_attributes])
+def test_move_items_urllib_robotparser(item_name):
+    """Ensure that everything loads correctly."""
+    if sys.version_info[:2] >= (2, 6):
+        assert item_name in dir(six.moves.urllib.robotparser)
+    getattr(six.moves.urllib.robotparser, item_name)
+
+
+def test_import_moves_error_1():
+    from six.moves.urllib.parse import urljoin
+    from six import moves
+    # In 1.4.1: AttributeError: 'Module_six_moves_urllib_parse' object has no attribute 'urljoin'
+    assert moves.urllib.parse.urljoin
+
+
+def test_import_moves_error_2():
+    from six import moves
+    assert moves.urllib.parse.urljoin
+    # In 1.4.1: ImportError: cannot import name urljoin
+    from six.moves.urllib.parse import urljoin
+
+
+def test_import_moves_error_3():
+    from six.moves.urllib.parse import urljoin
+    # In 1.4.1: ImportError: cannot import name urljoin
+    from six.moves.urllib_parse import urljoin
+
+
+def test_from_imports():
+    from six.moves.queue import Queue
+    assert isinstance(Queue, six.class_types)
+    from six.moves.configparser import ConfigParser
+    assert isinstance(ConfigParser, six.class_types)
+
+
+def test_filter():
+    from six.moves import filter
+    f = filter(lambda x: x % 2, range(10))
+    assert six.advance_iterator(f) == 1
+
+
+def test_filter_false():
+    from six.moves import filterfalse
+    f = filterfalse(lambda x: x % 3, range(10))
+    assert six.advance_iterator(f) == 0
+    assert six.advance_iterator(f) == 3
+    assert six.advance_iterator(f) == 6
+
+def test_map():
+    from six.moves import map
+    assert six.advance_iterator(map(lambda x: x + 1, range(2))) == 1
+
+
+def test_zip():
+    from six.moves import zip
+    assert six.advance_iterator(zip(range(2), range(2))) == (0, 0)
+
+
+@py.test.mark.skipif("sys.version_info < (2, 6)")
+def test_zip_longest():
+    from six.moves import zip_longest
+    it = zip_longest(range(2), range(1))
+
+    assert six.advance_iterator(it) == (0, 0)
+    assert six.advance_iterator(it) == (1, None)
+
+
+class TestCustomizedMoves:
+
+    def teardown_method(self, meth):
+        try:
+            del six._MovedItems.spam
+        except AttributeError:
+            pass
+        try:
+            del six.moves.__dict__["spam"]
+        except KeyError:
+            pass
+
+
+    def test_moved_attribute(self):
+        attr = six.MovedAttribute("spam", "foo", "bar")
+        if six.PY3:
+            assert attr.mod == "bar"
+        else:
+            assert attr.mod == "foo"
+        assert attr.attr == "spam"
+        attr = six.MovedAttribute("spam", "foo", "bar", "lemma")
+        assert attr.attr == "lemma"
+        attr = six.MovedAttribute("spam", "foo", "bar", "lemma", "theorm")
+        if six.PY3:
+            assert attr.attr == "theorm"
+        else:
+            assert attr.attr == "lemma"
+
+
+    def test_moved_module(self):
+        attr = six.MovedModule("spam", "foo")
+        if six.PY3:
+            assert attr.mod == "spam"
+        else:
+            assert attr.mod == "foo"
+        attr = six.MovedModule("spam", "foo", "bar")
+        if six.PY3:
+            assert attr.mod == "bar"
+        else:
+            assert attr.mod == "foo"
+
+
+    def test_custom_move_module(self):
+        attr = six.MovedModule("spam", "six", "six")
+        six.add_move(attr)
+        six.remove_move("spam")
+        assert not hasattr(six.moves, "spam")
+        attr = six.MovedModule("spam", "six", "six")
+        six.add_move(attr)
+        from six.moves import spam
+        assert spam is six
+        six.remove_move("spam")
+        assert not hasattr(six.moves, "spam")
+
+
+    def test_custom_move_attribute(self):
+        attr = six.MovedAttribute("spam", "six", "six", "u", "u")
+        six.add_move(attr)
+        six.remove_move("spam")
+        assert not hasattr(six.moves, "spam")
+        attr = six.MovedAttribute("spam", "six", "six", "u", "u")
+        six.add_move(attr)
+        from six.moves import spam
+        assert spam is six.u
+        six.remove_move("spam")
+        assert not hasattr(six.moves, "spam")
+
+
+    def test_empty_remove(self):
+        py.test.raises(AttributeError, six.remove_move, "eggs")
+
+
+def test_get_unbound_function():
+    class X(object):
+        def m(self):
+            pass
+    assert six.get_unbound_function(X.m) is X.__dict__["m"]
+
+
+def test_get_method_self():
+    class X(object):
+        def m(self):
+            pass
+    x = X()
+    assert six.get_method_self(x.m) is x
+    py.test.raises(AttributeError, six.get_method_self, 42)
+
+
+def test_get_method_function():
+    class X(object):
+        def m(self):
+            pass
+    x = X()
+    assert six.get_method_function(x.m) is X.__dict__["m"]
+    py.test.raises(AttributeError, six.get_method_function, hasattr)
+
+
+def test_get_function_closure():
+    def f():
+        x = 42
+        def g():
+            return x
+        return g
+    cell = six.get_function_closure(f())[0]
+    assert type(cell).__name__ == "cell"
+
+
+def test_get_function_code():
+    def f():
+        pass
+    assert isinstance(six.get_function_code(f), types.CodeType)
+    if not hasattr(sys, "pypy_version_info"):
+        py.test.raises(AttributeError, six.get_function_code, hasattr)
+
+
+def test_get_function_defaults():
+    def f(x, y=3, b=4):
+        pass
+    assert six.get_function_defaults(f) == (3, 4)
+
+
+def test_get_function_globals():
+    def f():
+        pass
+    assert six.get_function_globals(f) is globals()
+
+
+def test_dictionary_iterators(monkeypatch):
+    def stock_method_name(iterwhat):
+        """Given a method suffix like "lists" or "values", return the name
+        of the dict method that delivers those on the version of Python
+        we're running in."""
+        if six.PY3:
+            return iterwhat
+        return 'iter' + iterwhat
+
+    class MyDict(dict):
+        if not six.PY3:
+            def lists(self, **kw):
+                return [1, 2, 3]
+        def iterlists(self, **kw):
+            return iter([1, 2, 3])
+    f = MyDict.iterlists
+    del MyDict.iterlists
+    setattr(MyDict, stock_method_name('lists'), f)
+
+    d = MyDict(zip(range(10), reversed(range(10))))
+    for name in "keys", "values", "items", "lists":
+        meth = getattr(six, "iter" + name)
+        it = meth(d)
+        assert not isinstance(it, list)
+        assert list(it) == list(getattr(d, name)())
+        py.test.raises(StopIteration, six.advance_iterator, it)
+        record = []
+        def with_kw(*args, **kw):
+            record.append(kw["kw"])
+            return old(*args)
+        old = getattr(MyDict, stock_method_name(name))
+        monkeypatch.setattr(MyDict, stock_method_name(name), with_kw)
+        meth(d, kw=42)
+        assert record == [42]
+        monkeypatch.undo()
+
+
+def test_advance_iterator():
+    assert six.next is six.advance_iterator
+    l = [1, 2]
+    it = iter(l)
+    assert six.next(it) == 1
+    assert six.next(it) == 2
+    py.test.raises(StopIteration, six.next, it)
+    py.test.raises(StopIteration, six.next, it)
+
+
+def test_iterator():
+    class myiter(six.Iterator):
+        def __next__(self):
+            return 13
+    assert six.advance_iterator(myiter()) == 13
+    class myitersub(myiter):
+        def __next__(self):
+            return 14
+    assert six.advance_iterator(myitersub()) == 14
+
+
+def test_callable():
+    class X:
+        def __call__(self):
+            pass
+        def method(self):
+            pass
+    assert six.callable(X)
+    assert six.callable(X())
+    assert six.callable(test_callable)
+    assert six.callable(hasattr)
+    assert six.callable(X.method)
+    assert six.callable(X().method)
+    assert not six.callable(4)
+    assert not six.callable("string")
+
+
+def test_create_bound_method():
+    class X(object):
+        pass
+    def f(self):
+        return self
+    x = X()
+    b = six.create_bound_method(f, x)
+    assert isinstance(b, types.MethodType)
+    assert b() is x
+
+
+if six.PY3:
+
+    def test_b():
+        data = six.b("\xff")
+        assert isinstance(data, bytes)
+        assert len(data) == 1
+        assert data == bytes([255])
+
+
+    def test_u():
+        s = six.u("hi \u0439 \U00000439 \\ \\\\ \n")
+        assert isinstance(s, str)
+        assert s == "hi \u0439 \U00000439 \\ \\\\ \n"
+
+else:
+
+    def test_b():
+        data = six.b("\xff")
+        assert isinstance(data, str)
+        assert len(data) == 1
+        assert data == "\xff"
+
+
+    def test_u():
+        s = six.u("hi \u0439 \U00000439 \\ \\\\ \n")
+        assert isinstance(s, unicode)
+        assert s == "hi \xd0\xb9 \xd0\xb9 \\ \\\\ \n".decode("utf8")
+
+
+def test_u_escapes():
+    s = six.u("\u1234")
+    assert len(s) == 1
+
+
+def test_unichr():
+    assert six.u("\u1234") == six.unichr(0x1234)
+    assert type(six.u("\u1234")) is type(six.unichr(0x1234))
+
+
+def test_int2byte():
+    assert six.int2byte(3) == six.b("\x03")
+    py.test.raises((OverflowError, ValueError), six.int2byte, 256)
+
+
+def test_byte2int():
+    assert six.byte2int(six.b("\x03")) == 3
+    assert six.byte2int(six.b("\x03\x04")) == 3
+    py.test.raises(IndexError, six.byte2int, six.b(""))
+
+
+def test_bytesindex():
+    assert six.indexbytes(six.b("hello"), 3) == ord("l")
+
+
+def test_bytesiter():
+    it = six.iterbytes(six.b("hi"))
+    assert six.next(it) == ord("h")
+    assert six.next(it) == ord("i")
+    py.test.raises(StopIteration, six.next, it)
+
+
+def test_StringIO():
+    fp = six.StringIO()
+    fp.write(six.u("hello"))
+    assert fp.getvalue() == six.u("hello")
+
+
+def test_BytesIO():
+    fp = six.BytesIO()
+    fp.write(six.b("hello"))
+    assert fp.getvalue() == six.b("hello")
+
+
+def test_exec_():
+    def f():
+        l = []
+        six.exec_("l.append(1)")
+        assert l == [1]
+    f()
+    ns = {}
+    six.exec_("x = 42", ns)
+    assert ns["x"] == 42
+    glob = {}
+    loc = {}
+    six.exec_("global y; y = 42; x = 12", glob, loc)
+    assert glob["y"] == 42
+    assert "x" not in glob
+    assert loc["x"] == 12
+    assert "y" not in loc
+
+
+def test_reraise():
+    def get_next(tb):
+        if six.PY3:
+            return tb.tb_next.tb_next
+        else:
+            return tb.tb_next
+    e = Exception("blah")
+    try:
+        raise e
+    except Exception:
+        tp, val, tb = sys.exc_info()
+    try:
+        six.reraise(tp, val, tb)
+    except Exception:
+        tp2, value2, tb2 = sys.exc_info()
+        assert tp2 is Exception
+        assert value2 is e
+        assert tb is get_next(tb2)
+    try:
+        six.reraise(tp, val)
+    except Exception:
+        tp2, value2, tb2 = sys.exc_info()
+        assert tp2 is Exception
+        assert value2 is e
+        assert tb2 is not tb
+    try:
+        six.reraise(tp, val, tb2)
+    except Exception:
+        tp2, value2, tb3 = sys.exc_info()
+        assert tp2 is Exception
+        assert value2 is e
+        assert get_next(tb3) is tb2
+    try:
+        six.reraise(tp, None, tb)
+    except Exception:
+        tp2, value2, tb2 = sys.exc_info()
+        assert tp2 is Exception
+        assert value2 is not val
+        assert isinstance(value2, Exception)
+        assert tb is get_next(tb2)
+
+
+def test_print_():
+    save = sys.stdout
+    out = sys.stdout = six.moves.StringIO()
+    try:
+        six.print_("Hello,", "person!")
+    finally:
+        sys.stdout = save
+    assert out.getvalue() == "Hello, person!\n"
+    out = six.StringIO()
+    six.print_("Hello,", "person!", file=out)
+    assert out.getvalue() == "Hello, person!\n"
+    out = six.StringIO()
+    six.print_("Hello,", "person!", file=out, end="")
+    assert out.getvalue() == "Hello, person!"
+    out = six.StringIO()
+    six.print_("Hello,", "person!", file=out, sep="X")
+    assert out.getvalue() == "Hello,Xperson!\n"
+    out = six.StringIO()
+    six.print_(six.u("Hello,"), six.u("person!"), file=out)
+    result = out.getvalue()
+    assert isinstance(result, six.text_type)
+    assert result == six.u("Hello, person!\n")
+    six.print_("Hello", file=None) # This works.
+    out = six.StringIO()
+    six.print_(None, file=out)
+    assert out.getvalue() == "None\n"
+
+
+@py.test.mark.skipif("sys.version_info[:2] >= (2, 6)")
+def test_print_encoding(monkeypatch):
+    # Fool the type checking in print_.
+    monkeypatch.setattr(six, "file", six.BytesIO, raising=False)
+    out = six.BytesIO()
+    out.encoding = "utf-8"
+    out.errors = None
+    six.print_(six.u("\u053c"), end="", file=out)
+    assert out.getvalue() == six.b("\xd4\xbc")
+    out = six.BytesIO()
+    out.encoding = "ascii"
+    out.errors = "strict"
+    py.test.raises(UnicodeEncodeError, six.print_, six.u("\u053c"), file=out)
+    out.errors = "backslashreplace"
+    six.print_(six.u("\u053c"), end="", file=out)
+    assert out.getvalue() == six.b("\\u053c")
+
+
+def test_print_exceptions():
+    py.test.raises(TypeError, six.print_, x=3)
+    py.test.raises(TypeError, six.print_, end=3)
+    py.test.raises(TypeError, six.print_, sep=42)
+
+
+def test_with_metaclass():
+    class Meta(type):
+        pass
+    class X(six.with_metaclass(Meta)):
+        pass
+    assert type(X) is Meta
+    assert issubclass(X, object)
+    class Base(object):
+        pass
+    class X(six.with_metaclass(Meta, Base)):
+        pass
+    assert type(X) is Meta
+    assert issubclass(X, Base)
+    class Base2(object):
+        pass
+    class X(six.with_metaclass(Meta, Base, Base2)):
+        pass
+    assert type(X) is Meta
+    assert issubclass(X, Base)
+    assert issubclass(X, Base2)
+    assert X.__mro__ == (X, Base, Base2, object)
+
+
+def test_wraps():
+    def f(g):
+        @six.wraps(g)
+        def w():
+            return 42
+        return w
+    def k():
+        pass
+    original_k = k
+    k = f(f(k))
+    assert hasattr(k, '__wrapped__')
+    k = k.__wrapped__
+    assert hasattr(k, '__wrapped__')
+    k = k.__wrapped__
+    assert k is original_k
+    assert not hasattr(k, '__wrapped__')
+
+
+def test_add_metaclass():
+    class Meta(type):
+        pass
+    class X:
+        "success"
+    X = six.add_metaclass(Meta)(X)
+    assert type(X) is Meta
+    assert issubclass(X, object)
+    assert X.__module__ == __name__
+    assert X.__doc__ == "success"
+    class Base(object):
+        pass
+    class X(Base):
+        pass
+    X = six.add_metaclass(Meta)(X)
+    assert type(X) is Meta
+    assert issubclass(X, Base)
+    class Base2(object):
+        pass
+    class X(Base, Base2):
+        pass
+    X = six.add_metaclass(Meta)(X)
+    assert type(X) is Meta
+    assert issubclass(X, Base)
+    assert issubclass(X, Base2)
+
+    # Test a second-generation subclass of a type.
+    class Meta1(type):
+        m1 = "m1"
+    class Meta2(Meta1):
+        m2 = "m2"
+    class Base:
+        b = "b"
+    Base = six.add_metaclass(Meta1)(Base)
+    class X(Base):
+        x = "x"
+    X = six.add_metaclass(Meta2)(X)
+    assert type(X) is Meta2
+    assert issubclass(X, Base)
+    assert type(Base) is Meta1
+    assert "__dict__" not in vars(X)
+    instance = X()
+    instance.attr = "test"
+    assert vars(instance) == {"attr": "test"}
+    assert instance.b == Base.b
+    assert instance.x == X.x
+
+    # Test a class with slots.
+    class MySlots(object):
+        __slots__ = ["a", "b"]
+    MySlots = six.add_metaclass(Meta1)(MySlots)
+
+    assert MySlots.__slots__ == ["a", "b"]
+    instance = MySlots()
+    instance.a = "foo"
+    py.test.raises(AttributeError, setattr, instance, "c", "baz")
+
+    # Test a class with string for slots.
+    class MyStringSlots(object):
+        __slots__ = "ab"
+    MyStringSlots = six.add_metaclass(Meta1)(MyStringSlots)
+    assert MyStringSlots.__slots__ == "ab"
+    instance = MyStringSlots()
+    instance.ab = "foo"
+    py.test.raises(AttributeError, setattr, instance, "a", "baz")
+    py.test.raises(AttributeError, setattr, instance, "b", "baz")
+
+    class MySlotsWeakref(object):
+        __slots__ = "__weakref__",
+    MySlotsWeakref = six.add_metaclass(Meta)(MySlotsWeakref)
+    assert type(MySlotsWeakref) is Meta

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-external/hadoop_jmx_collector/lib/six/tox.ini
----------------------------------------------------------------------
diff --git a/eagle-external/hadoop_jmx_collector/lib/six/tox.ini b/eagle-external/hadoop_jmx_collector/lib/six/tox.ini
new file mode 100644
index 0000000..b29b31a
--- /dev/null
+++ b/eagle-external/hadoop_jmx_collector/lib/six/tox.ini
@@ -0,0 +1,12 @@
+[tox]
+envlist=py25,py26,py27,py31,py32,py33,py34,pypy
+indexserver=
+    default = http://pypi.python.org/simple
+    testrun = http://pypi.testrun.org
+
+[testenv]
+deps=pytest
+commands= py.test -rfsxX {posargs}
+
+[pytest]
+minversion=2.2.0

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-external/hadoop_jmx_collector/system_metric_kafka.py
----------------------------------------------------------------------
diff --git a/eagle-external/hadoop_jmx_collector/system_metric_kafka.py b/eagle-external/hadoop_jmx_collector/system_metric_kafka.py
new file mode 100644
index 0000000..9f07734
--- /dev/null
+++ b/eagle-external/hadoop_jmx_collector/system_metric_kafka.py
@@ -0,0 +1,378 @@
+#!/usr/bin/python
+
+import os
+import re
+import time
+import json
+import sys
+import socket
+import types
+import re
+import errno
+
+# load kafka-python
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '', 'lib/six'))
+import six
+
+# load kafka-python
+sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), '', 'lib/kafka-python'))
+from kafka import KafkaClient, SimpleProducer, SimpleConsumer
+
+from util_func import *
+
+TOPIC = "cronus_sys_metrics"
+DATA_TYPE = "system"
+
+METRIC_NAME_EXCLUDE = re.compile(r"[\(|\)]")
+
+DEBUG_KAFKA_HOST = []
+PROD_KAFKA_HOST = []
+
+PORT_MAP = {
+    "60030": "regionserver",
+    "50075": "datanode",
+    "50070": "namenode",
+    "60010": "master",
+    "50030": "resourcemanager",
+    "50060": "nodemanager",
+    "8480": "journalnode"
+}
+
+def readFile(filename):
+    f = open(filename, 'r')
+    s = f.read()
+    f.close()
+    return s
+
+def kafka_connect(host):
+    print "Connecting to kafka " + str(host)
+    # To send messages synchronously
+    kafka = KafkaClient(host, timeout=58)
+    producer = SimpleProducer(kafka, batch_send=True, batch_send_every_n=500, batch_send_every_t=30)
+    return kafka, producer
+
+
+def kafka_close(kafka, producer):
+    if producer is not None:
+        producer.stop()
+    if kafka is not None:
+        kafka.close()
+
+
+def kafka_produce(producer, topic, kafka_json):
+    # Note that the application is responsible for encoding messages to type str
+    if producer != None :
+        producer.send_messages(topic, kafka_json)
+    else:
+        print kafka_json
+
+
+def addExtraMetric(producer, kafka_dict, metric, value, device, topic):
+    kafka_dict["timestamp"] = int(round(time.time() * 1000))
+    kafka_dict["metric"] = DATA_TYPE + "." + metric.lower()
+    kafka_dict["value"] = str(value)
+    kafka_dict["device"] = device
+    kafka_json = json.dumps(kafka_dict)
+    print(kafka_json)
+    kafka_produce(producer, topic, kafka_json)
+
+
+def getCPU(producer, kafka_dict, topic):
+    cpu_info = os.popen('cat /proc/stat').readlines()
+    demension = ["cpu", "user", "nice", "system", "idle", "wait", "irq", "softirq", "steal", "guest"]
+
+    total_cpu = 0
+    total_cpu_usage = 0
+    cpu_stat_pre = None
+
+    data_dir = "/tmp/eagle_cpu_stat_previous"
+    if os.path.exists(data_dir):
+        fd = open(data_dir, "r")
+        cpu_stat_pre = fd.read()
+        fd.close()
+
+    for item in cpu_info:
+        if re.match(r'^cpu\d+', item) is None:
+            continue
+
+        items = re.split("\s+", item.strip())
+        demens = min(len(demension), len(items))
+        # print items
+        tuple = dict()
+        for i in range(1, demens):
+            # if not isNumber(items[i]):
+            # continue
+
+            tuple[demension[i]] = int(items[i])
+
+            kafka_dict['timestamp'] = int(round(time.time() * 1000))
+            kafka_dict['metric'] = DATA_TYPE + "." + 'cpu.' + demension[i]
+            kafka_dict['device'] = items[0]
+            kafka_dict['value'] = items[i]
+            kafka_json = json.dumps(kafka_dict)
+            #print kafka_json
+            kafka_produce(producer, topic, kafka_json)
+
+        per_cpu_usage = tuple["user"] + tuple["nice"] + tuple["system"] + tuple["wait"] + tuple["irq"] + tuple[
+            "softirq"] + tuple["steal"] + tuple["guest"]
+        per_cpu_total = tuple["user"] + tuple["nice"] + tuple["system"] + tuple["idle"] + tuple["wait"] + tuple["irq"] + \
+                        tuple["softirq"] + tuple["steal"] + tuple["guest"]
+        total_cpu += per_cpu_total
+        total_cpu_usage += per_cpu_usage
+
+        # system.cpu.usage
+        kafka_dict['timestamp'] = int(round(time.time() * 1000))
+        kafka_dict['metric'] = DATA_TYPE + "." + 'cpu.' + "perusage"
+        kafka_dict['device'] = items[0]
+        kafka_dict['value'] = str(round(per_cpu_usage * 100.0 / per_cpu_total, 2))
+        kafka_json = json.dumps(kafka_dict)
+        print kafka_json
+        kafka_produce(producer, topic, kafka_json)
+
+    cup_stat_current = str(total_cpu_usage) + " " + str(total_cpu)
+    print cup_stat_current
+    fd = open(data_dir, "w")
+    fd.write(cup_stat_current)
+    fd.close()
+
+    pre_total_cpu_usage = 0
+    pre_total_cpu = 0
+    if cpu_stat_pre != None:
+        result = re.split("\s+", cpu_stat_pre.rstrip())
+        pre_total_cpu_usage = int(result[0])
+        pre_total_cpu = int(result[1])
+    kafka_dict['timestamp'] = int(round(time.time() * 1000))
+    kafka_dict['metric'] = DATA_TYPE + "." + 'cpu.' + "totalusage"
+    kafka_dict['device'] = "cpu"
+    kafka_dict['value'] = str(round((total_cpu_usage-pre_total_cpu_usage) * 100.0 / (total_cpu-pre_total_cpu), 2))
+    kafka_json = json.dumps(kafka_dict)
+
+    print kafka_json
+    kafka_produce(producer, topic, kafka_json)
+
+
+def getUptime(producer, kafka_dict, topic):
+    demension = ["uptime.day", "idletime.day"]
+    output = os.popen('cat /proc/uptime').readlines()
+
+    for item in output:
+        items = re.split("\s+", item.rstrip())
+        for i in range(len(demension)):
+            kafka_dict["timestamp"] = int(round(time.time() * 1000))
+            kafka_dict["metric"] = DATA_TYPE + "." + 'uptime' + '.' + demension[i]
+            kafka_dict["value"] = str(round(float(items[i]) / 86400, 2))
+            kafka_json = json.dumps(kafka_dict)
+            print kafka_json
+            kafka_produce(producer, topic, kafka_json)
+
+
+def getMemInfo(producer, kafka_dict, topic):
+    output = os.popen('cat /proc/meminfo').readlines()
+    mem_info = dict()
+    for item in output:
+        items = re.split(":?\s+", item.rstrip())
+        # print items
+        mem_info[items[0]] = int(items[1])
+        itemNum = len(items)
+        metric = 'memory' + '.' + items[0]
+        if (len(items) > 2 ):
+            metric = metric + '.' + items[2]
+        kafka_dict["timestamp"] = int(round(time.time() * 1000))
+        kafka_dict["metric"] = METRIC_NAME_EXCLUDE.sub("", DATA_TYPE + "." + metric.lower())
+        kafka_dict["value"] = items[1]
+        kafka_dict["device"] = 'memory'
+        kafka_json = json.dumps(kafka_dict)
+        print kafka_json
+        kafka_produce(producer, topic, kafka_json)
+    usage = (mem_info['MemTotal'] - mem_info['MemFree'] - mem_info['Buffers'] - mem_info['Cached']) * 100.0 / mem_info[
+        'MemTotal']
+    usage = round(usage, 2)
+    addExtraMetric(producer, kafka_dict, "memory.usage", usage, "memory", topic)
+
+
+def getLoadAvg(producer, kafka_dict, topic):
+    demension = ['cpu.loadavg.1min', 'cpu.loadavg.5min', 'cpu.loadavg.15min']
+    output = os.popen('cat /proc/loadavg').readlines()
+    for item in output:
+        items = re.split("\s+", item.rstrip())
+
+        demens = min(len(demension), len(items))
+        for i in range(demens):
+            kafka_dict["timestamp"] = int(round(time.time() * 1000))
+            kafka_dict["metric"] = DATA_TYPE + "." + demension[i]
+            kafka_dict["value"] = items[i]
+            kafka_dict["device"] = 'cpu'
+            kafka_json = json.dumps(kafka_dict)
+            print kafka_json
+            kafka_produce(producer, topic, kafka_json)
+
+
+def getIpmiCPUTemp(producer, kafka_dict, topic):
+    output = os.popen('sudo ipmitool sdr | grep Temp | grep CPU').readlines()
+    for item in output:
+        items = re.split("^(CPU\d+)\sTemp\.\s+\|\s+(\d+|\d+\.\d+)\s", item.rstrip())
+        kafka_dict["timestamp"] = int(round(time.time() * 1000))
+        kafka_dict["metric"] = DATA_TYPE + "." + 'cpu.temp'
+        kafka_dict["value"] = items[2]
+        kafka_dict["device"] = item[1]
+        kafka_json = json.dumps(kafka_dict)
+        print kafka_json
+        kafka_produce(producer, topic, kafka_json)
+
+
+def getInterface(producer, kafka_dict, topic):
+    demension = ['receivedbytes', 'receivedpackets', 'receivederrs', 'receiveddrop', 'transmitbytes', 'transmitpackets',
+                 'transmiterrs', 'transmitdrop']
+    output = os.popen("cat /proc/net/dev").readlines()
+
+    for item in output:
+        if re.match(r'^\s+eth\d+:', item) is None:
+            continue
+        items = re.split("[:\s]+", item.strip())
+        filtered_items = items[1:5] + items[9:13]
+
+        for i in range(len(demension)):
+            kafka_dict["timestamp"] = int(round(time.time() * 1000))
+            kafka_dict['metric'] = DATA_TYPE + "." + 'nic.' + demension[i]
+            kafka_dict["value"] = filtered_items[i]
+            kafka_dict["device"] = items[0]
+            kafka_json = json.dumps(kafka_dict)
+            print kafka_json
+            kafka_produce(producer, topic, kafka_json)
+
+
+def getSmartDisk(producer, kafka_dict, topic):
+    harddisks = os.popen("lsscsi").readlines()
+    for item in harddisks:
+        items = re.split('\/', item.strip())
+        # print items
+        smartctl = os.popen('sudo smartctl -A /dev/' + items[-1]).readlines()
+        for line in smartctl:
+            line = line.strip()
+            if re.match(r'^[\d]+\s', line) is None:
+                continue
+            lineitems = re.split("\s+", line)
+            metric = 'smartdisk.' + lineitems[1]
+            kafka_dict['metric'] = DATA_TYPE + "." + metric.lower()
+            kafka_dict["timestamp"] = int(round(time.time() * 1000))
+            kafka_dict["value"] = lineitems[-1]
+            kafka_dict["device"] = 'smartdisk'
+            kafka_json = json.dumps(kafka_dict)
+            print kafka_json
+            kafka_produce(producer, topic, kafka_json)
+
+
+def getDiskStat(producer, kafka_dict, topic):
+    demension = ['readrate', 'writerate', 'avgwaittime', 'utilization', 'disktotal', 'diskused', 'usage']
+    iostat_output = os.popen("iostat -xk 1 2 | grep ^sd").readlines()
+    # remove the first set of elements
+    iostat_output = iostat_output[len(iostat_output) / 2:]
+    # print iostat_output
+    iostat_dict = {}
+    for item in iostat_output:
+        items = re.split('\s+', item.strip())
+        # print items
+        filtered_items = [items[5], items[6], items[9], items[11]]
+        iostat_dict[items[0]] = filtered_items
+    # print iostat_dict
+
+    disk_output = os.popen("df -k | grep ^/dev").readlines()
+    for item in disk_output:
+        items = re.split('\s+', item.strip())
+        fs = re.split('^\/dev\/(\w+)\d+$', items[0])
+        disk = fs[1]
+        iostat_dict[disk].append(items[1])
+        iostat_dict[disk].append(items[2])
+        iostat_dict[disk].append(items[4].rstrip('%'))
+    #print iostat_dict
+
+    for key, metrics in iostat_dict.iteritems():
+        for i in range(len(metrics)):
+            metric = 'disk.' + demension[i]
+            kafka_dict['metric'] = DATA_TYPE + "." + metric.lower()
+            kafka_dict["timestamp"] = int(round(time.time() * 1000))
+            kafka_dict["value"] = metrics[i]
+            kafka_dict["device"] = key
+            kafka_json = json.dumps(kafka_dict)
+            # print kafka_json
+            kafka_produce(producer, topic, kafka_json)
+
+
+def get_services(host):
+    service_list = list()
+    socket.setdefaulttimeout(1)
+    for (key, value) in PORT_MAP.items():
+        try:
+            handle = None
+            port = int(key)
+            handle = socket.socket().connect((host, port))
+            service_list.append(value)
+        except socket.error as err:
+            # if err.errno != errno.ECONNREFUSED:
+            # service_list.append(value)
+            pass
+        finally:
+            if handle != None:
+                handle.close()
+
+    return service_list
+
+def tryGetSystemMetric(type, func, *args):
+    try:
+        func(*args)
+    except:
+        print type + " does not work, ignore"
+
+DEVICE_CONF = {
+    "cpustat": getCPU,
+    "uptime": getUptime,
+    "meminfo": getMemInfo,
+    "loadavg": getLoadAvg,
+    "ipmicputemp": getIpmiCPUTemp,
+    "network": getInterface,
+    "smartdisk": getSmartDisk,
+    "diskstat": getDiskStat
+}
+
+def main(argv):
+    kafka = None
+    producer = None
+    topic = None
+    try:
+        # read the kafka.ini
+        config = loadConfigFile('eagle-collector.conf')
+        print config
+
+        site = config[u'env'].get('site').encode('utf-8')
+        component = config[u'input'].get('component').encode('utf-8')
+        host = socket.getfqdn()
+        print host
+
+        outputs = [s.encode('utf-8') for s in config[u'output']]
+
+        if('kafka' in outputs):
+            kafkaConfig = config[u'output'].get(u'kafka')
+            brokerList = kafkaConfig.get('brokerList')
+            topic = kafkaConfig.get('topic')
+            kafka, producer = kafka_connect(brokerList)
+
+        kafka_dict = {"host": host, "value": 0, "device": ''}
+        services = get_services(host)
+        print services
+        for service in services:
+            kafka_dict[service] = 'true'
+
+        for type, func in DEVICE_CONF.items():
+            print type + ":" + str(func)
+            tryGetSystemMetric(type, func, kafka, kafka_dict, topic)
+
+    except Exception, e:
+        print 'main except: ', e
+
+    finally:
+        kafka_close(kafka, producer)
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-external/hadoop_jmx_collector/util_func.py
----------------------------------------------------------------------
diff --git a/eagle-external/hadoop_jmx_collector/util_func.py b/eagle-external/hadoop_jmx_collector/util_func.py
new file mode 100644
index 0000000..47ca240
--- /dev/null
+++ b/eagle-external/hadoop_jmx_collector/util_func.py
@@ -0,0 +1,85 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+#!/usr/bin/python
+
+import os
+import re
+import time
+import json
+
+
+def kafka_connect(host):
+    # To send messages synchronously
+    print "Connecting kafka: " + str(host)
+    kafka = KafkaClient(host, timeout=58)
+    producer = SimpleProducer(kafka, batch_send=True, batch_send_every_n=500, batch_send_every_t=30)
+    return kafka, producer
+
+
+def kafka_close(kafka, producer):
+    if producer is not None:
+        producer.stop()
+    if kafka is not None:
+        kafka.close()
+
+
+def send_output_message(producer, topic, kafka_dict, metric, value):
+    kafka_dict["timestamp"] = int(round(time.time() * 1000))
+    kafka_dict["metric"] = metric.lower()
+    kafka_dict["value"] = str(value)
+    kafka_json = json.dumps(kafka_dict)
+
+    if producer != None:
+        producer.send_messages(topic, kafka_json)
+    else:
+        print(kafka_json)
+
+
+def readFile(filename):
+    f = open(filename, 'r')
+    s = f.read()
+    f.close()
+    return s
+
+
+def loadConfigFile(filename):
+    # read the self-defined filters
+
+    script_dir = os.path.dirname(__file__)
+    rel_path = "./" + filename
+    abs_file_path = os.path.join(script_dir, rel_path)
+    json_file = readFile(abs_file_path)
+    #print json_file
+
+    try:
+        config = json.loads(json_file)
+
+    except ValueError:
+        print "configuration file load error"
+    return config
+
+
+def isNumber(str):
+    try:
+        if str == None or isinstance(str, (bool)):
+            return False
+        float(str)
+        return True
+    except:
+        return False
+
+

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-external/hadoop_jmx_collector/util_func.pyc
----------------------------------------------------------------------
diff --git a/eagle-external/hadoop_jmx_collector/util_func.pyc b/eagle-external/hadoop_jmx_collector/util_func.pyc
new file mode 100644
index 0000000..9fca678
Binary files /dev/null and b/eagle-external/hadoop_jmx_collector/util_func.pyc differ

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-gc/src/main/resources/application.conf
----------------------------------------------------------------------
diff --git a/eagle-gc/src/main/resources/application.conf b/eagle-gc/src/main/resources/application.conf
index b86fcfa..5fad589 100644
--- a/eagle-gc/src/main/resources/application.conf
+++ b/eagle-gc/src/main/resources/application.conf
@@ -42,7 +42,7 @@
   "eagleProps" : {
     "site" : "sandbox",
     "dataSource": "NNGCLog",
-    "mailHost" : "atom.corp.ebay.com",
+    "mailHost" : "www.xyz.com",
     "mailSmtpPort":"25",
     "mailDebug" : "true",
     "eagleService": {

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-samples/eagle-persist-sample/src/main/resources/application.conf
----------------------------------------------------------------------
diff --git a/eagle-samples/eagle-persist-sample/src/main/resources/application.conf b/eagle-samples/eagle-persist-sample/src/main/resources/application.conf
index 466c993..6c4d261 100644
--- a/eagle-samples/eagle-persist-sample/src/main/resources/application.conf
+++ b/eagle-samples/eagle-persist-sample/src/main/resources/application.conf
@@ -46,7 +46,7 @@
   "persistExecutorConfigs" {
     "persistExecutor1" : {
       "kafka": {
-        "bootstrap_servers" : "eagle-c3-lvs01-2-3954.lvs01.dev.ebayc3.com",
+        "bootstrap_servers" : "www.xyz.com",
         "topics" : {
           "defaultOutput" : "downSampleOutput"
         }

http://git-wip-us.apache.org/repos/asf/incubator-eagle/blob/db2bbf91/eagle-webservice/src/main/resources/application.conf
----------------------------------------------------------------------
diff --git a/eagle-webservice/src/main/resources/application.conf b/eagle-webservice/src/main/resources/application.conf
index ecc29d7..6b7c8bc 100644
--- a/eagle-webservice/src/main/resources/application.conf
+++ b/eagle-webservice/src/main/resources/application.conf
@@ -16,7 +16,7 @@
 eagle{
 	service{
 		storage-type="hbase"
-		hbase-zookeeper-quorum="eagle-c3-lvs01-1-9953.lvs01.dev.ebayc3.com"
+		hbase-zookeeper-quorum="www.xyz.com"
 		hbase-zookeeper-property-clientPort=2181
 		zookeeper-znode-parent="/hbase",
 		springActiveProfile="sandbox"


Mime
View raw message