Dogfooding by acezen

[acezen]

System info

uname -a
Darwin B-W282LVDL-0218.local 21.5.0 Darwin Kernel Version 21.5.0: Tue Apr 26 21:08:22 PDT 2022; root:xnu-8020.121.3~4/RELEASE_X86_64 x86_64

python --version
Python 3.10.9 

Task 1: 在本地试用 GraphScope

• 安装 GraphScope
• 载入 ogbn_mag 内置图
• Project ogbn_mag到一个简单图，选择点标签为 paper, 边标签为 cites, 属性都为空。
• 在简单图上运行一个 Kcore 算法, 并打印结果为 pandas.DataFrame
• 在 ogbn_mag图上启动交互引擎 （Interactive）
• 通过 gremlin 计算图有多少点，边
• 对于 ogbn_mag图，使用 learning 定义并执行一个 GCN 训练过程，可参考 CI 或文档中定义的过程
• 退出 GraphScope。

Task 2: 在本地开发调试 GraphScope

• 通过 vineyardd直接启动 vineyard
• 从源代码编译 Analytical Engine，找到编译出的binary grape_engine， 通过 grape_engine直接运行 analytical_engine，然后退出 grape_engine 进程
• 为 GAE 添加一条日志 ( analytical_engine/core/server/analytical_server.cc)，并重新编译，启动并找到新添加的日志
• 从源代码编译 Interactive Engine，找到编译出的 frontend-x-SNAPSHOT.jar和 gaia_executor,直接运行这个 jar 包和这个 gaia_executor，使 frontend 能够连接到 executor。
• 了解 Frontend 和 Executor 的代码位置和组织结构，为 GIE 的 Frontend (interactive_engine/frontend/src/main/java/com/alibaba/graphscope/frontend/Frontend.java) 和 executor (interactive_engine/executor/assembly/v6d/src/bin/gaia_executor.rs) 各添加一条日志，并重新编译，启动并找到新添加的日志
• 从源代码编译 Learning Engine, 找到 libgraphlearn_shared.so
• 使用 setup.py 安装 coordinator 和 client。 注意因依赖关系， client 安装要在 coordinator 之前
• 继续安装 GAE，GIE，和 GLE 到预设安装目录。（上一步只有编译。相当于 make 和 make install 的区别）
• 找到 Client， Coordinator， GAE，GIE 和 GLE 的安装位置目录
• 若一切正常，这时你能通过 python 拉起 graphscope。启动python，import graphscope 并载入一个内置 modern_graph 图，在图上启动图交互引擎，发送一个查所有点的语句。
• 退出 graphscope

Task 3: 运行本地测试

• 找到 CI 定义的位置和文件
• 找到单元测试的位置，参考在 CI 中是如何运行这些单元测试的步骤，并在本地运行CI上的本地测试 （如果没有，可开 Issue 加入运行）
• GAE 的单元测试
• GIE 的单元测试
• GLE 的单元测试
• 运行一组 Python 中的单元测试 test_min.py 。（Python 中的单元测试更像是集成测试，因为往往由多个引擎参与）
• 在 python/graphscope/tests/minitest下新增一个test 文件，在里面添加一个涉及多个引擎的测试，其中要包括载入一张 ogbn_mag 图，打印 Kcore 算法结果，通过 Gremlin 查询图的点边数量，执行 GCN 训练。

Task 4: 在 Kubernetes 上使用 GraphScope （Python SDK）

• 通过客户端在 K8S 环境下安装 Graphscope，建立一个 Session，通过 kubectl 查看拉起来的 Pod 和 Service （可通过 minikube/kind 在单机搭建 K8S 环境）
• 通过载图 API 载一个图 ogbn_mag
• 在图上运行一个 LPA 算法，并打印结果为 pandas.DataFrame
• 在图上启动交互引擎 （Interactive）
• 通过 gremlin 计算图有多少点，边
• 使用 learning 定义并执行一个 GCN 训练过程
• 关闭 Session

Task 5: 在 Kubernetes 上使用 GraphScope （Helm）

• 通过 Helm 安装 GraphScope，并载图，运行算法，Gremlin 和 Learning

Task 6: 独立部署

• 独立部署 GAE，并载图 modern_graph，运行 LPA 算法
• 独立部署 GIE，发送 gremlin 查询点边数量

Task 7: 打包镜像与了解 Kubernetes 上运行的基本概念

• 构建 GAE 的镜像
• 构建 GIE 的镜像 （包括 Frontend 和 Executor）
• 构建 GLE 的镜像
• 构建 Coordinator 的镜像
• 为 GAE 添加一条日志 ( analytical_engine/core/server/analytical_server.cc) 并重新构建镜像，在不使用 docker push的情况下，使用新的镜像启动并在日志中可以找到新添加的日志 （使用 registry 和 tag 来选择使用哪个镜像）
• 为 GIE 的 Frontend (interactive_engine/frontend/src/main/java/com/alibaba/graphscope/frontend/Frontend.java) 和 executor (interactive_engine/executor/assembly/v6d/src/bin/gaia_executor.rs) 各添加一条日志 并重新构建 Frontend 和 Executor 镜像，在不使用 docker push的情况下，使用新的镜像启动并可以找到新添加的日志
• 为 Coordinator 添加一个异常 (coordinator/gscoordinator/coordinator.py)，并重新构建 Coordinator 镜像。启动并找到异常的报错。（日志在控制台中或者在 Coordinator Pod 的日志中）
• 清除所有 GraphScope 的资源，包括镜像，容器。

Task 8: 运行 K8S 上的测试

• 找到在 Kubernetes 上运行的测试，找到在 CI 中是如何运行这些单元测试的
• 参考 CI 的步骤，运行 test_demo_scripts.py 中的 test_demo_distribute 测试
• 尝试添加一个在 Kubernetes 上运行的测试，并运行。其中要包括载入一张 ogbn_mag 图，打印 Kcore 算法结果，通过 Gremlin 查询图的点边数量，执行 GCN 训练。

Task 9 : 打包为 Wheel 包

• 从源码构建 Python graphscope-client Wheels
• 从源码构建 Python graphscope wheels
• 安装构建出的 Wheel

[sighingnow]

Fixed by #2650

[sighingnow]

@sighingnow

[sighingnow]

Cannot reproduce with the latest nightly release:

[sighingnow]

Reproducible with grpcio==1.55.0rc1 but works with grpcio==1.54.0. @acezen can you please downgrade your grpcio installation a bit?

Actually, it was a grpc issue and we have nothing to do before grpc upload new wheels to their pypi: grpc/grpc#31885

[acezen]

building graph analytical engine

graphscope ➜ /workspaces/GraphScope (3b11b77f) $ ./gs make analytical
Setting the environment for development.

[WARNING] GRAPHSCOPE_HOME will set to source root (/workspaces/GraphScope) for development.
[WARNING] To use you assigned GRAPHSCOPE_HOME, export GRAPHSCOPE_ENV=prod.

Read the env: GRAPHSCOPE_HOME=/workspaces/GraphScope
# this file is located in 'src/make_command.sh'
# code for 'gs make' goes here
# you can edit it freely and regenerate (it will not be overwritten)
args:
- ${args[component]} = analytical
- ${args[--install-prefix]} = /opt/graphscope
Making component analytical
make: Nothing to be done for 'analytical'.

reference: https://graphscope.io/docs/latest/analytical_engine/dev_and_test.html#build-analytical-engine

[acezen]

Fixed by remove analytical_engine/build

[acezen]

It's weird that if analytical_engine/build is existed, the ./gs make analytical do nothing.

[acezen]

@siyuan0322

[siyuan0322]

It checks if grape_engine exists.
A cache mechanism of Makefile in order to not building everytime.
It has drawback through, can't compare the timestamp of grape_engine dependencies to decide if rebuilding is needed.

[sighingnow]

@longbinlai dev & test doc for GIE

[acezen]

Can we unify the building process with gs like:

./gs make analytical
./gs make interactive
./gs make learning

https://graphscope.io/docs/latest/analytical_engine/dev_and_test.html#build-analytical-engine
https://graphscope.io/docs/latest/learning_engine/dev_and_test.html#build-learning-engine

[acezen]

no document about how to install client and coordinator withsetup.py

[acezen]

@longbinlai

[acezen]

the learning building command should be:

./gs make learning

run with make learning, got

make: Nothing to be done for 'learning'.

[acezen]

@LiSu

[acezen]

task2 - install gae, gie, gle

there are no instruction to help how to install gie and gle

[acezen]

@LiSu @longbinlai

[acezen]

task2

g = load_mordern_graph()

got error:

2023-06-05 09:53:04,228 [ERROR][local_launcher:532]: Error when launching GraphScope on local
Traceback (most recent call last):
  File "/workspaces/GraphScope/coordinator/gscoordinator/local_launcher.py", line 529, in start
    self.launch_vineyard()
  File "/workspaces/GraphScope/coordinator/gscoordinator/local_launcher.py", line 473, in launch_vineyard
    raise RuntimeError(msg)
RuntimeError: Launch vineyardd failed: Traceback (most recent call last):

  File "/usr/lib/python3.10/runpy.py", line 196, in _run_module_as_main

    return _run_code(code, main_globals, None,

  File "/usr/lib/python3.10/runpy.py", line 86, in _run_code

    exec(code, run_globals)

  File "/home/graphscope/.local/lib/python3.10/site-packages/vineyard/__main__.py", line 22, in <module>

    main()

  File "/home/graphscope/.local/lib/python3.10/site-packages/vineyard/deploy/__main__.py", line 40, in main

    raise SystemExit(deploy_vineyardd(sys.argv[1:]))

  File "/home/graphscope/.local/lib/python3.10/site-packages/vineyard/deploy/__main__.py", line 28, in deploy_vineyardd

    vineyardd = find_vineyardd_path()

  File "/home/graphscope/.local/lib/python3.10/site-packages/vineyard/deploy/utils.py", line 165, in find_vineyardd_path

    pkg_resources.resource_filename('vineyard.bdist', 'vineyardd')

  File "/home/graphscope/.local/lib/python3.10/site-packages/pkg_resources/__init__.py", line 1154, in resource_filename

    return get_provider(package_or_requirement).get_resource_filename(

  File "/home/graphscope/.local/lib/python3.10/site-packages/pkg_resources/__init__.py", line 361, in get_provider

    return _find_adapter(_provider_factories, loader)(module)

  File "/home/graphscope/.local/lib/python3.10/site-packages/pkg_resources/__init__.py", line 1403, in __init__

    self.module_path = os.path.dirname(getattr(module, '__file__', ''))

  File "/usr/lib/python3.10/posixpath.py", line 152, in dirname

    p = os.fspath(p)

TypeError: expected str, bytes or os.PathLike object, not NoneType

Rerun with `graphscope.set_option(log_level='debug')`, to get verbosed vineyardd logs.
╭───────────────────── Traceback (most recent call last) ──────────────────────╮
│ /usr/lib/python3.10/runpy.py:196 in _run_module_as_main                      │
│                                                                              │
│   193 │   main_globals = sys.modules["__main__"].__dict__                    │
│   194 │   if alter_argv:                                                     │
│   195 │   │   sys.argv[0] = mod_spec.origin                                  │
│ ❱ 196 │   return _run_code(code, main_globals, None,                         │
│   197 │   │   │   │   │    "__main__", mod_spec)                             │
│   198                                                                        │
│   199 def run_module(mod_name, init_globals=None,                            │
│                                                                              │
│ /usr/lib/python3.10/runpy.py:86 in _run_code                                 │
│                                                                              │
│    83 │   │   │   │   │      __loader__ = loader,                            │
│    84 │   │   │   │   │      __package__ = pkg_name,                         │
│    85 │   │   │   │   │      __spec__ = mod_spec)                            │
│ ❱  86 │   exec(code, run_globals)                                            │
│    87 │   return run_globals                                                 │
│    88                                                                        │
│    89 def _run_module_code(code, init_globals=None,                          │
│                                                                              │
│ /workspaces/GraphScope/coordinator/gscoordinator/__main__.py:3 in <module>   │
│                                                                              │
│   1 from gscoordinator.coordinator import launch_graphscope                  │
│   2                                                                          │
│ ❱ 3 launch_graphscope()                                                      │
│   4                                                                          │
│                                                                              │
│ /workspaces/GraphScope/coordinator/gscoordinator/coordinator.py:903 in       │
│ launch_graphscope                                                            │
│                                                                              │
│    900 def launch_graphscope():                                              │
│    901 │   args = parse_sys_args()                                           │
│    902 │   launcher = get_launcher(args)                                     │
│ ❱  903 │   start_server(launcher, args)                                      │
│    904                                                                       │
│    905                                                                       │
│    906 def get_launcher(args):                                               │
│                                                                              │
│ /workspaces/GraphScope/coordinator/gscoordinator/coordinator.py:963 in       │
│ start_server                                                                 │
│                                                                              │
│    960                                                                       │
│    961                                                                       │
│    962 def start_server(launcher, args):                                     │
│ ❱  963 │   coordinator_service_servicer = CoordinatorServiceServicer(        │
│    964 │   │   launcher=launcher,                                            │
│    965 │   │   dangling_timeout_seconds=args.dangling_timeout_seconds,       │
│    966 │   │   log_level=args.log_level,                                     │
│                                                                              │
│ /workspaces/GraphScope/coordinator/gscoordinator/coordinator.py:181 in       │
│ __init__                                                                     │
│                                                                              │
│    178 │   │   self._session_id = self._generate_session_id()                │
│    179 │   │   self._launcher.set_session_workspace(self._session_id)        │
│    180 │   │   if not self._launcher.start():                                │
│ ❱  181 │   │   │   raise RuntimeError("Coordinator launching instance failed │
│    182 │   │                                                                 │
│    183 │   │   self._operation_executor: OperationExecutor = OperationExecut │
│    184 │   │   │   self._session_id, self._launcher, self._object_manager    │
╰──────────────────────────────────────────────────────────────────────────────╯
RuntimeError: Coordinator launching instance failed.
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ in <module>:1                                                                                    │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/dataset/modern_graph.py:73 in load_modern_graph         │
│                                                                                                  │
│    70 │   │   prefix = fpath[0:-7]                                                               │
│    71 │                                                                                          │
│    72 │   if sess is None:                                                                       │
│ ❱  73 │   │   sess = get_default_session()                                                       │
│    74 │                                                                                          │
│    75 │   graph = sess.g(directed=directed)                                                      │
│    76 │   graph = (                                                                              │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/client/session.py:1480 in get_default_session           │
│                                                                                                  │
│   1477 │   Returns:                                                                              │
│   1478 │   │   The default :class:`graphscope.Session`.                                          │
│   1479 │   """                                                                                   │
│ ❱ 1480 │   return _default_session_stack.get_default()                                           │
│   1481                                                                                           │
│   1482                                                                                           │
│   1483 def get_session_by_id(handle):                                                            │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/client/session.py:1500 in get_default                   │
│                                                                                                  │
│   1497 │   def get_default(self):                                                                │
│   1498 │   │   if not self.stack:                                                                │
│   1499 │   │   │   logger.info("Creating default session ...")                                   │
│ ❱ 1500 │   │   │   sess = session(cluster_type="hosts", num_workers=1)                           │
│   1501 │   │   │   sess.as_default()                                                             │
│   1502 │   │   return self.stack[-1]                                                             │
│   1503                                                                                           │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/client/utils.py:400 in wrapper                          │
│                                                                                                  │
│   397 │   │   │   assert len(original_defaults) == len(new_defaults), "set defaults failed"      │
│   398 │   │   │   func.__defaults__ = tuple(new_defaults)                                        │
│   399 │   │   │                                                                                  │
│ ❱ 400 │   │   │   return_value = func(*args, **kwargs)                                           │
│   401 │   │   │                                                                                  │
│   402 │   │   │   # Restore original defaults.                                                   │
│   403 │   │   │   func.__defaults__ = original_defaults                                          │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/client/session.py:681 in __init__                       │
│                                                                                                  │
│    678 │   │   atexit.register(self.close)                                                       │
│    679 │   │   # create and connect session                                                      │
│    680 │   │   with CaptureKeyboardInterrupt(self.close):                                        │
│ ❱  681 │   │   │   self._connect()                                                               │
│    682 │   │                                                                                     │
│    683 │   │   self._disconnected: bool = False                                                  │
│    684                                                                                           │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/client/session.py:1064 in _connect                      │
│                                                                                                  │
│   1061 │   │   self._grpc_client = GRPCClient(                                                   │
│   1062 │   │   │   self._launcher, self._coordinator_endpoint, self._config_params["reconnect"]  │
│   1063 │   │   )                                                                                 │
│ ❱ 1064 │   │   self._grpc_client.waiting_service_ready(                                          │
│   1065 │   │   │   timeout_seconds=self._config_params["timeout_seconds"],                       │
│   1066 │   │   )                                                                                 │
│   1067                                                                                           │
│                                                                                                  │
│ /workspaces/GraphScope/python/graphscope/client/rpc.py:64 in waiting_service_ready               │
│                                                                                                  │
│    61 │   │   │   if self._launcher:                                                             │
│    62 │   │   │   │   code = self._launcher.poll()                                               │
│    63 │   │   │   │   if code is not None and code != 0:                                         │
│ ❱  64 │   │   │   │   │   raise RuntimeError(                                                    │
│    65 │   │   │   │   │   │   f"Start coordinator failed with exit code {code}"                  │
│    66 │   │   │   │   │   )                                                                      │
│    67 │   │   │   try:                                                                           │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
RuntimeError: Start coordinator failed with exit code 1

[acezen]

@sighingnow

[sighingnow]

Try pip3 install -U vineyard

[acezen]

Fixed by upgrade vineyard to 0.15.0 through pip3 install -U vineyard