packages/iSulad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sync openeuler

Browse Source 
Signed-off-by: Grooooot <isula@huawei.com>
This commit is contained in:
Grooooot 2020-01-20 10:36:04 +08:00
parent 8b32f11d19
commit e61a5e351e
249 changed files with 4006 additions and 3597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
CMakeLists.txt
View File

@ -1,5 +1,5 @@
cmake_minimum_required (VERSION 3.12.1)
project (lcrd)
cmake_minimum_required (VERSION 2.8)
project (isulad)
include(cmake/helper.cmake)
@ -17,7 +17,7 @@ execute_process(
OUTPUT_STRIP_TRAILING_WHITESPACE
)
message("-- commit id: " ${GIT_COMMIT_HASH})
add_definitions(-DLCRD_GIT_COMMIT="${GIT_COMMIT_HASH}")
add_definitions(-DISULAD_GIT_COMMIT="${GIT_COMMIT_HASH}")
execute_process(
COMMAND sh -c "date --rfc-3339 ns | sed -e 's/ /T/'"
@ -25,13 +25,13 @@ execute_process(
OUTPUT_STRIP_TRAILING_WHITESPACE
)
message("-- build time: " ${BUILD_DATE})
add_definitions(-DLCRD_BUILD_TIME="${BUILD_DATE}")
add_definitions(-DISULAD_BUILD_TIME="${BUILD_DATE}")
if (NOT LCRD_ROOT_PATH)
add_definitions(-DLCRD_ROOT_PATH="/var/lib/lcrd")
if (NOT ISULAD_ROOT_PATH)
add_definitions(-DISULAD_ROOT_PATH="/var/lib/isulad")
endif()
if (NOT LCRD_STATE_PATH)
add_definitions(-DLCRD_STATE_PATH="/var/run/lcrd")
if (NOT ISULAD_STATE_PATH)
add_definitions(-DISULAD_STATE_PATH="/var/run/isulad")
endif()
if (LIB_INSTALL_DIR)
@ -52,8 +52,8 @@ configure_file(
)
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/lcrd.pc.in"
"${CMAKE_BINARY_DIR}/conf/lcrd.pc"
"${CMAKE_CURRENT_SOURCE_DIR}/isulad.pc.in"
"${CMAKE_BINARY_DIR}/conf/isulad.pc"
)
# parse .proto files
@ -85,20 +85,20 @@ IF(ENABLE_LLT)
ENDIF(ENABLE_LLT)
# install all files
install(FILES ${CMAKE_BINARY_DIR}/conf/lcrd.pc
install(FILES ${CMAKE_BINARY_DIR}/conf/isulad.pc
DESTINATION ${LIB_INSTALL_DIR_DEFAULT}/pkgconfig PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
install(FILES src/liblcrc.h
DESTINATION include/lcrd)
install(FILES src/connect/client/lcrc_connect.h
DESTINATION include/lcrd)
install(FILES src/libisula.h
DESTINATION include/isulad)
install(FILES src/connect/client/isula_connect.h
DESTINATION include/isulad)
install(FILES src/container_def.h
DESTINATION include/lcrd)
DESTINATION include/isulad)
install(FILES src/types_def.h
DESTINATION include/lcrd)
DESTINATION include/isulad)
install(FILES src/error.h
DESTINATION include/lcrd)
DESTINATION include/isulad)
install(FILES src/engines/engine.h
DESTINATION include/lcrd)
DESTINATION include/isulad)
# install config files
set(conf_prefix "/etc")
@ -108,12 +108,12 @@ endif()
install(FILES src/contrib/config/daemon.json
DESTINATION ${conf_prefix}/isulad PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
install(FILES src/contrib/config/config.json src/contrib/config/systemcontainer_config.json
DESTINATION ${conf_prefix}/default/lcrd PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
DESTINATION ${conf_prefix}/default/isulad PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
install(FILES src/contrib/config/seccomp_default.json
DESTINATION ${conf_prefix}/isulad PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
install(FILES src/contrib/config/hooks/default.json
DESTINATION ${conf_prefix}/default/lcrd/hooks PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
DESTINATION ${conf_prefix}/default/isulad/hooks PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ GROUP_WRITE)
install(FILES src/contrib/sysmonitor/isulad-check.sh
DESTINATION ${conf_prefix}/default/lcrd PERMISSIONS OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_EXECUTE)
DESTINATION ${conf_prefix}/default/isulad PERMISSIONS OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_EXECUTE)
install(FILES src/contrib/sysmonitor/isulad-monit
DESTINATION ${conf_prefix}/sysmonitor/process PERMISSIONS OWNER_READ OWNER_WRITE)

262
Dockerfile Normal file
View File

@ -0,0 +1,262 @@
#######################################################################
##- @Copyright (C) Huawei Technologies., Ltd. 2019. All rights reserved.
# - lcr licensed under the Mulan PSL v1.
# - You can use this software according to the terms and conditions of the Mulan PSL v1.
# - You may obtain a copy of Mulan PSL v1 at:
# - http://license.coscl.org.cn/MulanPSL
# - THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
# - IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
# - PURPOSE.
# - See the Mulan PSL v1 for more details.
##- @Description: prepare compile container envrionment
##- @Author: lifeng
##- @Create: 2020-01-10
#######################################################################
# This file describes the isulad compile container image.
#
# Usage:
#
# docker build --build-arg http_proxy=YOUR_HTTP_PROXY_IF_NEEDED \
# --build-arg https_proxy=YOUR_HTTPS_PROXY_IF_NEEDED \
# -t YOUR_IMAGE_NAME -f ./Dockerfile .
FROM centos:7.6.1810
MAINTAINER LiFeng <lifeng68huawei.com>
# Install dependency package
RUN yum clean all && yum swap -y fakesystemd systemd && \
yum install -y epel-release \
yum update -y && \
yum install -y automake \
autoconf \
libtool \
make \
cmake \
which \
gdb \
strace \
rpm-build \
graphviz \
libcap \
libcap-devel \
libxslt \
docbook2X \
libselinux \
libselinux-devel \
libseccomp \
libseccomp-devel \
yajl-devel \
git \
bridge-utils \
dnsmasq \
libcgroup \
rsync \
iptables \
iproute \
net-tools \
unzip \
tar \
wget \
gtest \
gtest-devel \
gmock \
gmock-devel \
cppcheck \
python \
python-pip \
libcurl-devel \
zlib-devel \
glibc-headers \
openssl-devel \
gcc \
gcc-c++ \
hostname \
sqlite-devel \
gpgme \
gpgme-devel \
expect \
systemd-devel \
systemd-libs \
go \
CUnit \
CUnit-devel \
valgrind \
e2fsprogs
RUN pip install xlrd
RUN yum clean all && \
(cd /lib/systemd/system/sysinit.target.wants/; for i in *; \
do [ $i == systemd-tmpfiles-setup.service ] || rm -f $i; done); \
rm -f /lib/systemd/system/multi-user.target.wants/*;\
rm -f /etc/systemd/system/*.wants/*;\
rm -f /lib/systemd/system/local-fs.target.wants/*; \
rm -f /lib/systemd/system/sockets.target.wants/*udev*; \
rm -f /lib/systemd/system/sockets.target.wants/*initctl*; \
rm -f /lib/systemd/system/basic.target.wants/*;\
rm -f /lib/systemd/system/anaconda.target.wants/*;
RUN echo "export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH" >> /etc/bashrc && \
echo "export LD_LIBRARY_PATH=/usr/local/lib:/usr/lib:$LD_LIBRARY_PATH" >> /etc/bashrc && \
echo "/usr/lib" >> /etc/ld.so.conf && \
echo "/usr/local/lib" >> /etc/ld.so.conf
# disalbe sslverify
RUN git config --global http.sslverify false
# Centos has no protobuf, protobuf-devel, grpc, grpc-devel, grpc-plugin
# and we should install them manually.
# install protobuf
RUN set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/protobuf.git && \
cd protobuf && \
tar -xzvf protobuf-all-3.9.0.tar.gz && \
cd protobuf-3.9.0 && \
./autogen.sh && \
./configure && \
make -j $(nproc) && \
make install && \
ldconfig
# install c-ares
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/c-ares.git && \
cd c-ares && \
tar -xzvf c-ares-1.15.0.tar.gz && \
cd c-ares-1.15.0 && \
autoreconf -if && \
./configure --enable-shared --disable-dependency-tracking && \
make -j $(nproc) && \
make install && \
ldconfig
# install grpc
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/grpc.git && \
cd grpc && \
tar -xzvf grpc-1.22.0.tar.gz && \
cd grpc-1.22.0 && \
make -j $(nproc) && \
make install && \
ldconfig
# install libevent
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/libevent.git && \
cd libevent && \
tar -xzvf libevent-2.1.11-stable.tar.gz && \
cd libevent-2.1.11-stable && \
./autogen.sh && \
./configure && \
make -j $(nproc) && \
make install && \
ldconfig
# install libevhtp
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/libevhtp.git && \
cd libevhtp && \
tar -xzvf libevhtp-1.2.16.tar.gz && \
cd libevhtp-1.2.16 && \
patch -p1 -F1 -s < ../0001-support-dynamic-threads.patch && \
patch -p1 -F1 -s < ../0002-close-openssl.patch && \
rm -rf build && \
mkdir build && \
cd build && \
cmake -D EVHTP_BUILD_SHARED=on -D EVHTP_DISABLE_SSL=on ../ && \
make -j $(nproc) && \
make install && \
ldconfig
# install http-parser
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/http-parser.git && \
cd http-parser && \
tar -xzvf http-parser-2.9.2.tar.gz && \
cd http-parser-2.9.2 && \
make -j CFLAGS="-Wno-error" && \
make CFLAGS="-Wno-error" install && \
ldconfig
# install libwebsockets
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/libwebsockets.git && \
cd libwebsockets && \
tar -xzvf libwebsockets-2.4.2.tar.gz && \
cd libwebsockets-2.4.2 && \
patch -p1 -F1 -s < ../libwebsockets-fix-coredump.patch && \
mkdir build && \
cd build && \
cmake -DLWS_WITH_SSL=0 -DLWS_MAX_SMP=32 -DCMAKE_BUILD_TYPE=Debug ../ && \
make -j $(nproc) && \
make install && \
ldconfig
# install lxc
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/src-openeuler/lxc.git && \
cd lxc && \
./apply-patches && \
cd lxc-3.0.3 && \
./autogen.sh && \
./configure && \
make -j $(nproc) && \
make install && \
ldconfig
# install lcr
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/openeuler/lcr.git && \
cd lcr && \
mkdir build && \
cd build && \
cmake ../ && \
make -j $(nproc) && \
make install && \
ldconfig
# install clibcni
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/openeuler/clibcni.git && \
cd clibcni && \
mkdir build && \
cd build && \
cmake ../ && \
make -j $(nproc) && \
make install && \
ldconfig
# install iSulad-kit
RUN export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig:$PKG_CONFIG_PATH && \
set -x && \
cd ~ && \
git clone https://gitee.com/openeuler/iSulad-kit.git && \
cd iSulad-kit && \
./apply-patch && \
make -j $(nproc) && \
make install && \
ldconfig
VOLUME [ "/sys/fs/cgroup" ]
CMD ["/usr/sbin/init"]

16
README.md
View File

@ -17,43 +17,43 @@ yum install -y iSulad
### Run
We provide `systemd` service to start `iSulad`
```sh
systemd start lcrd # run the server with systemd command
systemd start isulad # run the server with systemd command
```
You can use direct command to start `iSulad` server：
```sh
$ sudo lcrd # run the server with default socket name and default log level and images manage function
$ sudo isulad # run the server with default socket name and default log level and images manage function
```
### Operations on containers:
`iSulad` provides command line `lcrd` to talk with server.
`iSulad` provides command line `isulad` to talk with server.
Here are some sample commands to manager containers.
List all containers in your own environment:
```sh
# list containers
$ sudo lcrc ps -a
$ sudo isula ps -a
```
Create a container with busybox named `test`
```sh
# create a container 'test' with image busybox
$ sudo lcrc create -t -n test busybox
$ sudo isula create -t -n test busybox
```
Start this container `test`
```sh
# start the container 'test'
$ sudo lcrc start test
$ sudo isula start test
```
Kill the container `test`
```sh
# kill the container 'test'
$ sudo lcrc kill test
$ sudo isula kill test
```
Remove the container `test`
```sh
# remove the container 'test'
$ sudo lcrc rm test
$ sudo isula rm test
```
### Build from source

12
cmake/options.cmake
View File

@ -26,22 +26,22 @@ if (ENABLE_OPENSSL_VERIFY STREQUAL "ON")
set(OPENSSL_VERIFY 1)
endif()
option(PACKAGE "set lcrd package" ON)
option(PACKAGE "set isulad package" ON)
if (PACKAGE STREQUAL "ON")
set(LCRD_PACKAGE "iSulad")
set(ISULAD_PACKAGE "iSulad")
endif()
option(VERSION "set lcrd version" ON)
option(VERSION "set isulad version" ON)
if (VERSION STREQUAL "ON")
set(LCRD_VERSION "1.1.5")
set(ISULAD_VERSION "1.1.9")
endif()
option(DEBUG "set lcrd gcc option" ON)
option(DEBUG "set isulad gcc option" ON)
if (DEBUG STREQUAL "ON")
add_definitions("-g -O2")
endif()
option(GCOV "set lcrd gcov option" OFF)
option(GCOV "set isulad gcov option" OFF)
if (GCOV STREQUAL "ON")
set(ISULAD_GCOV "ON")
endif()

3
cmake/set_build_flags.cmake
View File

@ -1,7 +1,10 @@
# set common FLAGS
set(CMAKE_C_FLAGS "-fPIC -fstack-protector-all -D_FORTIFY_SOURCE=2 -O2 -Wall -Werror -rdynamic")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__FILENAME__='\"$(subst ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"'")
if (GRPC_CONNECTOR OR ENABLE_OCI_IMAGE)
set(CMAKE_CXX_FLAGS "-fPIC -std=c++11 -fstack-protector-all -D_FORTIFY_SOURCE=2 -O2 -Wall -Werror")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILENAME__='\"$(subst ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"'")
endif()
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-E -Wl,-z,relro -Wl,-z,now -Wl,-z,noexecstack -Wtrampolines -fPIE -pie -shared -pthread")
set(CMAKE_EXE_LINKER_FLAGS "-Wl,-E -Wl,-z,relro -Wl,-z,now -Wl,-z,noexecstack -Wtrampolines -fPIE -pie")

2
config.h.in
View File

@ -1 +1 @@
#cmakedefine VERSION "@LCRD_VERSION@"
#cmakedefine VERSION "@ISULAD_VERSION@"

63
docs/build_guide.md
View File

@ -1,12 +1,18 @@
## Install Dependencies
# Build iSulad from source
If you intend to contribute on iSulad. Thanks for your effort. Every contribution is very appreciated for us.
## Build iSulad based on openEuler distribution
If you use the openEuler distribution, you can easily install various dependent packages via yum.
### Install Dependencies
```sh
$ sudo yum install -y cmake gcc-c++ systemd-devel yajl-devel libcurl libcurl-devel clibcni clibcni-devel protobuf-devel grpc-devel grpc-plugins http-parser-devel libwebsockets-devel libevhtp-devel libevent-devel lcr lxc-devel
```
## Build steps:
### Build steps:
Run the cmds under the iSulad source directory
```sh
@ -17,3 +23,52 @@ $ sudo make
$ sudo make install
```
## Via Docker container
#### Build image
You can build `iSulad` via a Linux-based Docker container. You can build an image from the`Dockerfile` in the source directory. From the iSulad source root directory you can run the following command to make your image.
```sh
$ sudo docker build --build-arg http_proxy=YOUR_HTTP_PROXY_IF_NEED
--build-arg https_proxy=YOUR_HTTPS_PROXY_IF_NEED \
-t YOUR_IMAGE_NAME -f ./Dockerfile .
```
#### Prepare root directory for the iSulad
Let's prepare a root directory on host, and we will mount this directory into the container. This directory be used by `iSulad` in container.
```sh
$ sudo mkdir -p /var/lib/isulad
```
#### Build iSulad in container
Let's suppose that you built an image called `iSulad:dev`.
Then from the iSulad source root directory you can run the following command:
```sh
$ sudo docker run -tid --name YOUR_CONTAINER_NAME -v /var/lib/isulad:/var/lib/isulad -v `pwd`:/src/isulad --privileged iSulad:dev
```
Let's suppose that you run an container named `iSulad_build`. Then you can use the following commands to build iSulad in your container `iSulad_build`:
```bash
// enter the container
$ sudo docker exec -it iSulad_build bash
// Now you enter the container, so build iSulad in the container by following commands
# cd /src/isulad
# mkdir build
# cd build
# cmake ..
# make
# make install
```
Now You can use direct command to start `iSulad` server in the container：
```sh
$ sudo isulad # run the server with default socket name and default log level and images manage function
```

115
iSulad.spec
View File

@ -1,5 +1,5 @@
%global _version 1.1.5
%global _release 20200106.022952.git939935db
%global _version 1.1.9
%global _release 20200120.104710.gitdf7191f2
%global is_systemd 1
%global debug_package %{nil}
@ -8,14 +8,14 @@ Version: %{_version}
Release: %{_release}
Summary: Lightweight Container Runtime Daemon
License: Mulan PSL v1
URL: lcrd
URL: isulad
Source: iSulad-1.0.tar.gz
BuildRoot: {_tmppath}/iSulad-%{version}
ExclusiveArch: x86_64 aarch64
%ifarch x86_64 aarch64
Provides: libhttpclient.so()(64bit)
Provides: liblcrc.so()(64bit)
Provides: libisula.so()(64bit)
%endif
%if 0%{?is_systemd}
@ -60,120 +60,139 @@ cd build
rm -rf %{buildroot}
cd build
install -d $RPM_BUILD_ROOT/%{_libdir}
install -m 0644 ./src/liblcrc.so %{buildroot}/%{_libdir}/liblcrc.so
install -m 0644 ./src/libisula.so %{buildroot}/%{_libdir}/libisula.so
install -m 0644 ./src/http/libhttpclient.so %{buildroot}/%{_libdir}/libhttpclient.so
install -d $RPM_BUILD_ROOT/%{_libdir}/pkgconfig
install -m 0640 ./conf/lcrd.pc %{buildroot}/%{_libdir}/pkgconfig/lcrd.pc
install -m 0640 ./conf/isulad.pc %{buildroot}/%{_libdir}/pkgconfig/isulad.pc
install -d $RPM_BUILD_ROOT/%{_bindir}
install -m 0755 ./src/lcrc %{buildroot}/%{_bindir}/lcrc
install -m 0755 ./src/lcrd %{buildroot}/%{_bindir}/lcrd
install -m 0755 ./src/isula %{buildroot}/%{_bindir}/isula
install -m 0755 ./src/isulad %{buildroot}/%{_bindir}/isulad
install -d $RPM_BUILD_ROOT/%{_includedir}/lcrd
install -m 0644 ../src/liblcrc.h %{buildroot}/%{_includedir}/lcrd/liblcrc.h
install -m 0644 ../src/connect/client/lcrc_connect.h %{buildroot}/%{_includedir}/lcrd/lcrc_connect.h
install -m 0644 ../src/container_def.h %{buildroot}/%{_includedir}/lcrd/container_def.h
install -m 0644 ../src/types_def.h %{buildroot}/%{_includedir}/lcrd/types_def.h
install -m 0644 ../src/error.h %{buildroot}/%{_includedir}/lcrd/error.h
install -m 0644 ../src/engines/engine.h %{buildroot}/%{_includedir}/lcrd/engine.h
install -d $RPM_BUILD_ROOT/%{_includedir}/isulad
install -m 0644 ../src/libisula.h %{buildroot}/%{_includedir}/isulad/libisula.h
install -m 0644 ../src/connect/client/isula_connect.h %{buildroot}/%{_includedir}/isulad/isula_connect.h
install -m 0644 ../src/container_def.h %{buildroot}/%{_includedir}/isulad/container_def.h
install -m 0644 ../src/types_def.h %{buildroot}/%{_includedir}/isulad/types_def.h
install -m 0644 ../src/error.h %{buildroot}/%{_includedir}/isulad/error.h
install -m 0644 ../src/engines/engine.h %{buildroot}/%{_includedir}/isulad/engine.h
install -d $RPM_BUILD_ROOT/%{_sysconfdir}/isulad
install -m 0640 ../src/contrib/config/daemon.json %{buildroot}/%{_sysconfdir}/isulad/daemon.json
install -m 0640 ../src/contrib/config/seccomp_default.json %{buildroot}/%{_sysconfdir}/isulad/seccomp_default.json
install -d $RPM_BUILD_ROOT/%{_sysconfdir}/default/lcrd
install -m 0640 ../src/contrib/config/config.json %{buildroot}/%{_sysconfdir}/default/lcrd/config.json
install -m 0640 ../src/contrib/config/systemcontainer_config.json %{buildroot}/%{_sysconfdir}/default/lcrd/systemcontainer_config.json
install -m 0550 ../src/contrib/sysmonitor/isulad-check.sh %{buildroot}/%{_sysconfdir}/default/lcrd/isulad-check.sh
install -d $RPM_BUILD_ROOT/%{_sysconfdir}/default/isulad
install -m 0640 ../src/contrib/config/config.json %{buildroot}/%{_sysconfdir}/default/isulad/config.json
install -m 0640 ../src/contrib/config/systemcontainer_config.json %{buildroot}/%{_sysconfdir}/default/isulad/systemcontainer_config.json
install -m 0550 ../src/contrib/sysmonitor/isulad-check.sh %{buildroot}/%{_sysconfdir}/default/isulad/isulad-check.sh
mkdir -p $RPM_BUILD_ROOT/%{_sysconfdir}/sysmonitor/process
cp ../src/contrib/sysmonitor/isulad-monit $RPM_BUILD_ROOT/etc/sysmonitor/process
install -d $RPM_BUILD_ROOT/%{_sysconfdir}/default/lcrd/hooks
install -m 0640 ../src/contrib/config/hooks/default.json %{buildroot}/%{_sysconfdir}/default/lcrd/hooks/default.json
install -d $RPM_BUILD_ROOT/%{_sysconfdir}/default/isulad/hooks
install -m 0640 ../src/contrib/config/hooks/default.json %{buildroot}/%{_sysconfdir}/default/isulad/hooks/default.json
install -d $RPM_BUILD_ROOT/%{_sysconfdir}/sysconfig
install -p -m 0640 ../src/contrib/config/iSulad.sysconfig $RPM_BUILD_ROOT/%{_sysconfdir}/sysconfig/iSulad
%if 0%{?is_systemd}
install -d $RPM_BUILD_ROOT/%{_unitdir}
install -p -m 0640 ../src/contrib/init/lcrd.service $RPM_BUILD_ROOT/%{_unitdir}/lcrd.service
install -p -m 0640 ../src/contrib/init/isulad.service $RPM_BUILD_ROOT/%{_unitdir}/isulad.service
%else
install -d $RPM_BUILD_ROOT/%{_initddir}
install -p -m 0640 ../src/contrib/init/lcrd.init $RPM_BUILD_ROOT/%{_initddir}/lcrd.init
install -p -m 0640 ../src/contrib/init/isulad.init $RPM_BUILD_ROOT/%{_initddir}/isulad.init
%endif
%clean
rm -rf %{buildroot}
%pre
# support update from lcrd to isulad, will remove in next version
%if 0%{?is_systemd}
systemctl stop lcrd
systemctl disable lcrd
if [ -e %{_sysconfdir}/isulad/daemon.json ];then
sed -i 's#/etc/default/lcrd/hooks#/etc/default/isulad/hooks#g' %{_sysconfdir}/isulad/daemon.json
fi
%else
/sbin/chkconfig --del lcrd
%endif
%post
if ! getent group lcrd > /dev/null; then
groupadd --system lcrd
if ! getent group isulad > /dev/null; then
groupadd --system isulad
fi
if [ "$1" = "1" ]; then
%if 0%{?is_systemd}
systemctl enable lcrd
systemctl start lcrd
systemctl enable isulad
systemctl start isulad
%else
/sbin/chkconfig --add lcrd
/sbin/chkconfig --add isulad
%endif
elif [ "$1" = "2" ]; then
%if 0%{?is_systemd}
systemctl status lcrd | grep 'Active:' | grep 'running'
# support update from lcrd to isulad, will remove in next version
if [ -e %{_unitdir}/lcrd.service.rpmsave ]; then
mv %{_unitdir}/lcrd.service.rpmsave %{_unitdir}/isulad.service
sed -i 's/lcrd/isulad/g' %{_unitdir}/isulad.service
fi
systemctl status isulad | grep 'Active:' | grep 'running'
if [ $? -eq 0 ]; then
systemctl restart lcrd
systemctl restart isulad
else
systemctl start isulad
fi
%else
/sbin/service lcrd status | grep 'Active:' | grep 'running'
/sbin/service isulad status | grep 'Active:' | grep 'running'
if [ $? -eq 0 ]; then
/sbin/service lcrd restart
/sbin/service isulad restart
fi
%endif
fi
if ! getent group lcrd > /dev/null; then
groupadd --system lcrd
if ! getent group isulad > /dev/null; then
groupadd --system isulad
fi
%preun
%if 0%{?is_systemd}
%systemd_preun lcrd
%systemd_preun isulad
%else
if [ $1 -eq 0 ] ; then
/sbin/service lcrd stop >/dev/null 2>&1
/sbin/chkconfig --del lcrd
/sbin/service isulad stop >/dev/null 2>&1
/sbin/chkconfig --del isulad
fi
%endif
%postun
%if 0%{?is_systemd}
%systemd_postun_with_restart lcrd
%systemd_postun_with_restart isulad
%else
if [ "$1" -ge "1" ] ; then
/sbin/service lcrd condrestart >/dev/null 2>&1 || :
/sbin/service isulad condrestart >/dev/null 2>&1 || :
fi
%endif
%files
%attr(0600,root,root) %{_sysconfdir}/sysmonitor/process/isulad-monit
%attr(0550,root,root) %{_sysconfdir}/default/lcrd/isulad-check.sh
%attr(0550,root,root) %{_sysconfdir}/default/isulad/isulad-check.sh
%defattr(0640,root,root,0750)
%{_sysconfdir}/isulad
%{_sysconfdir}/isulad/*
%{_sysconfdir}/default/*
%defattr(-,root,root,-)
%if 0%{?is_systemd}
%{_unitdir}/lcrd.service
%attr(0640,root,root) %{_unitdir}/lcrd.service
%{_unitdir}/isulad.service
%attr(0640,root,root) %{_unitdir}/isulad.service
%else
%{_initddir}/lcrd.init
%attr(0640,root,root) %{_initddir}/lcrd.init
%{_initddir}/isulad.init
%attr(0640,root,root) %{_initddir}/isulad.init
%endif
%{_includedir}/lcrd/*
%{_includedir}/isulad/*
%attr(0755,root,root) %{_libdir}/pkgconfig
%attr(0640,root,root) %{_libdir}/pkgconfig/lcrd.pc
%attr(0640,root,root) %{_libdir}/pkgconfig/isulad.pc
%defattr(0550,root,root,0750)
%{_bindir}/*
%{_libdir}/*
@ -183,7 +202,7 @@ fi
%config(noreplace,missingok) %{_sysconfdir}/sysconfig/iSulad
%config(noreplace,missingok) %{_sysconfdir}/isulad/daemon.json
%if 0%{?is_systemd}
%config(noreplace,missingok) %{_unitdir}/lcrd.service
%config(noreplace,missingok) %{_unitdir}/isulad.service
%else
%config(noreplace,missingok) %{_initddir}/lcrd.init
%config(noreplace,missingok) %{_initddir}/isulad.init
%endif

6
lcrd.pc.in → isulad.pc.in
View File

@ -3,10 +3,10 @@ libdir=@CMAKE_INSTALL_PREFIX@/lib
localstatedir=@CMAKE_INSTALL_PREFIX@/var
includedir=@CMAKE_INSTALL_PREFIX@/include
Name: liblcrc
Name: libisula
Description: light-weighted container runtime daemon library
Version: @LCRD_VERSION@
Version: @ISULAD_VERSION@
URL: iSulad
Libs: -L@CMAKE_INSTALL_PREFIX@/lib -llcrc
Libs: -L@CMAKE_INSTALL_PREFIX@/lib -lisula
Cflags: -I@CMAKE_INSTALL_PREFIX@/include

84
src/CMakeLists.txt
View File

@ -103,47 +103,47 @@ list(REMOVE_DUPLICATES SHARED_SRCS)
add_subdirectory(http)
# ------ build liblcrc ------
# ------ build libisula ------
if (OPENSSL_VERIFY)
list(APPEND CONNECTOR ${CMAKE_CURRENT_SOURCE_DIR}/http/certificate.c)
endif()
add_library(liblcrc ${LIBTYPE}
${CMAKE_CURRENT_SOURCE_DIR}/liblcrc.c
add_library(libisula ${LIBTYPE}
${CMAKE_CURRENT_SOURCE_DIR}/libisula.c
${CMAKE_CURRENT_SOURCE_DIR}/pack_config.c
${CONNECTOR}
${SHARED_SRCS}
)
target_include_directories(liblcrc PUBLIC
target_include_directories(libisula PUBLIC
${SHARED_INCS}
${CONNECTOR_INCS}
${CMAKE_CURRENT_SOURCE_DIR}/http
)
# set liblcrc FLAGS
set_target_properties(liblcrc PROPERTIES PREFIX "")
target_link_libraries(liblcrc ${LIBYAJL_LIBRARY} ${LIBSECUREC_LIBRARY})
# set libisula FLAGS
set_target_properties(libisula PROPERTIES PREFIX "")
target_link_libraries(libisula ${LIBYAJL_LIBRARY} ${LIBSECUREC_LIBRARY})
if (GRPC_CONNECTOR)
target_link_libraries(liblcrc -Wl,--as-needed -lstdc++ -lcrypto)
target_link_libraries(liblcrc -Wl,--as-needed ${PROTOBUF_LIBRARY})
target_link_libraries(liblcrc -Wl,--no-as-needed ${GRPC_PP_REFLECTION_LIBRARY} ${GRPC_PP_LIBRARY} ${GRPC_LIBRARY} ${GPR_LIBRARY})
target_link_libraries(libisula -Wl,--as-needed -lstdc++ -lcrypto)
target_link_libraries(libisula -Wl,--as-needed ${PROTOBUF_LIBRARY})
target_link_libraries(libisula -Wl,--no-as-needed ${GRPC_PP_REFLECTION_LIBRARY} ${GRPC_PP_LIBRARY} ${GRPC_LIBRARY} ${GPR_LIBRARY})
else()
target_link_libraries(liblcrc ${EVHTP_LIBRARY} ${EVENT_LIBRARY} ${ZLIB_LIBRARY} -ldl libhttpclient)
target_link_libraries(libisula ${EVHTP_LIBRARY} ${EVENT_LIBRARY} ${ZLIB_LIBRARY} -ldl libhttpclient)
endif()
# ------ build liblcrc finish -----
# ------ build libisula finish -----
add_subdirectory(cmd)
# ------ build lcrc -------
add_executable(lcrc
${LCRC_SRCS}
# ------ build isula -------
add_executable(isula
${ISULA_SRCS}
)
target_include_directories(lcrc PUBLIC ${LCRC_INCS} ${SHARED_INCS})
target_link_libraries(lcrc liblcrc -lpthread)
# ------ build lcrc finish -------
target_include_directories(isula PUBLIC ${ISULA_INCS} ${SHARED_INCS})
target_link_libraries(isula libisula -lpthread)
# ------ build isula finish -------
# ------ build lcrd -------
# ------ build isulad -------
add_subdirectory(services)
add_subdirectory(image)
add_subdirectory(runtime)
@ -170,9 +170,9 @@ add_subdirectory(plugin)
add_subdirectory(map)
add_subdirectory(config)
add_executable(lcrd
add_executable(isulad
${CONNECT_SOCKET} ${SHARED_SRCS}
${LCRD_SRCS} ${SERVICES_SRCS}
${ISULAD_SRCS} ${SERVICES_SRCS}
${HTTP_SRCS}
${ENGINES_SRCS}
${IMAGE_SRCS}
@ -181,19 +181,19 @@ add_executable(lcrd
${MAP_SRCS} ${CONFIG_SRCS}
${CMAKE_CURRENT_SOURCE_DIR}/filters.c
${CMAKE_CURRENT_SOURCE_DIR}/namespace.c
${CMAKE_CURRENT_SOURCE_DIR}/liblcrd.c
${CMAKE_CURRENT_SOURCE_DIR}/libisulad.c
${CMAKE_CURRENT_SOURCE_DIR}/sysctl_tools.c
${WEBSOCKET_SERVICE_SRCS}
)
target_include_directories(lcrd PUBLIC
target_include_directories(isulad PUBLIC
${SHARED_INCS}
${CONNECT_SOCKET_INCS}
${SERVICES_INCS}
${IMAGE_INCS}
${RUNTIME_INCS}
${ENGINES_INCS}
${LCRD_INCS}
${ISULAD_INCS}
${CMAKE_CURRENT_SOURCE_DIR}/plugin
${CMAKE_CURRENT_SOURCE_DIR}/map
${CMAKE_CURRENT_SOURCE_DIR}/config
@ -201,41 +201,41 @@ target_include_directories(lcrd PUBLIC
${WEBSOCKET_SERVICE_INCS}
)
target_link_libraries(lcrd ${LIBYAJL_LIBRARY} ${LIBSECUREC_LIBRARY} ${SYSTEMD_LIBRARY})
target_link_libraries(lcrd -ldl ${ZLIB_LIBRARY} -lpthread libhttpclient)
target_link_libraries(isulad ${LIBYAJL_LIBRARY} ${LIBSECUREC_LIBRARY} ${SYSTEMD_LIBRARY})
target_link_libraries(isulad -ldl ${ZLIB_LIBRARY} -lpthread libhttpclient)
if (ENABLE_EMBEDDED_IMAGE)
target_link_libraries(lcrd ${SQLITE3_LIBRARY})
target_link_libraries(isulad ${SQLITE3_LIBRARY})
endif()
if (GRPC_CONNECTOR)
message("GRPC iSulad")
target_link_libraries(lcrd -Wl,--as-needed -lstdc++ -lcrypto)
target_link_libraries(lcrd -Wl,--as-needed ${PROTOBUF_LIBRARY})
target_link_libraries(lcrd -Wl,--no-as-needed ${GRPC_PP_REFLECTION_LIBRARY} ${GRPC_PP_LIBRARY} ${GRPC_LIBRARY} ${GPR_LIBRARY})
target_link_libraries(lcrd ${CLIBCNI_LIBRARY} ${WEBSOCKET_LIBRARY})
target_link_libraries(isulad -Wl,--as-needed -lstdc++ -lcrypto)
target_link_libraries(isulad -Wl,--as-needed ${PROTOBUF_LIBRARY})
target_link_libraries(isulad -Wl,--no-as-needed ${GRPC_PP_REFLECTION_LIBRARY} ${GRPC_PP_LIBRARY} ${GRPC_LIBRARY} ${GPR_LIBRARY})
target_link_libraries(isulad ${CLIBCNI_LIBRARY} ${WEBSOCKET_LIBRARY})
else()
message("Restful iSulad")
target_link_libraries(lcrd ${EVHTP_LIBRARY} ${EVENT_LIBRARY})
target_link_libraries(isulad ${EVHTP_LIBRARY} ${EVENT_LIBRARY})
endif()
if (ENABLE_OCI_IMAGE)
target_link_libraries(lcrd -Wl,--as-needed -lstdc++)
target_link_libraries(lcrd -Wl,--as-needed ${PROTOBUF_LIBRARY})
target_link_libraries(lcrd -Wl,--no-as-needed ${GRPC_PP_REFLECTION_LIBRARY} ${GRPC_PP_LIBRARY} ${GRPC_LIBRARY} ${GPR_LIBRARY})
target_link_libraries(isulad -Wl,--as-needed -lstdc++)
target_link_libraries(isulad -Wl,--as-needed ${PROTOBUF_LIBRARY})
target_link_libraries(isulad -Wl,--no-as-needed ${GRPC_PP_REFLECTION_LIBRARY} ${GRPC_PP_LIBRARY} ${GRPC_LIBRARY} ${GPR_LIBRARY})
endif()
if (ISULAD_GCOV)
target_link_libraries(lcrc -lgcov)
target_link_libraries(liblcrc -lgcov)
target_link_libraries(lcrd -lgcov)
target_link_libraries(isula -lgcov)
target_link_libraries(libisula -lgcov)
target_link_libraries(isulad -lgcov)
endif()
# ------ build lcrd finish -------
# ------ build isulad finish -------
# ------ install binary --------
install(TARGETS liblcrc
install(TARGETS libisula
LIBRARY DESTINATION ${LIB_INSTALL_DIR_DEFAULT} PERMISSIONS OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_EXECUTE)
install(TARGETS lcrc
install(TARGETS isula
RUNTIME DESTINATION bin PERMISSIONS OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_EXECUTE)
install(TARGETS lcrd
install(TARGETS isulad
RUNTIME DESTINATION bin PERMISSIONS OWNER_READ OWNER_EXECUTE GROUP_READ GROUP_EXECUTE)

24
src/api/image_client/isula_image.proto
View File

@ -1,5 +1,5 @@
// #######################################################################
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019. All rights reserved.
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019-2020. All rights reserved.
// # - iSulad licensed under the Mulan PSL v1.
// # - You can use this software according to the terms and conditions of the Mulan PSL v1.
// # - You may obtain a copy of Mulan PSL v1 at:
@ -10,8 +10,28 @@
// # - See the Mulan PSL v1 for more details.
// ##- @Description: generate grpc
// ##- @Author: wujing
// ##- @Create: 2019-04-25
// ##- @Create: 2020-01-26
// #######################################################################
/*
Since some of this code is derived from Kubernetes, their copyright
is retained here....
Copyright 2018 The Kubernetes Authors.
Licensed 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.
*/
// To regenerate api.pb.go run hack/update-generated-runtime.sh
syntax = 'proto3';

27
src/api/services/health/health.proto
View File

@ -1,5 +1,5 @@
// #######################################################################
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019. All rights reserved.
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019-2020. All rights reserved.
// # - iSulad licensed under the Mulan PSL v1.
// # - You can use this software according to the terms and conditions of the Mulan PSL v1.
// # - You may obtain a copy of Mulan PSL v1 at:
@ -9,9 +9,30 @@
// # - PURPOSE.
// # - See the Mulan PSL v1 for more details.
// ##- @Description: generate grpc
// ##- @Author: wujing
// ##- @Create: 2019-04-25
// ##- @Author: tanyifeng
// ##- @Create: 2020-01-16
// #######################################################################
//
// Since some of this code is derived from grpc, their copyright
// is retained here....
//
// Copyright 2015 The gRPC Authors
//
// Licensed 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.
// The canonical version of this proto can be found at
// https://github.com/grpc/grpc-proto/blob/master/grpc/health/v1/health.proto
syntax = "proto3";
option optimize_for = CODE_SIZE;

25
src/api/services/images/images.proto
View File

@ -1,5 +1,5 @@
// #######################################################################
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019. All rights reserved.
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019-2020. All rights reserved.
// # - iSulad licensed under the Mulan PSL v1.
// # - You can use this software according to the terms and conditions of the Mulan PSL v1.
// # - You may obtain a copy of Mulan PSL v1 at:
@ -10,8 +10,29 @@
// # - See the Mulan PSL v1 for more details.
// ##- @Description: generate grpc
// ##- @Author: wujing
// ##- @Create: 2019-04-25
// ##- @Create: 2020-01-16
// #######################################################################
/*
Since some of this code is derived from containerd, their copyright
is retained here....
Copyright 2013-2016 Docker, Inc.
Licensed 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.
*/
syntax = "proto3";
option optimize_for = CODE_SIZE;

24
src/api/types/descriptor.proto
View File

@ -1,5 +1,5 @@
// #######################################################################
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019. All rights reserved.
// ##- @Copyright (C) Huawei Technologies., Ltd. 2019-2020. All rights reserved.
// # - iSulad licensed under the Mulan PSL v1.
// # - You can use this software according to the terms and conditions of the Mulan PSL v1.
// # - You may obtain a copy of Mulan PSL v1 at:
@ -10,8 +10,28 @@
// # - See the Mulan PSL v1 for more details.
// ##- @Description: generate grpc
// ##- @Author: wujing
// ##- @Create: 2019-04-25
// ##- @Create: 2019-01-16
// #######################################################################
/*
Since some of this code is derived from containerd, their copyright
is retained here....
Copyright 2013-2016 Docker, Inc.
Licensed 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.
*/
syntax = "proto3";
option optimize_for = CODE_SIZE;

12
src/cmd/CMakeLists.txt
View File

@ -1,10 +1,10 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} comm_srcs)
add_subdirectory(lcrc)
set(LCRC_SRCS ${comm_srcs} ${CMD_LCRC_SRCS} PARENT_SCOPE)
set(LCRC_INCS ${CMAKE_CURRENT_SOURCE_DIR} ${CMD_LCRC_INCS} PARENT_SCOPE)
add_subdirectory(isula)
set(ISULA_SRCS ${comm_srcs} ${CMD_ISULA_SRCS} PARENT_SCOPE)
set(ISULA_INCS ${CMAKE_CURRENT_SOURCE_DIR} ${CMD_ISULA_INCS} PARENT_SCOPE)
add_subdirectory(lcrd)
set(LCRD_SRCS ${comm_srcs} ${CMD_LCRD_SRCS} PARENT_SCOPE)
set(LCRD_INCS ${CMAKE_CURRENT_SOURCE_DIR} ${CMD_LCRD_INCS} PARENT_SCOPE)
add_subdirectory(isulad)
set(ISULAD_SRCS ${comm_srcs} ${CMD_ISULAD_SRCS} PARENT_SCOPE)
set(ISULAD_INCS ${CMAKE_CURRENT_SOURCE_DIR} ${CMD_ISULAD_INCS} PARENT_SCOPE)

10
src/cmd/commander.c
View File

@ -21,14 +21,14 @@
#include <assert.h>
#include <regex.h>
#include <limits.h>
#include "liblcrd.h"
#include "libisulad.h"
#include "utils.h"
#include "log.h"
void command_help_lcrd_head()
void command_help_isulad_head()
{
fprintf(stdout, "lcrd\n\nlightweight container runtime daemon\n");
fprintf(stdout, "isulad\n\nlightweight container runtime daemon\n");
}
int compare_options(const void *s1, const void *s2)
@ -93,8 +93,8 @@ void command_help(command_t *self)
progname++;
}
if (self->type != NULL && strcmp(self->type, "lcrd") == 0) {
command_help_lcrd_head();
if (self->type != NULL && strcmp(self->type, "isulad") == 0) {
command_help_isulad_head();
}
fprintf(stdout, "\nUsage: %s %s\n\n", progname, self->usage);
fprintf(stdout, "%s\n\n", self->description);

18
src/cmd/lcrc/CMakeLists.txt → src/cmd/isula/CMakeLists.txt
View File

@ -4,19 +4,19 @@ add_subdirectory(information)
add_subdirectory(extend)
add_subdirectory(stream)
add_subdirectory(images)
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} lcrc_srcs)
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} isula_srcs)
set(CMD_LCRC_SRCS
${lcrc_srcs}
${LCRC_BASE_SRCS}
${LCRC_EXTEND_SRCS}
${LCRC_IMAGES_SRCS}
${LCRC_INFORMATION_SRCS}
${LCRC_STREAM_SRCS}
set(CMD_ISULA_SRCS
${isula_srcs}
${ISULA_BASE_SRCS}
${ISULA_EXTEND_SRCS}
${ISULA_IMAGES_SRCS}
${ISULA_INFORMATION_SRCS}
${ISULA_STREAM_SRCS}
PARENT_SCOPE
)
set(CMD_LCRC_INCS
set(CMD_ISULA_INCS
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/base
${CMAKE_CURRENT_SOURCE_DIR}/extend

2
src/cmd/lcrc/arguments.c → src/cmd/isula/arguments.c
View File

@ -252,7 +252,7 @@ void print_common_help()
void client_print_error(uint32_t cc, uint32_t server_errono, const char *errmsg)
{
switch (server_errono) {
case LCRD_SUCCESS:
case ISULAD_SUCCESS:
if (errmsg != NULL) {
COMMAND_ERROR("%s", errmsg);
}

12
src/cmd/lcrc/arguments.h → src/cmd/isula/arguments.h
View File

@ -13,8 +13,8 @@
* Description: provide container client arguments definition
******************************************************************************/
#ifndef __LCRC_ARGUMENTS_H
#define __LCRC_ARGUMENTS_H
#ifndef __ISULA_ARGUMENTS_H
#define __ISULA_ARGUMENTS_H
#include <stdbool.h>
#include <getopt.h>
@ -24,7 +24,7 @@
#include "commander.h"
#include "container_def.h"
#include "json_common.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
/* max arguments can be specify in client */
#define MAX_CLIENT_ARGS 1000
@ -231,7 +231,7 @@ struct client_arguments {
/* notes: we should free the mem in custom_conf by hand */
struct custom_configs custom_conf;
// lcrc run;
// isula run;
bool detach;
bool interactive;
@ -342,7 +342,7 @@ extern int client_arguments_init(struct client_arguments *args);
extern void client_arguments_free(struct client_arguments *args);
extern void lcrd_screen_print(uint32_t cc, uint32_t server_errono,
extern void isulad_screen_print(uint32_t cc, uint32_t server_errono,
struct client_arguments *args);
@ -350,5 +350,5 @@ extern void client_print_error(uint32_t cc, uint32_t server_errono, const char *
extern client_connect_config_t get_connect_config(const struct client_arguments *args);
#endif /* __LCRC_ARGUMENTS_H */
#endif /* __ISULA_ARGUMENTS_H */

7
src/cmd/isula/base/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} isula_base_srcs)
set(ISULA_BASE_SRCS
${isula_base_srcs}
PARENT_SCOPE
)

146
src/cmd/lcrc/base/create.c → src/cmd/isula/base/create.c
View File

@ -28,10 +28,10 @@
#include "console.h"
#include "create.h"
#include "commands.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "path.h"
#include "pull.h"
#include "liblcrd.h"
#include "libisulad.h"
const char g_cmd_create_desc[] = "Create a new container";
const char g_cmd_create_usage[] = "create [OPTIONS] --external-rootfs=PATH|IMAGE [COMMAND] [ARG...]";
@ -48,7 +48,7 @@ struct client_arguments g_cmd_create_args = {
.custom_conf.health_retries = 0,
};
static void request_pack_host_config_limit(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_config_limit(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* pids limit */
if (args->custom_conf.pids_limit != 0) {
@ -60,7 +60,7 @@ static void request_pack_host_config_limit(const struct client_arguments *args,
}
}
static int request_pack_host_config_storage_opts(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static int request_pack_host_config_storage_opts(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
size_t i = 0;
size_t len = 0;
@ -95,7 +95,7 @@ static int request_pack_host_config_storage_opts(const struct client_arguments *
return 0;
}
static int request_pack_host_config_sysctls(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static int request_pack_host_config_sysctls(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
size_t i = 0;
size_t len = 0;
@ -127,7 +127,7 @@ static int request_pack_host_config_sysctls(const struct client_arguments *args,
return 0;
}
static int request_pack_host_config_cgroup(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static int request_pack_host_config_cgroup(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
if (args == NULL) {
return -1;
@ -177,7 +177,7 @@ static int request_pack_host_config_cgroup(const struct client_arguments *args,
return 0;
}
static int util_env_set_lcrd_enable_plugins(char ***penv, const size_t *penv_len, const char *names)
static int util_env_set_isulad_enable_plugins(char ***penv, const size_t *penv_len, const char *names)
{
size_t env_len;
size_t len = 0;
@ -193,14 +193,14 @@ static int util_env_set_lcrd_enable_plugins(char ***penv, const size_t *penv_len
env = *penv;
env_len = *penv_len;
arr[0] = LCRD_ENABLE_PLUGINS;
arr[0] = ISULAD_ENABLE_PLUGINS;
arr[1] = "=";
arr[2] = names;
len = 3;
val = util_env_get_val(env, env_len, LCRD_ENABLE_PLUGINS, strlen(LCRD_ENABLE_PLUGINS));
val = util_env_get_val(env, env_len, ISULAD_ENABLE_PLUGINS, strlen(ISULAD_ENABLE_PLUGINS));
if (val != NULL && strlen(val) != 0) {
arr[3] = LCRD_ENABLE_PLUGINS_SEPERATOR;
arr[3] = ISULAD_ENABLE_PLUGINS_SEPERATOR;
arr[4] = val;
len = 5;
}
@ -210,7 +210,7 @@ static int util_env_set_lcrd_enable_plugins(char ***penv, const size_t *penv_len
goto failed;
}
if (util_env_set_val(penv, penv_len, LCRD_ENABLE_PLUGINS, strlen(LCRD_ENABLE_PLUGINS), kv)) {
if (util_env_set_val(penv, penv_len, ISULAD_ENABLE_PLUGINS, strlen(ISULAD_ENABLE_PLUGINS), kv)) {
goto failed;
}
@ -224,7 +224,7 @@ failed:
return -1;
}
static int request_pack_custom_env(struct client_arguments *args, lcrc_container_config_t *conf)
static int request_pack_custom_env(struct client_arguments *args, isula_container_config_t *conf)
{
int ret = 0;
char *pe = NULL;
@ -244,10 +244,10 @@ static int request_pack_custom_env(struct client_arguments *args, lcrc_container
}
if (args->custom_conf.accel != NULL) {
pe = util_env_get_val(conf->env, conf->env_len, LCRD_ENABLE_PLUGINS, strlen(LCRD_ENABLE_PLUGINS));
pe = util_env_get_val(conf->env, conf->env_len, ISULAD_ENABLE_PLUGINS, strlen(ISULAD_ENABLE_PLUGINS));
if (pe == NULL) {
if (util_array_append(&conf->env, LCRD_ENABLE_PLUGINS "=")) {
COMMAND_ERROR("init env LCRD_ENABLE_PLUGINS failed");
if (util_array_append(&conf->env, ISULAD_ENABLE_PLUGINS "=")) {
COMMAND_ERROR("init env ISULAD_ENABLE_PLUGINS failed");
ret = -1;
goto out;
}
@ -257,7 +257,7 @@ static int request_pack_custom_env(struct client_arguments *args, lcrc_container
conf->accel = args->custom_conf.accel;
conf->accel_len = util_array_len((const char **)(args->custom_conf.accel));
if (util_env_set_lcrd_enable_plugins(&conf->env, &conf->env_len, LCRD_ISULA_ADAPTER)) {
if (util_env_set_isulad_enable_plugins(&conf->env, &conf->env_len, ISULAD_ISULA_ADAPTER)) {
COMMAND_ERROR("init accel env failed");
ret = -1;
goto out;
@ -315,7 +315,7 @@ out:
return ret;
}
static int read_env_from_file(const char *path, size_t file_size, lcrc_container_config_t *conf)
static int read_env_from_file(const char *path, size_t file_size, isula_container_config_t *conf)
{
int ret = 0;
FILE *fp = NULL;
@ -365,7 +365,7 @@ out:
return ret;
}
static int append_env_variables_to_conf(const char *env_file, lcrc_container_config_t *conf)
static int append_env_variables_to_conf(const char *env_file, isula_container_config_t *conf)
{
int ret = 0;
size_t file_size;
@ -392,7 +392,7 @@ out:
return ret;
}
static int request_pack_custom_env_file(const struct client_arguments *args, lcrc_container_config_t *conf)
static int request_pack_custom_env_file(const struct client_arguments *args, isula_container_config_t *conf)
{
int ret = 0;
size_t i;
@ -414,7 +414,7 @@ out:
return ret;
}
static void request_pack_custom_user(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_user(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->custom_conf.user != NULL) {
conf->user = args->custom_conf.user;
@ -423,7 +423,7 @@ static void request_pack_custom_user(const struct client_arguments *args, lcrc_c
return;
}
static void request_pack_custom_hostname(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_hostname(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->custom_conf.hostname != NULL) {
conf->hostname = args->custom_conf.hostname;
@ -432,7 +432,7 @@ static void request_pack_custom_hostname(const struct client_arguments *args, lc
return;
}
static void request_pack_custom_all_devices(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_all_devices(const struct client_arguments *args, isula_container_config_t *conf)
{
/* alldevices */
if (args->custom_conf.all_devices) {
@ -441,7 +441,7 @@ static void request_pack_custom_all_devices(const struct client_arguments *args,
return;
}
static void request_pack_custom_system_container(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_system_container(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->custom_conf.system_container) {
conf->system_container = true;
@ -457,7 +457,7 @@ static void request_pack_custom_system_container(const struct client_arguments *
return;
}
static void request_pack_custom_mounts(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_mounts(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->custom_conf.mounts != NULL) {
conf->mounts_len = util_array_len((const char **)(args->custom_conf.mounts));
@ -466,7 +466,7 @@ static void request_pack_custom_mounts(const struct client_arguments *args, lcrc
return;
}
static void request_pack_custom_entrypoint(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_entrypoint(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->custom_conf.entrypoint != NULL) {
conf->entrypoint = args->custom_conf.entrypoint;
@ -475,7 +475,7 @@ static void request_pack_custom_entrypoint(const struct client_arguments *args,
return;
}
static void request_pack_custom_args(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_args(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->argc != 0 && args->argv != NULL) {
conf->cmd_len = (size_t)(args->argc);
@ -485,7 +485,7 @@ static void request_pack_custom_args(const struct client_arguments *args, lcrc_c
return;
}
static void request_pack_custom_log_options(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_log_options(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->log_file != NULL) {
conf->log_file = args->log_file;
@ -498,13 +498,13 @@ static void request_pack_custom_log_options(const struct client_arguments *args,
return;
}
static int request_pack_custom_log_accel(struct client_arguments *args, lcrc_container_config_t *conf)
static int request_pack_custom_log_accel(struct client_arguments *args, isula_container_config_t *conf)
{
int ret = 0;
char *accargs = NULL;
if (conf->accel != NULL) {
accargs = util_string_join(LCRD_ISULA_ACCEL_ARGS_SEPERATOR, (const char **)conf->accel, conf->accel_len);
accargs = util_string_join(ISULAD_ISULA_ACCEL_ARGS_SEPERATOR, (const char **)conf->accel, conf->accel_len);
if (conf->annotations == NULL) {
conf->annotations = util_common_calloc_s(sizeof(json_map_string_string));
@ -515,7 +515,7 @@ static int request_pack_custom_log_accel(struct client_arguments *args, lcrc_con
}
}
ret = append_json_map_string_string(conf->annotations, LCRD_ISULA_ACCEL_ARGS, accargs);
ret = append_json_map_string_string(conf->annotations, ISULAD_ISULA_ACCEL_ARGS, accargs);
if (ret != 0) {
COMMAND_ERROR("init accel annotations failed accel=%s", accargs);
ret = -1;
@ -529,7 +529,7 @@ out:
return ret;
}
static void request_pack_custom_work_dir(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_work_dir(const struct client_arguments *args, isula_container_config_t *conf)
{
/* work dir in container */
if (args->custom_conf.workdir != NULL) {
@ -539,7 +539,7 @@ static void request_pack_custom_work_dir(const struct client_arguments *args, lc
return;
}
static void request_pack_custom_tty(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_tty(const struct client_arguments *args, isula_container_config_t *conf)
{
conf->tty = args->custom_conf.tty;
conf->open_stdin = args->custom_conf.open_stdin;
@ -550,7 +550,7 @@ static void request_pack_custom_tty(const struct client_arguments *args, lcrc_co
return;
}
static void request_pack_custom_health_check(const struct client_arguments *args, lcrc_container_config_t *conf)
static void request_pack_custom_health_check(const struct client_arguments *args, isula_container_config_t *conf)
{
if (args->custom_conf.health_cmd != NULL) {
conf->health_cmd = args->custom_conf.health_cmd;
@ -566,7 +566,7 @@ static void request_pack_custom_health_check(const struct client_arguments *args
return;
}
static int request_pack_custom_conf(struct client_arguments *args, lcrc_container_config_t *conf)
static int request_pack_custom_conf(struct client_arguments *args, isula_container_config_t *conf)
{
if (args == NULL) {
return -1;
@ -622,7 +622,7 @@ static int request_pack_custom_conf(struct client_arguments *args, lcrc_containe
return 0;
}
static int request_pack_host_ns_change_files(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static int request_pack_host_ns_change_files(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
int ret = 0;
size_t i = 0;
@ -688,7 +688,7 @@ static int request_pack_host_ns_change_files(const struct client_arguments *args
return ret;
}
static void request_pack_host_caps(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_caps(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* cap add */
if (args->custom_conf.cap_adds != NULL) {
@ -702,7 +702,7 @@ static void request_pack_host_caps(const struct client_arguments *args, lcrc_hos
}
}
static void request_pack_host_group_add(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_group_add(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* group add */
if (args->custom_conf.group_add != NULL) {
@ -711,7 +711,7 @@ static void request_pack_host_group_add(const struct client_arguments *args, lcr
}
}
static void request_pack_host_extra_hosts(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_extra_hosts(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* extra hosts */
if (args->custom_conf.extra_hosts != NULL) {
@ -720,7 +720,7 @@ static void request_pack_host_extra_hosts(const struct client_arguments *args, l
}
}
static void request_pack_host_dns(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_dns(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* dns */
if (args->custom_conf.dns != NULL) {
@ -741,7 +741,7 @@ static void request_pack_host_dns(const struct client_arguments *args, lcrc_host
}
}
static void request_pack_host_ulimit(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_ulimit(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* ulimit options */
if (args->custom_conf.ulimits != NULL) {
@ -750,7 +750,7 @@ static void request_pack_host_ulimit(const struct client_arguments *args, lcrc_h
}
}
static void request_pack_host_weight_devices(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_weight_devices(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* blkio weight devices */
if (args->custom_conf.weight_devices != NULL) {
@ -759,7 +759,7 @@ static void request_pack_host_weight_devices(const struct client_arguments *args
}
}
static void request_pack_host_device_read_bps(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_device_read_bps(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
if (args->custom_conf.blkio_throttle_read_bps_device != NULL) {
hostconfig->blkio_throttle_read_bps_device_len =
@ -768,7 +768,7 @@ static void request_pack_host_device_read_bps(const struct client_arguments *arg
}
}
static void request_pack_host_device_write_bps(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_device_write_bps(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
if (args->custom_conf.blkio_throttle_write_bps_device != NULL) {
hostconfig->blkio_throttle_write_bps_device_len =
@ -777,14 +777,14 @@ static void request_pack_host_device_write_bps(const struct client_arguments *ar
}
}
static void request_pack_host_blockio(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_blockio(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
request_pack_host_weight_devices(args, hostconfig);
request_pack_host_device_read_bps(args, hostconfig);
request_pack_host_device_write_bps(args, hostconfig);
}
static void request_pack_host_devices(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_devices(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* devices */
if (args->custom_conf.devices != NULL) {
@ -793,7 +793,7 @@ static void request_pack_host_devices(const struct client_arguments *args, lcrc_
}
}
static void request_pack_host_hugepage_limits(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_hugepage_limits(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* hugepage limits */
if (args->custom_conf.hugepage_limits != NULL) {
@ -802,7 +802,7 @@ static void request_pack_host_hugepage_limits(const struct client_arguments *arg
}
}
static void request_pack_host_binds(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_binds(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* volumes to binds */
if (args->custom_conf.volumes != NULL) {
@ -811,7 +811,7 @@ static void request_pack_host_binds(const struct client_arguments *args, lcrc_ho
}
}
static void request_pack_host_hook_spec(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_hook_spec(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* hook-spec file */
if (args->custom_conf.hook_spec != NULL) {
@ -819,14 +819,14 @@ static void request_pack_host_hook_spec(const struct client_arguments *args, lcr
}
}
static void request_pack_host_restart_policy(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_restart_policy(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
if (args->restart != NULL) {
hostconfig->restart_policy = args->restart;
}
}
static void request_pack_host_namespaces(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_namespaces(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
if (args->host_channel != NULL) {
hostconfig->host_channel = args->host_channel;
@ -849,7 +849,7 @@ static void request_pack_host_namespaces(const struct client_arguments *args, lc
}
}
static void request_pack_host_security(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static void request_pack_host_security(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
/* security opt */
if (args->custom_conf.security != NULL) {
@ -858,7 +858,7 @@ static void request_pack_host_security(const struct client_arguments *args, lcrc
}
}
static int request_pack_host_config(const struct client_arguments *args, lcrc_host_config_t *hostconfig)
static int request_pack_host_config(const struct client_arguments *args, isula_host_config_t *hostconfig)
{
int ret = 0;
@ -946,18 +946,18 @@ static int request_pack_host_config(const struct client_arguments *args, lcrc_ho
#define IMAGE_NOT_FOUND_ERROR "No such image"
static int do_client_create(const struct client_arguments *args, const lcrc_connect_ops *ops,
const struct lcrc_create_request *request, struct lcrc_create_response *response)
static int do_client_create(const struct client_arguments *args, const isula_connect_ops *ops,
const struct isula_create_request *request, struct isula_create_response *response)
{
int ret = 0;
client_connect_config_t config = get_connect_config(args);
ret = ops->container.create(request, response, &config);
if (ret != 0) {
if (response->cc == LCRD_ERR_INPUT) {
if (response->cc == ISULAD_ERR_INPUT) {
ret = EINVALIDARGS;
} else if (response->server_errono ||
(response->errmsg && !strcmp(response->errmsg, errno_to_error_message(LCRD_ERR_CONNECT)))) {
(response->errmsg && !strcmp(response->errmsg, errno_to_error_message(ISULAD_ERR_CONNECT)))) {
ret = ESERVERERROR;
} else {
ret = ECOMMON;
@ -966,14 +966,14 @@ static int do_client_create(const struct client_arguments *args, const lcrc_conn
return ret;
}
static int client_try_to_create(const struct client_arguments *args, const struct lcrc_create_request *request,
struct lcrc_create_response **out_response)
static int client_try_to_create(const struct client_arguments *args, const struct isula_create_request *request,
struct isula_create_response **out_response)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_create_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_create_response *response = NULL;
response = util_common_calloc_s(sizeof(struct lcrc_create_response));
response = util_common_calloc_s(sizeof(struct isula_create_response));
if (response == NULL) {
ERROR("Out of memory");
ret = ECOMMON;
@ -1000,8 +1000,8 @@ static int client_try_to_create(const struct client_arguments *args, const struc
}
/* retry create */
lcrc_create_response_free(response);
response = util_common_calloc_s(sizeof(struct lcrc_create_response));
isula_create_response_free(response);
response = util_common_calloc_s(sizeof(struct isula_create_response));
if (response == NULL) {
ERROR("Out of memory");
ret = ECOMMON;
@ -1018,14 +1018,14 @@ out:
return ret;
}
static void free_alloced_memory_in_host_config(lcrc_host_config_t *hostconfig)
static void free_alloced_memory_in_host_config(isula_host_config_t *hostconfig)
{
lcrc_ns_change_files_free(hostconfig);
lcrc_host_config_storage_opts_free(hostconfig);
lcrc_host_config_sysctl_free(hostconfig);
isula_ns_change_files_free(hostconfig);
isula_host_config_storage_opts_free(hostconfig);
isula_host_config_sysctl_free(hostconfig);
}
static void free_alloced_memory_in_config(lcrc_container_config_t *custom_conf)
static void free_alloced_memory_in_config(isula_container_config_t *custom_conf)
{
if (custom_conf == NULL) {
return;
@ -1041,10 +1041,10 @@ static void free_alloced_memory_in_config(lcrc_container_config_t *custom_conf)
int client_create(struct client_arguments *args)
{
int ret = 0;
struct lcrc_create_request request = { 0 };
struct lcrc_create_response *response = NULL;
lcrc_container_config_t custom_conf = { 0 };
lcrc_host_config_t host_config = { 0 };
struct isula_create_request request = { 0 };
struct isula_create_response *response = NULL;
isula_container_config_t custom_conf = { 0 };
isula_host_config_t host_config = { 0 };
container_cgroup_resources_t cr = { 0 };
request.name = args->name;
@ -1081,7 +1081,7 @@ int client_create(struct client_arguments *args)
out:
free_alloced_memory_in_host_config(request.hostconfig);
free_alloced_memory_in_config(request.config);
lcrc_create_response_free(response);
isula_create_response_free(response);
return ret;
}

2
src/cmd/lcrc/base/create.h → src/cmd/isula/base/create.h
View File

@ -52,7 +52,7 @@
{ CMD_OPT_TYPE_STRING_DUP, false, "entrypoint", 0, &(cmdargs).custom_conf.entrypoint, \
"Entrypoint to run when starting the container", NULL }, \
{ CMD_OPT_TYPE_STRING, false, "external-rootfs", 0, &(cmdargs).external_rootfs, \
"Specify the custom rootfs that is not managed by LCRD for the container, directory or block device", NULL }, \
"Specify the custom rootfs that is not managed by isulad for the container, directory or block device", NULL }, \
{ CMD_OPT_TYPE_CALLBACK, false, "files-limit", 0, &(cmdargs).custom_conf.files_limit, \
"Tune container files limit (set -1 for unlimited)", command_convert_llong }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "hook-spec", 0, &(cmdargs).custom_conf.hook_spec, \

12
src/cmd/lcrc/base/kill.c → src/cmd/isula/base/kill.c
View File

@ -16,7 +16,7 @@
#include "arguments.h"
#include "kill.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_kill_desc[] = "Kill one or more running containers";
const char g_cmd_kill_usage[] = "kill [OPTIONS] CONTAINER [CONTAINER...]";
@ -29,12 +29,12 @@ static int client_kill(const struct client_arguments *args)
{
int ret = 0;
int signal = -1;
lcrc_connect_ops *ops = NULL;
struct lcrc_kill_request request = { 0 };
struct lcrc_kill_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_kill_request request = { 0 };
struct isula_kill_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_kill_response));
response = util_common_calloc_s(sizeof(struct isula_kill_response));
if (response == NULL) {
ERROR("Kill: Out of memory");
return -1;
@ -65,7 +65,7 @@ static int client_kill(const struct client_arguments *args)
}
out:
lcrc_kill_response_free(response);
isula_kill_response_free(response);
return ret;
}

0
src/cmd/lcrc/base/kill.h → src/cmd/isula/base/kill.h
View File

10
src/cmd/lcrc/base/rename.c → src/cmd/isula/base/rename.c
View File

@ -16,7 +16,7 @@
#include "arguments.h"
#include "log.h"
#include "utils.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_rename_desc[] = "Rename a container";
const char g_cmd_rename_usage[] =
@ -27,9 +27,9 @@ struct client_arguments g_cmd_rename_args = { 0 };
static int client_rename(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_rename_request request = { 0 };
struct lcrc_rename_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_rename_request request = { 0 };
struct isula_rename_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(*response));
@ -53,7 +53,7 @@ static int client_rename(const struct client_arguments *args)
client_print_error(response->cc, response->server_errono, response->errmsg);
}
out:
lcrc_rename_response_free(response);
isula_rename_response_free(response);
return ret;
}

0
src/cmd/lcrc/base/rename.h → src/cmd/isula/base/rename.h
View File

12
src/cmd/lcrc/base/restart.c → src/cmd/isula/base/restart.c
View File

@ -18,7 +18,7 @@
#include "arguments.h"
#include "log.h"
#include "utils.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_restart_desc[] = "Restart one or more containers";
const char g_cmd_restart_usage[] = "restart [OPTIONS] CONTAINER [CONTAINER...]";
@ -31,12 +31,12 @@ struct client_arguments g_cmd_restart_args = {
static int client_restart(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_restart_request request = { 0 };
struct lcrc_restart_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_restart_request request = { 0 };
struct isula_restart_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_restart_response));
response = util_common_calloc_s(sizeof(struct isula_restart_response));
if (response == NULL) {
ERROR("Out of memory");
return -1;
@ -57,7 +57,7 @@ static int client_restart(const struct client_arguments *args)
client_print_error(response->cc, response->server_errono, response->errmsg);
}
out:
lcrc_restart_response_free(response);
isula_restart_response_free(response);
return ret;
}

0
src/cmd/lcrc/base/restart.h → src/cmd/isula/base/restart.h
View File

12
src/cmd/lcrc/base/rm.c → src/cmd/isula/base/rm.c
View File

@ -16,7 +16,7 @@
#include "rm.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "commands.h"
#include "console.h"
#include "utils.h"
@ -34,12 +34,12 @@ struct client_arguments g_cmd_delete_args = {
static int client_delete(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_delete_request request = { 0 };
struct lcrc_delete_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_delete_request request = { 0 };
struct isula_delete_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_delete_response));
response = util_common_calloc_s(sizeof(struct isula_delete_response));
if (response == NULL) {
ERROR("RM: Out of memory");
return -1;
@ -66,7 +66,7 @@ static int client_delete(const struct client_arguments *args)
}
out:
lcrc_delete_response_free(response);
isula_delete_response_free(response);
return ret;
}

0
src/cmd/lcrc/base/rm.h → src/cmd/isula/base/rm.h
View File

24
src/cmd/lcrc/base/run.c → src/cmd/isula/base/run.c
View File

@ -21,7 +21,7 @@
#include "arguments.h"
#include "log.h"
#include "utils.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "console.h"
#include "error.h"
@ -81,9 +81,9 @@ static int remote_cmd_start(const struct client_arguments *args, uint32_t *exit_
{
int ret = 0;
bool reset_tty = false;
lcrc_connect_ops *ops = NULL;
struct lcrc_start_request request = { 0 };
struct lcrc_start_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_start_request request = { 0 };
struct isula_start_response *response = NULL;
client_connect_config_t config = { 0 };
struct termios oldtios;
@ -103,7 +103,7 @@ static int remote_cmd_start(const struct client_arguments *args, uint32_t *exit_
request.attach_stdin = args->custom_conf.attach_stdin;
request.attach_stdout = args->custom_conf.attach_stdout;
request.attach_stderr = args->custom_conf.attach_stderr;
response = util_common_calloc_s(sizeof(struct lcrc_start_response));
response = util_common_calloc_s(sizeof(struct isula_start_response));
if (response == NULL) {
ERROR("Out of memory");
ret = ECOMMON;
@ -116,14 +116,14 @@ static int remote_cmd_start(const struct client_arguments *args, uint32_t *exit_
client_print_error(response->cc, response->server_errono, response->errmsg);
ret = ECOMMON;
if (response->server_errono ||
(response->errmsg && !strcmp(response->errmsg, errno_to_error_message(LCRD_ERR_CONNECT)))) {
(response->errmsg && !strcmp(response->errmsg, errno_to_error_message(ISULAD_ERR_CONNECT)))) {
ret = ESERVERERROR;
}
goto out;
}
out:
lcrc_start_response_free(response);
isula_start_response_free(response);
if (reset_tty && tcsetattr(0, TCSAFLUSH, &oldtios) < 0) {
ERROR("Failed to reset terminal properties");
return -1;
@ -134,9 +134,9 @@ out:
static int do_resize_run_console(const struct client_arguments *args, unsigned int height, unsigned int width)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_resize_request request = { 0 };
struct lcrc_resize_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_resize_request request = { 0 };
struct isula_resize_response *response = NULL;
client_connect_config_t config = { 0 };
ops = get_connect_client_ops();
@ -150,7 +150,7 @@ static int do_resize_run_console(const struct client_arguments *args, unsigned i
request.height = height;
request.width = width;
response = util_common_calloc_s(sizeof(struct lcrc_resize_response));
response = util_common_calloc_s(sizeof(struct isula_resize_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
@ -165,7 +165,7 @@ static int do_resize_run_console(const struct client_arguments *args, unsigned i
}
out:
lcrc_resize_response_free(response);
isula_resize_response_free(response);
return ret;
}

0
src/cmd/lcrc/base/run.h → src/cmd/isula/base/run.h
View File

14
src/cmd/lcrc/base/start.c → src/cmd/isula/base/start.c
View File

@ -23,7 +23,7 @@
#include "commander.h"
#include "start.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "console.h"
#include "utils.h"
#include "commands.h"
@ -95,9 +95,9 @@ out:
static int do_client_start(const struct client_arguments *args, struct command_fifo_config **console_fifos)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_start_request request = { 0 };
struct lcrc_start_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_start_request request = { 0 };
struct isula_start_response *response = NULL;
client_connect_config_t config = { 0 };
ops = get_connect_client_ops();
@ -117,7 +117,7 @@ static int do_client_start(const struct client_arguments *args, struct command_f
request.attach_stdout = args->custom_conf.attach_stdout;
request.attach_stderr = args->custom_conf.attach_stderr;
response = util_common_calloc_s(sizeof(struct lcrc_start_response));
response = util_common_calloc_s(sizeof(struct isula_start_response));
if (response == NULL) {
ERROR("Out of memory");
ret = ECOMMON;
@ -129,7 +129,7 @@ static int do_client_start(const struct client_arguments *args, struct command_f
if (ret) {
client_print_error(response->cc, response->server_errono, response->errmsg);
if (response->server_errono ||
(response->errmsg && !strcmp(response->errmsg, errno_to_error_message(LCRD_ERR_CONNECT)))) {
(response->errmsg && !strcmp(response->errmsg, errno_to_error_message(ISULAD_ERR_CONNECT)))) {
ret = ESERVERERROR;
util_contain_errmsg(response->errmsg, &ret);
} else {
@ -139,7 +139,7 @@ static int do_client_start(const struct client_arguments *args, struct command_f
}
out:
lcrc_start_response_free(response);
isula_start_response_free(response);
response = NULL;
return ret;
}

0
src/cmd/lcrc/base/start.h → src/cmd/isula/base/start.h
View File

12
src/cmd/lcrc/base/stop.c → src/cmd/isula/base/stop.c
View File

@ -16,7 +16,7 @@
#include "arguments.h"
#include "log.h"
#include "utils.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_stop_desc[] = "Stop one or more containers";
const char g_cmd_stop_usage[] = "stop [OPTIONS] CONTAINER [CONTAINER...]";
@ -32,12 +32,12 @@ struct client_arguments g_cmd_stop_args = {
static int client_stop(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_stop_request request = { 0 };
struct lcrc_stop_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_stop_request request = { 0 };
struct isula_stop_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_stop_response));
response = util_common_calloc_s(sizeof(struct isula_stop_response));
if (response == NULL) {
ERROR("Stop: Out of memory");
return -1;
@ -59,7 +59,7 @@ static int client_stop(const struct client_arguments *args)
client_print_error(response->cc, response->server_errono, response->errmsg);
}
out:
lcrc_stop_response_free(response);
isula_stop_response_free(response);
return ret;
}

0
src/cmd/lcrc/base/stop.h → src/cmd/isula/base/stop.h
View File

6
src/cmd/lcrc/commands.c → src/cmd/isula/commands.c
View File

@ -85,7 +85,7 @@ free_out:
static void print_version()
{
printf("Version %s, commit %s\n", VERSION, LCRD_GIT_COMMIT);
printf("Version %s, commit %s\n", VERSION, ISULAD_GIT_COMMIT);
}
/* compare commands */
@ -154,7 +154,7 @@ int command_default_help(const char * const program_name, struct command *comman
if (command == NULL) {
printf("%s: sub-command \"%s\" not found\n", program_name, argv[0]);
printf("run `lcrc --help` for a list of sub-commands\n");
printf("run `isula --help` for a list of sub-commands\n");
return 1;
}
@ -174,7 +174,7 @@ int run_command(struct command *commands, int argc, const char **argv)
}
if (strcmp(argv[1], "--help") == 0) {
// lcrc help command format: lcrc --help args
// isula help command format: isula --help args
return command_default_help(argv[0], commands, argc - 2, (const char **)(argv + 2));
}

2
src/cmd/lcrc/commands.h → src/cmd/isula/commands.h
View File

@ -18,7 +18,7 @@
#include "arguments.h"
#include <semaphore.h>
#define CLIENT_RUNDIR "/var/run/lcrc"
#define CLIENT_RUNDIR "/var/run/isula"
// A command is described by:
// @name: The name which should be passed as a second parameter

7
src/cmd/isula/extend/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} isula_extend_srcs)
set(ISULA_EXTEND_SRCS
${isula_extend_srcs}
PARENT_SCOPE
)

12
src/cmd/lcrc/extend/events.c → src/cmd/isula/extend/events.c
View File

@ -16,7 +16,7 @@
#include "events.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_events_desc[] = "Get real time events from the server";
const char g_cmd_events_usage[] = "events [command options]";
@ -81,12 +81,12 @@ static void print_events_callback(const container_events_format_t *event)
static int client_event(struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_events_request request = { 0 };
struct lcrc_events_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_events_request request = { 0 };
struct isula_events_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_events_response));
response = util_common_calloc_s(sizeof(struct isula_events_response));
if (response == NULL) {
ERROR("Event: Out of memory");
return -1;
@ -122,7 +122,7 @@ static int client_event(struct client_arguments *args)
}
out:
lcrc_events_response_free(response);
isula_events_response_free(response);
return ret;
}

0
src/cmd/lcrc/extend/events.h → src/cmd/isula/extend/events.h
View File

12
src/cmd/lcrc/extend/export.c → src/cmd/isula/extend/export.c
View File

@ -17,7 +17,7 @@
#include "utils.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_export_desc[] = "export container";
const char g_cmd_export_usage[] = "export [command options] [ID|NAME]";
@ -30,13 +30,13 @@ struct client_arguments g_cmd_export_args = {};
static int client_export(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_export_request request;
struct lcrc_export_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_export_request request;
struct isula_export_response *response = NULL;
client_connect_config_t config = { 0 };
(void)memset(&request, 0, sizeof(request));
response = util_common_calloc_s(sizeof(struct lcrc_export_response));
response = util_common_calloc_s(sizeof(struct isula_export_response));
if (response == NULL) {
ERROR("Resume: Out of memory");
return -1;
@ -58,7 +58,7 @@ static int client_export(const struct client_arguments *args)
client_print_error(response->cc, response->server_errono, response->errmsg);
}
out:
lcrc_export_response_free(response);
isula_export_response_free(response);
return ret;
}

0
src/cmd/lcrc/extend/export.h → src/cmd/isula/extend/export.h
View File

12
src/cmd/lcrc/extend/pause.c → src/cmd/isula/extend/pause.c
View File

@ -16,7 +16,7 @@
#include "utils.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_pause_desc[] = "Pause all processes within one or more containers";
const char g_cmd_pause_usage[] = "pause [OPTIONS] CONTAINER [CONTAINER...]";
@ -29,12 +29,12 @@ struct client_arguments g_cmd_pause_args = {};
static int client_pause(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_pause_request request = { 0 };
struct lcrc_pause_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_pause_request request = { 0 };
struct isula_pause_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_pause_response));
response = util_common_calloc_s(sizeof(struct isula_pause_response));
if (response == NULL) {
ERROR("Pause: Out of memory");
return -1;
@ -55,7 +55,7 @@ static int client_pause(const struct client_arguments *args)
client_print_error(response->cc, response->server_errono, response->errmsg);
}
out:
lcrc_pause_response_free(response);
isula_pause_response_free(response);
return ret;
}

0
src/cmd/lcrc/extend/pause.h → src/cmd/isula/extend/pause.h
View File

12
src/cmd/lcrc/extend/resume.c → src/cmd/isula/extend/resume.c
View File

@ -16,7 +16,7 @@
#include "utils.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_resume_desc[] = "Unpause all processes within one or more containers";
const char g_cmd_resume_usage[] = "unpause [OPTIONS] CONTAINER [CONTAINER...]";
@ -29,12 +29,12 @@ struct client_arguments g_cmd_resume_args = {};
static int client_resume(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_resume_request request = { 0 };
struct lcrc_resume_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_resume_request request = { 0 };
struct isula_resume_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_resume_response));
response = util_common_calloc_s(sizeof(struct isula_resume_response));
if (response == NULL) {
ERROR("Resume: Out of memory");
return -1;
@ -54,7 +54,7 @@ static int client_resume(const struct client_arguments *args)
client_print_error(response->cc, response->server_errono, response->errmsg);
}
out:
lcrc_resume_response_free(response);
isula_resume_response_free(response);
return ret;
}

0
src/cmd/lcrc/extend/resume.h → src/cmd/isula/extend/resume.h
View File

36
src/cmd/lcrc/extend/stats.c → src/cmd/isula/extend/stats.c
View File

@ -30,7 +30,7 @@
#include "stats.h"
#include "utils.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#define ESC "\033"
#define TERMCLEAR ESC "[H" ESC "[J"
@ -47,9 +47,9 @@ struct client_arguments g_cmd_stats_args = {
.runtime = "lcr",
};
static struct lcrc_stats_response *g_oldstats = NULL;
static struct isula_stats_response *g_oldstats = NULL;
static void lcrc_size_humanize(unsigned long long val, char *buf, size_t bufsz)
static void isula_size_humanize(unsigned long long val, char *buf, size_t bufsz)
{
int ret = 0;
if (val > 1024 * 1024 * 1024) {
@ -80,7 +80,7 @@ static void stats_print_header(void)
printf(TERMNORM);
}
static void stats_print(const struct lcrc_container_info *stats)
static void stats_print(const struct isula_container_info *stats)
{
#define SHORTIDLEN 12
#define PERCENT 100
@ -94,10 +94,10 @@ static void stats_print(const struct lcrc_container_info *stats)
double cpu_percent = 0.0;
char *short_id = NULL;
lcrc_size_humanize(stats->blkio_read, iosb_read_str, sizeof(iosb_read_str));
lcrc_size_humanize(stats->blkio_write, iosb_write_str, sizeof(iosb_write_str));
lcrc_size_humanize(stats->mem_used, mem_used_str, sizeof(mem_used_str));
lcrc_size_humanize(stats->mem_limit, mem_limit_str, sizeof(mem_limit_str));
isula_size_humanize(stats->blkio_read, iosb_read_str, sizeof(iosb_read_str));
isula_size_humanize(stats->blkio_write, iosb_write_str, sizeof(iosb_write_str));
isula_size_humanize(stats->mem_used, mem_used_str, sizeof(mem_used_str));
isula_size_humanize(stats->mem_limit, mem_limit_str, sizeof(mem_limit_str));
len = snprintf(iosb_str, sizeof(iosb_str), "%s / %s", iosb_read_str, iosb_write_str);
if (len < 0 || (size_t)len >= sizeof(iosb_str)) {
@ -140,7 +140,7 @@ static void stats_print(const struct lcrc_container_info *stats)
free(short_id);
}
static void stats_output(const struct client_arguments *args, struct lcrc_stats_response **response)
static void stats_output(const struct client_arguments *args, struct isula_stats_response **response)
{
size_t i;
@ -152,15 +152,15 @@ static void stats_output(const struct client_arguments *args, struct lcrc_stats_
}
fflush(stdout);
lcrc_stats_response_free(g_oldstats);
isula_stats_response_free(g_oldstats);
g_oldstats = *response;
*response = NULL;
}
static int client_stats_mainloop(const struct client_arguments *args, const struct lcrc_stats_request *request)
static int client_stats_mainloop(const struct client_arguments *args, const struct isula_stats_request *request)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
isula_connect_ops *ops = NULL;
client_connect_config_t config;
if (args == NULL) {
@ -174,8 +174,8 @@ static int client_stats_mainloop(const struct client_arguments *args, const stru
config = get_connect_config(args);
while (1) {
struct lcrc_stats_response *response = NULL;
response = util_common_calloc_s(sizeof(struct lcrc_stats_response));
struct isula_stats_response *response = NULL;
response = util_common_calloc_s(sizeof(struct isula_stats_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
@ -186,13 +186,13 @@ static int client_stats_mainloop(const struct client_arguments *args, const stru
if (ret) {
ERROR("Failed to stats containers info");
client_print_error(response->cc, response->server_errono, response->errmsg);
lcrc_stats_response_free(response);
isula_stats_response_free(response);
ret = -1;
goto err_out;
}
stats_output(args, &response);
lcrc_stats_response_free(response);
isula_stats_response_free(response);
if (args->nostream) {
goto err_out;
}
@ -201,7 +201,7 @@ static int client_stats_mainloop(const struct client_arguments *args, const stru
}
err_out:
lcrc_stats_response_free(g_oldstats);
isula_stats_response_free(g_oldstats);
g_oldstats = NULL;
return ret;
}
@ -211,7 +211,7 @@ err_out:
*/
static int client_stats(const struct client_arguments *args)
{
struct lcrc_stats_request request = { 0 };
struct isula_stats_request request = { 0 };
request.all = args->showall;
request.containers = (char **)(args->argv);

0
src/cmd/lcrc/extend/stats.h → src/cmd/isula/extend/stats.h
View File

16
src/cmd/lcrc/extend/update.c → src/cmd/isula/extend/update.c
View File

@ -18,7 +18,7 @@
#include "update.h"
#include "utils.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_update_desc[] = "Update configuration of one or more containers";
const char g_cmd_update_usage[] = "update [OPTIONS] CONTAINER [CONTAINER...]";
@ -27,7 +27,7 @@ struct client_arguments g_cmd_update_args = {
.restart = NULL,
};
static int pack_update_request(const struct client_arguments *args, struct lcrc_update_request *request)
static int pack_update_request(const struct client_arguments *args, struct isula_update_request *request)
{
int ret = 0;
@ -59,14 +59,14 @@ static int pack_update_request(const struct client_arguments *args, struct lcrc_
static int client_update(const struct client_arguments *args)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
isula_connect_ops *ops = NULL;
container_cgroup_resources_t cr = { 0 };
lcrc_update_config_t updateconfig = { 0 };
struct lcrc_update_request request = { 0 };
struct lcrc_update_response *response = NULL;
isula_update_config_t updateconfig = { 0 };
struct isula_update_request request = { 0 };
struct isula_update_response *response = NULL;
client_connect_config_t config = { 0 };
response = util_common_calloc_s(sizeof(struct lcrc_update_response));
response = util_common_calloc_s(sizeof(struct isula_update_response));
if (response == NULL) {
ERROR("Out of memory");
return -1;
@ -97,7 +97,7 @@ static int client_update(const struct client_arguments *args)
}
out:
lcrc_update_response_free(response);
isula_update_response_free(response);
return ret;
}

0
src/cmd/lcrc/extend/update.h → src/cmd/isula/extend/update.h
View File

7
src/cmd/isula/images/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} isula_images_srcs)
set(ISULA_IMAGES_SRCS
${isula_images_srcs}
PARENT_SCOPE
)

40
src/cmd/lcrc/images/images.c → src/cmd/isula/images/images.c
View File

@ -21,7 +21,7 @@
#include "utils.h"
#include "arguments.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "log.h"
#define IMAGES_OPTIONS(cmdargs) \
@ -70,9 +70,9 @@ static char *trans_time(int64_t created)
}
/* list print table */
static void list_print_table(struct lcrc_image_info *images_list, const size_t size, const struct lengths *length)
static void list_print_table(struct isula_image_info *images_list, const size_t size, const struct lengths *length)
{
const struct lcrc_image_info *in = NULL;
const struct isula_image_info *in = NULL;
size_t i = 0;
char *created = NULL;
char *digest = NULL;
@ -125,7 +125,7 @@ static void list_print_table(struct lcrc_image_info *images_list, const size_t s
}
}
static int update_image_ref_width(const struct lcrc_image_info *in, struct lengths *l)
static int update_image_ref_width(const struct isula_image_info *in, struct lengths *l)
{
size_t len;
char *copy_name = util_strdup_s(in->imageref);
@ -159,9 +159,9 @@ static int update_image_ref_width(const struct lcrc_image_info *in, struct lengt
}
/* list field width */
static void list_field_width(const struct lcrc_image_info *images_list, const size_t size, struct lengths *l)
static void list_field_width(const struct isula_image_info *images_list, const size_t size, struct lengths *l)
{
const struct lcrc_image_info *in = NULL;
const struct isula_image_info *in = NULL;
size_t i = 0;
char tmpbuffer[30];
@ -198,9 +198,9 @@ static void list_field_width(const struct lcrc_image_info *images_list, const si
}
/*
* list all images from LCRD
* list all images from isulad
*/
static void images_info_print(const struct lcrc_list_images_response *response)
static void images_info_print(const struct isula_list_images_response *response)
{
struct lengths max_len = {
.registry_length = 30, /* registry */
@ -215,9 +215,9 @@ static void images_info_print(const struct lcrc_list_images_response *response)
}
/* images info print quiet */
static void images_info_print_quiet(const struct lcrc_list_images_response *response)
static void images_info_print_quiet(const struct isula_list_images_response *response)
{
const struct lcrc_image_info *in = NULL;
const struct isula_image_info *in = NULL;
size_t i = 0;
for (i = 0, in = response->images_list; in != NULL && i < response->images_num; i++, in++) {
@ -231,7 +231,7 @@ static void images_info_print_quiet(const struct lcrc_list_images_response *resp
/*
* used by qsort function for comparing image created time
*/
static inline int lcrc_image_cmp(struct lcrc_image_info *first, struct lcrc_image_info *second)
static inline int isula_image_cmp(struct isula_image_info *first, struct isula_image_info *second)
{
if (second->created > first->created) {
return 1;
@ -247,13 +247,13 @@ static inline int lcrc_image_cmp(struct lcrc_image_info *first, struct lcrc_imag
*/
static int list_images(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_list_images_request request = { 0 };
struct lcrc_list_images_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_list_images_request request = { 0 };
struct isula_list_images_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_list_images_response));
response = util_common_calloc_s(sizeof(struct isula_list_images_response));
if (response == NULL) {
ERROR("Imagelist: Out of memory");
return -1;
@ -266,7 +266,7 @@ static int list_images(const struct client_arguments *args)
goto out;
}
if (args->filters != NULL) {
request.filters = lcrc_filters_parse_args((const char **)args->filters,
request.filters = isula_filters_parse_args((const char **)args->filters,
util_array_len((const char **)(args->filters)));
if (request.filters == NULL) {
ERROR("Failed to parse filters args");
@ -282,8 +282,8 @@ static int list_images(const struct client_arguments *args)
}
if (response->images_list != NULL && response->images_num > 0) {
qsort(response->images_list, (size_t)(response->images_num), sizeof(struct lcrc_image_info),
(int (*)(const void *, const void *))lcrc_image_cmp);
qsort(response->images_list, (size_t)(response->images_num), sizeof(struct isula_image_info),
(int (*)(const void *, const void *))isula_image_cmp);
}
if (args->dispname) {
@ -293,8 +293,8 @@ static int list_images(const struct client_arguments *args)
}
out:
lcrc_filters_free(request.filters);
lcrc_list_images_response_free(response);
isula_filters_free(request.filters);
isula_list_images_response_free(response);
return ret;
}

0
src/cmd/lcrc/images/images.h → src/cmd/isula/images/images.h
View File

8
src/cmd/lcrc/images/load.c → src/cmd/isula/images/load.c
View File

@ -21,7 +21,7 @@
#include "utils.h"
#include "arguments.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "log.h"
#ifdef ENABLE_EMBEDDED_IMAGE
@ -39,9 +39,9 @@ struct client_arguments g_cmd_load_args = { 0 };
*/
static int client_load_image(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_load_request request = { 0 };
struct lcrc_load_response response = { 0 };
isula_connect_ops *ops = NULL;
struct isula_load_request request = { 0 };
struct isula_load_response response = { 0 };
client_connect_config_t config = { 0 };
int ret = 0;

0
src/cmd/lcrc/images/load.h → src/cmd/isula/images/load.h
View File

12
src/cmd/lcrc/images/login.c → src/cmd/isula/images/login.c
View File

@ -22,7 +22,7 @@
#include "utils.h"
#include "arguments.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "log.h"
const char g_cmd_login_desc[] = "Log in to a Docker registry";
@ -35,13 +35,13 @@ struct client_arguments g_cmd_login_args = {};
*/
int client_login(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_login_request request = { 0 };
struct lcrc_login_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_login_request request = { 0 };
struct isula_login_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_login_response));
response = util_common_calloc_s(sizeof(struct isula_login_response));
if (response == NULL) {
ERROR("Out of memory");
return ECOMMON;
@ -71,7 +71,7 @@ int client_login(const struct client_arguments *args)
COMMAND_ERROR("Login Succeeded");
out:
lcrc_login_response_free(response);
isula_login_response_free(response);
return ret;
}

0
src/cmd/lcrc/images/login.h → src/cmd/isula/images/login.h
View File

12
src/cmd/lcrc/images/logout.c → src/cmd/isula/images/logout.c
View File

@ -21,7 +21,7 @@
#include "utils.h"
#include "arguments.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "log.h"
const char g_cmd_logout_desc[] = "Log out from a Docker registry";
@ -34,13 +34,13 @@ struct client_arguments g_cmd_logout_args = {};
*/
int client_logout(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_logout_request request = { 0 };
struct lcrc_logout_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_logout_request request = { 0 };
struct isula_logout_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_logout_response));
response = util_common_calloc_s(sizeof(struct isula_logout_response));
if (response == NULL) {
ERROR("Out of memory");
return ECOMMON;
@ -68,7 +68,7 @@ int client_logout(const struct client_arguments *args)
COMMAND_ERROR("Logout Succeeded");
out:
lcrc_logout_response_free(response);
isula_logout_response_free(response);
return ret;
}

0
src/cmd/lcrc/images/logout.h → src/cmd/isula/images/logout.h
View File

12
src/cmd/lcrc/images/pull.c → src/cmd/isula/images/pull.c
View File

@ -21,7 +21,7 @@
#include "utils.h"
#include "arguments.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "log.h"
const char g_cmd_pull_desc[] = "Pull an image or a repository from a registry";
@ -34,13 +34,13 @@ struct client_arguments g_cmd_pull_args = {};
*/
int client_pull(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_pull_request request = { 0 };
struct lcrc_pull_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_pull_request request = { 0 };
struct isula_pull_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_pull_response));
response = util_common_calloc_s(sizeof(struct isula_pull_response));
if (response == NULL) {
ERROR("Out of memory");
return ECOMMON;
@ -67,7 +67,7 @@ int client_pull(const struct client_arguments *args)
COMMAND_ERROR("Image \"%s\" pulled", response->image_ref);
out:
lcrc_pull_response_free(response);
isula_pull_response_free(response);
return ret;
}

0
src/cmd/lcrc/images/pull.h → src/cmd/isula/images/pull.h
View File

12
src/cmd/lcrc/images/rmi.c → src/cmd/isula/images/rmi.c
View File

@ -20,7 +20,7 @@
#include "utils.h"
#include "arguments.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "log.h"
const char g_cmd_rmi_desc[] = "Remove one or more images";
@ -33,9 +33,9 @@ struct client_arguments g_cmd_rmi_args = { .force = false };
*/
static int client_rmi(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_rmi_request request = { 0 };
struct lcrc_rmi_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_rmi_request request = { 0 };
struct isula_rmi_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
@ -44,7 +44,7 @@ static int client_rmi(const struct client_arguments *args)
return -1;
}
response = util_common_calloc_s(sizeof(struct lcrc_rmi_response));
response = util_common_calloc_s(sizeof(struct isula_rmi_response));
if (response == NULL) {
ERROR("Out of memory");
return -1;
@ -69,7 +69,7 @@ static int client_rmi(const struct client_arguments *args)
goto out;
}
out:
lcrc_rmi_response_free(response);
isula_rmi_response_free(response);
return ret;
}

0
src/cmd/lcrc/images/rmi.h → src/cmd/isula/images/rmi.h
View File

7
src/cmd/isula/information/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} isula_information_srcs)
set(ISULA_INFORMATION_SRCS
${isula_information_srcs}
PARENT_SCOPE
)

18
src/cmd/lcrc/information/health.c → src/cmd/isula/information/health.c
View File

@ -16,9 +16,9 @@
#include "utils.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_health_check_desc[] = "LCRD health check";
const char g_cmd_health_check_desc[] = "iSulad health check";
const char g_cmd_health_check_usage[] = "health [command options]";
struct client_arguments g_cmd_health_check_args = {
@ -30,13 +30,13 @@ struct client_arguments g_cmd_health_check_args = {
*/
static int client_health_check(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_health_check_request request = { 0 };
struct lcrc_health_check_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_health_check_request request = { 0 };
struct isula_health_check_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_health_check_response));
response = util_common_calloc_s(sizeof(struct isula_health_check_response));
if (response == NULL) {
ERROR("Health: Out of memory");
return -1;
@ -57,7 +57,7 @@ static int client_health_check(const struct client_arguments *args)
ret = -1;
}
out:
lcrc_health_check_response_free(response);
isula_health_check_response_free(response);
return ret;
}
@ -93,11 +93,11 @@ int cmd_health_check_main(int argc, const char **argv)
}
if (client_health_check(&g_cmd_health_check_args)) {
printf("LCRD with socket name '%s' is NOT SERVING\n", g_cmd_health_check_args.socket);
printf("iSulad with socket name '%s' is NOT SERVING\n", g_cmd_health_check_args.socket);
exit(ECOMMON);
}
printf("LCRD with socket name '%s' is SERVING\n", g_cmd_health_check_args.socket);
printf("iSulad with socket name '%s' is SERVING\n", g_cmd_health_check_args.socket);
exit(EXIT_SUCCESS);
}

0
src/cmd/lcrc/information/health.h → src/cmd/isula/information/health.h
View File

14
src/cmd/lcrc/information/info.c → src/cmd/isula/information/info.c
View File

@ -19,14 +19,14 @@
#include "arguments.h"
#include "log.h"
#include "config.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_info_desc[] = "Display system-wide information";
const char g_cmd_info_usage[] = "info";
struct client_arguments g_cmd_info_args = {};
static void client_info_server(const struct lcrc_info_response *response)
static void client_info_server(const struct isula_info_response *response)
{
printf("Containers: %u\n", (unsigned int)(response->containers_num));
printf(" Running: %u\n", (unsigned int)(response->c_running));
@ -79,13 +79,13 @@ static void client_info_server(const struct lcrc_info_response *response)
static int client_info(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_info_request request = { 0 };
struct lcrc_info_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_info_request request = { 0 };
struct isula_info_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_info_response));
response = util_common_calloc_s(sizeof(struct isula_info_response));
if (response == NULL) {
ERROR("Info: Out of memory");
return -1;
@ -108,7 +108,7 @@ static int client_info(const struct client_arguments *args)
client_info_server(response);
out:
lcrc_info_response_free(response);
isula_info_response_free(response);
return ret;
}

0
src/cmd/lcrc/information/info.h → src/cmd/isula/information/info.h
View File

25
src/cmd/lcrc/information/inspect.c → src/cmd/isula/information/inspect.c
View File

@ -16,7 +16,7 @@
#include "inspect.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "console.h"
#include "utils.h"
#include "json_common.h"
@ -191,8 +191,9 @@ static bool inspect_filter_done(yajl_val root, const char *filter, container_tre
* CONTAINER_INSPECT_ERR: have the container, but failed to inspect due to other reasons
* CONTAINER_NOT_FOUND: no such container
*/
static int client_inspect_container(const struct lcrc_inspect_request *request, struct lcrc_inspect_response *response,
client_connect_config_t *config, const lcrc_connect_ops *ops)
static int client_inspect_container(const struct isula_inspect_request *request,
struct isula_inspect_response *response,
client_connect_config_t *config, const isula_connect_ops *ops)
{
int ret = 0;
@ -211,8 +212,8 @@ static int client_inspect_container(const struct lcrc_inspect_request *request,
return ret;
}
static int client_inspect_image(const struct lcrc_inspect_request *request, struct lcrc_inspect_response *response,
client_connect_config_t *config, const lcrc_connect_ops *ops)
static int client_inspect_image(const struct isula_inspect_request *request, struct isula_inspect_response *response,
client_connect_config_t *config, const isula_connect_ops *ops)
{
int ret = 0;
@ -229,14 +230,14 @@ static int client_inspect_image(const struct lcrc_inspect_request *request, stru
*/
static int client_inspect(const struct client_arguments *args, const char *filter, container_tree_t *tree_array)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_inspect_request request = { 0 };
struct lcrc_inspect_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_inspect_request request = { 0 };
struct isula_inspect_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
yajl_val tree = NULL;
response = util_common_calloc_s(sizeof(struct lcrc_inspect_response));
response = util_common_calloc_s(sizeof(struct isula_inspect_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
@ -257,10 +258,10 @@ static int client_inspect(const struct client_arguments *args, const char *filte
config = get_connect_config(args);
ret = client_inspect_container(&request, response, &config, ops);
if (ret == CONTAINER_NOT_FOUND) {
lcrc_inspect_response_free(response);
isula_inspect_response_free(response);
response = NULL;
response = util_common_calloc_s(sizeof(struct lcrc_inspect_response));
response = util_common_calloc_s(sizeof(struct isula_inspect_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
@ -295,7 +296,7 @@ static int client_inspect(const struct client_arguments *args, const char *filte
tree_array->tree_root = tree;
out:
lcrc_inspect_response_free(response);
isula_inspect_response_free(response);
return ret;
}

0
src/cmd/lcrc/information/inspect.h → src/cmd/isula/information/inspect.h
View File

16
src/cmd/lcrc/information/logs.c → src/cmd/isula/information/logs.c
View File

@ -27,7 +27,7 @@
#include "logs.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_logs_desc[] = "Fetch the logs of a container";
const char g_cmd_logs_usage[] = "logs [OPTIONS] CONTAINER";
@ -40,18 +40,18 @@ struct client_arguments g_cmd_logs_args = {
static int do_logs(const struct client_arguments *args)
{
#define DISABLE_ERR_MESSAGE "disable console log"
lcrc_connect_ops *ops = NULL;
struct lcrc_logs_request *request = NULL;
struct lcrc_logs_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_logs_request *request = NULL;
struct isula_logs_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_logs_response));
response = util_common_calloc_s(sizeof(struct isula_logs_response));
if (response == NULL) {
ERROR("Log: Out of memory");
return -1;
}
request = util_common_calloc_s(sizeof(struct lcrc_logs_request));
request = util_common_calloc_s(sizeof(struct isula_logs_request));
if (request == NULL) {
ERROR("Out of memory");
ret = -1;
@ -84,8 +84,8 @@ static int do_logs(const struct client_arguments *args)
}
out:
lcrc_logs_response_free(response);
lcrc_logs_request_free(request);
isula_logs_response_free(response);
isula_logs_request_free(request);
return ret;
}

0
src/cmd/lcrc/information/logs.h → src/cmd/isula/information/logs.h
View File

60
src/cmd/lcrc/information/ps.c → src/cmd/isula/information/ps.c
View File

@ -23,7 +23,7 @@
#include "ps.h"
#include "utils.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_list_desc[] = "List containers";
const char g_cmd_list_usage[] = "ps [command options]";
@ -127,7 +127,7 @@ static int append_field(struct filters *ff, struct filter_field *field)
return 0;
}
static const char *lcrc_lcrsta2str(Container_Status sta)
static const char *isula_lcrsta2str(Container_Status sta)
{
if (sta >= CONTAINER_STATUS_MAX_STATE) {
return NULL;
@ -135,16 +135,16 @@ static const char *lcrc_lcrsta2str(Container_Status sta)
return g_containerstatusstr[sta];
}
static void list_print_quiet(struct lcrc_container_summary_info **info, const size_t size,
static void list_print_quiet(struct isula_container_summary_info **info, const size_t size,
const struct lengths *length)
{
const char *status = NULL;
size_t i = 0;
for (i = 0; i < size; i++) {
const struct lcrc_container_summary_info *in = NULL;
const struct isula_container_summary_info *in = NULL;
in = info[i];
status = lcrc_lcrsta2str(in->status);
status = isula_lcrsta2str(in->status);
if (status == NULL) {
continue;
}
@ -154,12 +154,12 @@ static void list_print_quiet(struct lcrc_container_summary_info **info, const si
}
}
static int mix_container_state(const struct lcrc_container_summary_info *in, char *state, size_t len)
static int mix_container_state(const struct isula_container_summary_info *in, char *state, size_t len)
{
int ret = 0;
const char *container_status = NULL;
container_status = lcrc_lcrsta2str(in->status);
container_status = isula_lcrsta2str(in->status);
if (container_status == NULL) {
(void)strcpy(state, "-");
} else {
@ -169,7 +169,7 @@ static int mix_container_state(const struct lcrc_container_summary_info *in, cha
return ret;
}
static int handle_running_status(const char *start_at, const struct lcrc_container_summary_info *in,
static int handle_running_status(const char *start_at, const struct isula_container_summary_info *in,
char *status, size_t len)
{
int ret = 0;
@ -195,7 +195,7 @@ out:
return ret;
}
static int mix_container_status(const struct lcrc_container_summary_info *in, char *status, size_t len)
static int mix_container_status(const struct isula_container_summary_info *in, char *status, size_t len)
{
int ret = -1;
int sret = 0;
@ -359,7 +359,7 @@ static void print_created_field(int64_t created, unsigned int length)
printf("%-*s", (int)length, created_duration);
}
static void print_basic_container_info_item(const struct lcrc_container_summary_info *in, const char *status,
static void print_basic_container_info_item(const struct isula_container_summary_info *in, const char *status,
const char *name, const struct lengths *length)
{
if (strcmp(name, "ID") == 0) {
@ -391,7 +391,7 @@ static void print_basic_container_info_item(const struct lcrc_container_summary_
}
static void print_extern_container_info_item(const struct lcrc_container_summary_info *in, const char *state,
static void print_extern_container_info_item(const struct isula_container_summary_info *in, const char *state,
const char *name, const struct lengths *length)
{
if (strcmp(name, "ExitCode") == 0) {
@ -414,14 +414,14 @@ static void print_extern_container_info_item(const struct lcrc_container_summary
printf("%-*s", (int)length->state_length, state);
}
}
static void print_container_info_item(const struct lcrc_container_summary_info *in, const char *state,
static void print_container_info_item(const struct isula_container_summary_info *in, const char *state,
const char *status, const char *name, const struct lengths *length)
{
print_basic_container_info_item(in, status, name, length);
print_extern_container_info_item(in, state, name, length);
}
static void ps_print_container_info(const struct lcrc_container_summary_info *in, const char *state,
static void ps_print_container_info(const struct isula_container_summary_info *in, const char *state,
const char *status, const struct lengths *length, const struct filters *ff)
{
size_t i = should_print_table_header(ff) ? 1 : 0;
@ -436,12 +436,12 @@ static void ps_print_container_info(const struct lcrc_container_summary_info *in
printf("\n");
}
static void list_print_table(struct lcrc_container_summary_info **info, const size_t size,
static void list_print_table(struct isula_container_summary_info **info, const size_t size,
struct lengths *length, const struct filters *ff)
{
#define MAX_STATE_LEN 32
#define MAX_STATUS_LEN 100
const struct lcrc_container_summary_info *in = NULL;
const struct isula_container_summary_info *in = NULL;
size_t i = 0;
char state[MAX_STATE_LEN] = { 0 };
@ -476,7 +476,7 @@ static void calculate_str_length(const char *str, unsigned int *length)
}
}
static void calculate_status_str_length(const struct lcrc_container_summary_info *in, unsigned int *length)
static void calculate_status_str_length(const struct isula_container_summary_info *in, unsigned int *length)
{
#define MAX_STATUS_LEN 100
size_t len;
@ -490,11 +490,11 @@ static void calculate_status_str_length(const struct lcrc_container_summary_info
}
}
static void calculate_state_str_length(const struct lcrc_container_summary_info *in, unsigned int *length)
static void calculate_state_str_length(const struct isula_container_summary_info *in, unsigned int *length)
{
const char *state = NULL;
state = lcrc_lcrsta2str(in->status);
state = isula_lcrsta2str(in->status);
if (state != NULL) {
size_t len;
len = strlen(state);
@ -547,10 +547,10 @@ static void calculate_created_str_length(int64_t created, unsigned int *length)
calculate_time_str_length(timebuffer, length);
}
static void list_field_width(struct lcrc_container_summary_info **info, const size_t size, struct lengths *l)
static void list_field_width(struct isula_container_summary_info **info, const size_t size, struct lengths *l)
{
size_t i = 0;
const struct lcrc_container_summary_info *in = NULL;
const struct isula_container_summary_info *in = NULL;
if (info == NULL || l == NULL) {
return;
@ -596,8 +596,8 @@ static void list_field_width(struct lcrc_container_summary_info **info, const si
/*
* used by qsort function for comparing container start time
*/
static inline int lcrc_container_cmp(struct lcrc_container_summary_info **first,
struct lcrc_container_summary_info **second)
static inline int isula_container_cmp(struct isula_container_summary_info **first,
struct isula_container_summary_info **second)
{
return strcmp((*second)->startat, (*first)->startat);
}
@ -607,9 +607,9 @@ static inline int lcrc_container_cmp(struct lcrc_container_summary_info **first,
*/
static int client_list(const struct client_arguments *args, const struct filters *ff)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_list_request request = { 0 };
struct lcrc_list_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_list_request request = { 0 };
struct isula_list_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
struct lengths max_len = {
@ -630,7 +630,7 @@ static int client_list(const struct client_arguments *args, const struct filters
.runtime_length = 7, /* RUNTIME */
};
response = util_common_calloc_s(sizeof(struct lcrc_list_response));
response = util_common_calloc_s(sizeof(struct isula_list_response));
if (response == NULL) {
ERROR("Out of memory");
return -1;
@ -644,7 +644,7 @@ static int client_list(const struct client_arguments *args, const struct filters
}
if (args->filters != NULL) {
request.filters = lcrc_filters_parse_args((const char **)args->filters,
request.filters = isula_filters_parse_args((const char **)args->filters,
util_array_len((const char **)(args->filters)));
if (request.filters == NULL) {
ERROR("Failed to parse filters args");
@ -662,7 +662,7 @@ static int client_list(const struct client_arguments *args, const struct filters
}
if (response->container_num != 0)
qsort(response->container_summary, (size_t)(response->container_num),
sizeof(struct lcrc_container_summary_info *), (int (*)(const void *, const void *))lcrc_container_cmp);
sizeof(struct isula_container_summary_info *), (int (*)(const void *, const void *))isula_container_cmp);
if (args->dispname) {
list_print_quiet(response->container_summary, response->container_num, &max_len);
@ -672,8 +672,8 @@ static int client_list(const struct client_arguments *args, const struct filters
}
out:
lcrc_filters_free(request.filters);
lcrc_list_response_free(response);
isula_filters_free(request.filters);
isula_list_response_free(response);
return ret;
}

0
src/cmd/lcrc/information/ps.h → src/cmd/isula/information/ps.h
View File

14
src/cmd/lcrc/information/top.c → src/cmd/isula/information/top.c
View File

@ -16,7 +16,7 @@
#include <limits.h>
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "commands.h"
#include "console.h"
#include "utils.h"
@ -28,7 +28,7 @@ const char g_cmd_top_desc[] = "Display the running processes of a container";
const char g_cmd_top_usage[] = "top [OPTIONS] CONTAINER [ps OPTIONS]";
struct client_arguments g_cmd_top_args = {};
static void client_top_info_server(const struct lcrc_top_response *response)
static void client_top_info_server(const struct isula_top_response *response)
{
size_t i;
@ -50,14 +50,14 @@ static void client_top_info_server(const struct lcrc_top_response *response)
*/
static int client_top(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_top_request request = { 0 };
struct lcrc_top_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_top_request request = { 0 };
struct isula_top_response *response = NULL;
container_inspect *inspect_data = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_top_response));
response = util_common_calloc_s(sizeof(struct isula_top_response));
if (response == NULL) {
ERROR("TOP: Out of memory");
return -1;
@ -108,7 +108,7 @@ static int client_top(const struct client_arguments *args)
out:
free_container_inspect(inspect_data);
lcrc_top_response_free(response);
isula_top_response_free(response);
return ret;
}

0
src/cmd/lcrc/information/top.h → src/cmd/isula/information/top.h
View File

20
src/cmd/lcrc/information/version.c → src/cmd/isula/information/version.c
View File

@ -19,9 +19,9 @@
#include "arguments.h"
#include "log.h"
#include "config.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_version_desc[] = "Display information about lcrc";
const char g_cmd_version_desc[] = "Display information about isula";
const char g_cmd_version_usage[] = "version";
struct client_arguments g_cmd_version_args = {};
@ -30,8 +30,8 @@ static void client_version_info_client()
{
printf("Client:\n");
printf(" Version:\t%s\n", VERSION);
printf(" Git commit:\t%s\n", LCRD_GIT_COMMIT);
printf(" Built:\t%s\n", LCRD_BUILD_TIME);
printf(" Git commit:\t%s\n", ISULAD_GIT_COMMIT);
printf(" Built:\t%s\n", ISULAD_BUILD_TIME);
printf("\n");
}
static void client_version_info_oci_config()
@ -41,7 +41,7 @@ static void client_version_info_oci_config()
printf(" Default file:\t%s\n", OCICONFIG_PATH);
printf("\n");
}
static void client_version_info_server(const struct lcrc_version_response *response)
static void client_version_info_server(const struct isula_version_response *response)
{
printf("Server:\n");
printf(" Version:\t%s\n", response->version ? response->version : "");
@ -52,13 +52,13 @@ static void client_version_info_server(const struct lcrc_version_response *respo
static int client_version(const struct client_arguments *args)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_version_request request = { 0 };
struct lcrc_version_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_version_request request = { 0 };
struct isula_version_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_version_response));
response = util_common_calloc_s(sizeof(struct isula_version_response));
if (response == NULL) {
ERROR("Version: Out of memory");
return -1;
@ -83,7 +83,7 @@ static int client_version(const struct client_arguments *args)
client_version_info_server(response);
client_version_info_oci_config();
out:
lcrc_version_response_free(response);
isula_version_response_free(response);
return ret;
}

0
src/cmd/lcrc/information/version.h → src/cmd/isula/information/version.h
View File

12
src/cmd/lcrc/information/wait.c → src/cmd/isula/information/wait.c
View File

@ -16,7 +16,7 @@
#include "wait.h"
#include "arguments.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
const char g_cmd_wait_desc[] = "Block until one or more containers stop, then print their exit codes";
const char g_cmd_wait_usage[] = "wait [OPTIONS] CONTAINER [CONTAINER...]";
@ -28,13 +28,13 @@ struct client_arguments g_cmd_wait_args = {};
*/
int client_wait(const struct client_arguments *args, unsigned int *exit_code)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_wait_request request = { 0 };
struct lcrc_wait_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_wait_request request = { 0 };
struct isula_wait_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_wait_response));
response = util_common_calloc_s(sizeof(struct isula_wait_response));
if (response == NULL) {
ERROR("Wait: Out of memory");
return -1;
@ -70,7 +70,7 @@ int client_wait(const struct client_arguments *args, unsigned int *exit_code)
}
out:
lcrc_wait_response_free(response);
isula_wait_response_free(response);
return ret;
}

0
src/cmd/lcrc/information/wait.h → src/cmd/isula/information/wait.h
View File

4
src/cmd/lcrc/main.c → src/cmd/isula/main.c
View File

@ -10,7 +10,7 @@
* See the Mulan PSL v1 for more details.
* Author: lifeng
* Create: 2018-11-08
* Description: provide init process of lcrc
* Description: provide init process of isula
******************************************************************************/
#include <stdio.h>
@ -45,7 +45,7 @@
#include "pull.h"
#include "login.h"
#include "logout.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "version.h"
#include "rename.h"
#include "utils.h"

7
src/cmd/isula/stream/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} isula_stream_srcs)
set(ISULA_STREAM_SRCS
${isula_stream_srcs}
PARENT_SCOPE
)

32
src/cmd/lcrc/stream/attach.c → src/cmd/isula/stream/attach.c
View File

@ -22,7 +22,7 @@
#include "arguments.h"
#include "exec.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "console.h"
#include "utils.h"
#include "attach.h"
@ -58,13 +58,13 @@ static int check_tty(bool tty, struct termios *oldtios, bool *reset_tty)
int inspect_container(const struct client_arguments *args, container_inspect **inspect_data)
{
int ret = 0;
struct lcrc_inspect_request inspect_request = { 0 };
struct lcrc_inspect_response *inspect_response = NULL;
struct isula_inspect_request inspect_request = { 0 };
struct isula_inspect_response *inspect_response = NULL;
client_connect_config_t config = { 0 };
lcrc_connect_ops *ops = NULL;
isula_connect_ops *ops = NULL;
parser_error perr = NULL;
inspect_response = util_common_calloc_s(sizeof(struct lcrc_inspect_response));
inspect_response = util_common_calloc_s(sizeof(struct isula_inspect_response));
if (inspect_response == NULL) {
COMMAND_ERROR("Out of memory");
return -1;
@ -100,7 +100,7 @@ int inspect_container(const struct client_arguments *args, container_inspect **i
}
out:
lcrc_inspect_response_free(inspect_response);
isula_inspect_response_free(inspect_response);
free(perr);
return ret;
}
@ -194,9 +194,9 @@ struct wait_thread_arg {
static void *container_wait_thread_main(void *thread_arg)
{
int ret = -1;
lcrc_connect_ops *ops = NULL;
struct lcrc_wait_request request = { 0 };
struct lcrc_wait_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_wait_request request = { 0 };
struct isula_wait_response *response = NULL;
struct wait_thread_arg *arg = (struct wait_thread_arg *)thread_arg;
client_connect_config_t config = { 0 };
@ -208,7 +208,7 @@ static void *container_wait_thread_main(void *thread_arg)
}
prctl(PR_SET_NAME, "AttachWaitThread");
response = util_common_calloc_s(sizeof(struct lcrc_wait_response));
response = util_common_calloc_s(sizeof(struct isula_wait_response));
if (response == NULL) {
ERROR("Wait: Out of memory");
goto cleanup;
@ -240,7 +240,7 @@ cleanup:
if (ret == 0) {
(void)sem_post(arg->sem_exited);
}
lcrc_wait_response_free(response);
isula_wait_response_free(response);
free(arg);
return NULL;
}
@ -279,9 +279,9 @@ static int container_wait_thread(struct client_arguments *args, uint32_t *exit_c
static int client_attach(struct client_arguments *args, uint32_t *exit_code)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_attach_request request = { 0 };
struct lcrc_attach_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_attach_request request = { 0 };
struct isula_attach_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
struct termios oldtios = { 0 };
@ -309,7 +309,7 @@ static int client_attach(struct client_arguments *args, uint32_t *exit_code)
goto out;
}
response = util_common_calloc_s(sizeof(struct lcrc_attach_response));
response = util_common_calloc_s(sizeof(struct isula_attach_response));
if (response == NULL) {
ERROR("Attach: Out of memory");
ret = ECOMMON;
@ -357,7 +357,7 @@ static int client_attach(struct client_arguments *args, uint32_t *exit_code)
out:
(void)sem_destroy(&sem_exited);
free_container_inspect(inspect_data);
lcrc_attach_response_free(response);
isula_attach_response_free(response);
if (reset_tty) {
if (tcsetattr(0, TCSAFLUSH, &oldtios) < 0) {
ERROR("Failed to reset terminal properties");

0
src/cmd/lcrc/stream/attach.h → src/cmd/isula/stream/attach.h
View File

32
src/cmd/lcrc/stream/cp.c → src/cmd/isula/stream/cp.c
View File

@ -22,8 +22,8 @@
#include "arguments.h"
#include "log.h"
#include "path.h"
#include "lcrc_connect.h"
#include "lcrdtar.h"
#include "isula_connect.h"
#include "libtar.h"
#define FromContainer 0x01u
#define ToContainer 0x10u
@ -52,10 +52,10 @@ static void print_copy_from_container_error(const char *ops_err, const char *arc
const struct client_arguments *args)
{
if (ops_err != NULL) {
if (strcmp(ops_err, errno_to_error_message(LCRD_ERR_CONNECT)) == 0) {
if (strcmp(ops_err, errno_to_error_message(ISULAD_ERR_CONNECT)) == 0) {
COMMAND_ERROR("%s", ops_err);
} else {
client_print_error(0, LCRD_ERR_EXEC, ops_err);
client_print_error(0, ISULAD_ERR_EXEC, ops_err);
}
} else if (archive_err != NULL) {
COMMAND_ERROR("Failed exact archive: %s", archive_err);
@ -67,9 +67,9 @@ static void print_copy_from_container_error(const char *ops_err, const char *arc
static int client_copy_from_container(const struct client_arguments *args, const char *id, const char *srcpath,
const char *destpath)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_copy_from_container_request request = { 0 };
struct lcrc_copy_from_container_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_copy_from_container_request request = { 0 };
struct isula_copy_from_container_response *response = NULL;
int ret = 0;
int nret = 0;
char *archive_err = NULL;
@ -84,7 +84,7 @@ static int client_copy_from_container(const struct client_arguments *args, const
return -1;
}
response = util_common_calloc_s(sizeof(struct lcrc_copy_from_container_response));
response = util_common_calloc_s(sizeof(struct isula_copy_from_container_response));
if (response == NULL) {
ERROR("Event: Out of memory");
return -1;
@ -132,14 +132,14 @@ out:
free(archive_err);
free(ops_err);
free_archive_copy_info(srcinfo);
lcrc_copy_from_container_response_free(response);
isula_copy_from_container_response_free(response);
return ret;
}
static void print_copy_to_container_error(const struct lcrc_copy_to_container_response *response,
static void print_copy_to_container_error(const struct isula_copy_to_container_response *response,
const char *archive_err, int ret, const struct client_arguments *args)
{
if (response->cc != LCRD_SUCCESS || response->errmsg != NULL || response->server_errono != 0) {
if (response->cc != ISULAD_SUCCESS || response->errmsg != NULL || response->server_errono != 0) {
client_print_error(response->cc, response->server_errono, response->errmsg);
} else if (archive_err) {
COMMAND_ERROR("Failed to archive: %s", archive_err);
@ -151,9 +151,9 @@ static void print_copy_to_container_error(const struct lcrc_copy_to_container_re
static int client_copy_to_container(const struct client_arguments *args, const char *id, const char *srcpath,
const char *destpath)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_copy_to_container_request request = { 0 };
struct lcrc_copy_to_container_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_copy_to_container_request request = { 0 };
struct isula_copy_to_container_response *response = NULL;
int ret = 0;
int nret = 0;
char *archive_err = NULL;
@ -168,7 +168,7 @@ static int client_copy_to_container(const struct client_arguments *args, const c
return -1;
}
response = util_common_calloc_s(sizeof(struct lcrc_copy_to_container_response));
response = util_common_calloc_s(sizeof(struct isula_copy_to_container_response));
if (response == NULL) {
ERROR("Event: Out of memory");
return -1;
@ -219,7 +219,7 @@ out:
free(resolved);
free(archive_err);
free_archive_copy_info(srcinfo);
lcrc_copy_to_container_response_free(response);
isula_copy_to_container_response_free(response);
return ret;
}

0
src/cmd/lcrc/stream/cp.h → src/cmd/isula/stream/cp.h
View File

32
src/cmd/lcrc/stream/exec.c → src/cmd/isula/stream/exec.c
View File

@ -24,7 +24,7 @@
#include "arguments.h"
#include "exec.h"
#include "log.h"
#include "lcrc_connect.h"
#include "isula_connect.h"
#include "console.h"
#include "utils.h"
#include "commands.h"
@ -41,13 +41,13 @@ struct client_arguments g_cmd_exec_args = {};
static int client_exec(const struct client_arguments *args, const struct command_fifo_config *fifos,
uint32_t *exit_code)
{
lcrc_connect_ops *ops = NULL;
struct lcrc_exec_request request = { 0 };
struct lcrc_exec_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_exec_request request = { 0 };
struct isula_exec_response *response = NULL;
client_connect_config_t config = { 0 };
int ret = 0;
response = util_common_calloc_s(sizeof(struct lcrc_exec_response));
response = util_common_calloc_s(sizeof(struct isula_exec_response));
if (response == NULL) {
ERROR("Out of memory");
return ECOMMON;
@ -93,7 +93,7 @@ out:
*exit_code = response->exit_code;
}
lcrc_exec_response_free(response);
isula_exec_response_free(response);
return ret;
}
@ -222,9 +222,9 @@ static int remote_cmd_exec_setup_tty(const struct client_arguments *args, bool *
static int remote_cmd_exec(const struct client_arguments *args, uint32_t *exit_code)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_exec_request request = { 0 };
struct lcrc_exec_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_exec_request request = { 0 };
struct isula_exec_response *response = NULL;
client_connect_config_t config = { 0 };
struct termios oldtios;
bool reset_tty = false;
@ -236,7 +236,7 @@ static int remote_cmd_exec(const struct client_arguments *args, uint32_t *exit_c
return ECOMMON;
}
response = util_common_calloc_s(sizeof(struct lcrc_exec_response));
response = util_common_calloc_s(sizeof(struct isula_exec_response));
if (response == NULL) {
ERROR("Out of memory");
return ECOMMON;
@ -286,7 +286,7 @@ out:
if (response->exit_code != 0) {
*exit_code = response->exit_code;
}
lcrc_exec_response_free(response);
isula_exec_response_free(response);
return ret;
}
@ -341,9 +341,9 @@ out:
static int do_resize_exec_console(const struct client_arguments *args, unsigned int height, unsigned int width)
{
int ret = 0;
lcrc_connect_ops *ops = NULL;
struct lcrc_resize_request request = { 0 };
struct lcrc_resize_response *response = NULL;
isula_connect_ops *ops = NULL;
struct isula_resize_request request = { 0 };
struct isula_resize_response *response = NULL;
client_connect_config_t config = { 0 };
ops = get_connect_client_ops();
@ -358,7 +358,7 @@ static int do_resize_exec_console(const struct client_arguments *args, unsigned
request.height = height;
request.width = width;
response = util_common_calloc_s(sizeof(struct lcrc_resize_response));
response = util_common_calloc_s(sizeof(struct isula_resize_response));
if (response == NULL) {
ERROR("Out of memory");
ret = -1;
@ -373,7 +373,7 @@ static int do_resize_exec_console(const struct client_arguments *args, unsigned
}
out:
lcrc_resize_response_free(response);
isula_resize_response_free(response);
return ret;
}

0
src/cmd/lcrc/stream/exec.h → src/cmd/isula/stream/exec.h
View File

5
src/cmd/isulad/CMakeLists.txt Normal file
View File

@ -0,0 +1,5 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} top_srcs)
set(CMD_ISULAD_SRCS ${top_srcs} PARENT_SCOPE)
set(CMD_ISULAD_INCS ${CMAKE_CURRENT_SOURCE_DIR} PARENT_SCOPE)

14
src/cmd/lcrd/arguments.c → src/cmd/isulad/arguments.c
View File

@ -22,9 +22,9 @@
#include "utils.h"
#include "arguments.h"
#include "commands.h"
#include "liblcrd.h"
#include "libisulad.h"
#include "constants.h"
#include "lcrd_config.h"
#include "isulad_config.h"
static int set_daemon_default_tls_options(struct service_arguments *args)
{
@ -98,7 +98,7 @@ int service_arguments_init(struct service_arguments *args)
args->argc = 0;
args->argv = NULL;
args->progname = util_strdup_s("lcrd");
args->progname = util_strdup_s("isulad");
args->quiet = true;
args->help = false;
args->version = false;
@ -108,9 +108,9 @@ int service_arguments_init(struct service_arguments *args)
goto free_out;
}
args->json_confs->engine = util_strdup_s("lcr");
args->json_confs->group = util_strdup_s("lcrd");
args->json_confs->graph = util_strdup_s(LCRD_ROOT_PATH);
args->json_confs->state = util_strdup_s(LCRD_STATE_PATH);
args->json_confs->group = util_strdup_s("isulad");
args->json_confs->graph = util_strdup_s(ISULAD_ROOT_PATH);
args->json_confs->state = util_strdup_s(ISULAD_STATE_PATH);
args->json_confs->log_level = util_strdup_s("INFO");
args->json_confs->log_driver = util_strdup_s("file");
args->json_confs->log_opts = (json_map_string_string *)util_common_calloc_s(sizeof(json_map_string_string));
@ -136,7 +136,7 @@ int service_arguments_init(struct service_arguments *args)
args->max_file = 7;
args->max_size = 1024 * 1024;
args->json_confs->pidfile = util_strdup_s("/var/run/lcrd.pid");
args->json_confs->pidfile = util_strdup_s("/var/run/isulad.pid");
args->json_confs->storage_driver = util_strdup_s("overlay2");
args->json_confs->native_umask = util_strdup_s(UMASK_SECURE);
args->json_confs->image_service = true;

6
src/cmd/lcrd/arguments.h → src/cmd/isulad/arguments.h
View File

@ -12,8 +12,8 @@
* Create: 2017-11-22
* Description: provide container server arguments definition
******************************************************************************/
#ifndef __LCRD_ARGUMENTS_H
#define __LCRD_ARGUMENTS_H
#ifndef __ISULAD_ARGUMENTS_H
#define __ISULAD_ARGUMENTS_H
#include <stdbool.h>
#include <stdio.h>
@ -68,5 +68,5 @@ int service_arguments_init(struct service_arguments *args);
void service_arguments_free(struct service_arguments *args);
int server_log_opt_parser(struct service_arguments *args, const char *option);
#endif /* __LCRD_ARGUMENTS_H */
#endif /* __ISULAD_ARGUMENTS_H */

25
src/cmd/lcrd/commands.c → src/cmd/isulad/commands.c
View File

@ -21,7 +21,7 @@
#include "config.h"
#include "log.h"
#include "path.h"
#include "liblcrd.h"
#include "libisulad.h"
#ifdef ENABLE_OCI_IMAGE
#include "driver.h"
@ -31,12 +31,12 @@
#include "constants.h"
#include "isulad_daemon_configs.h"
const char lcrd_desc[] = "GLOBAL OPTIONS:";
const char lcrd_usage[] = "[global options]";
const char isulad_desc[] = "GLOBAL OPTIONS:";
const char isulad_usage[] = "[global options]";
void print_version()
{
printf("Version %s, commit %s\n", VERSION, LCRD_GIT_COMMIT);
printf("Version %s, commit %s\n", VERSION, ISULAD_GIT_COMMIT);
}
int server_callback_log_opt(command_option_t *option, const char *value)
@ -60,7 +60,8 @@ out:
return ret;
}
static void command_init_lcrd(command_t *self, command_option_t *options, int options_len, int argc, const char **argv,
static void command_init_isulad(command_t *self, command_option_t *options, int options_len, int argc,
const char **argv,
const char *description, const char *usage)
{
self->name = argv[0];
@ -70,16 +71,16 @@ static void command_init_lcrd(command_t *self, command_option_t *options, int op
self->description = description;
self->options = options;
self->option_count = options_len;
self->type = "lcrd";
self->type = "isulad";
}
// Tries to execute a command in the command list.
int parse_args(struct service_arguments *args, int argc, const char **argv)
{
command_t cmd = { 0 };
struct command_option options[] = { LCRD_OPTIONS(args) };
command_init_lcrd(&cmd, options, sizeof(options) / sizeof(options[0]), argc, (const char **)argv, lcrd_desc,
lcrd_usage);
struct command_option options[] = { ISULAD_OPTIONS(args) };
command_init_isulad(&cmd, options, sizeof(options) / sizeof(options[0]), argc, (const char **)argv, isulad_desc,
isulad_usage);
if (command_parse_args(&cmd, &args->argc, &args->argv)) {
exit(EINVALIDARGS);
}
@ -139,7 +140,7 @@ static int check_args_hosts_conf(const char **array, size_t size)
/* validate unix/tcp socket name */
for (i = 0; i < size; i++) {
if (!util_validate_socket(array[i])) {
lcrd_set_error_message("Invalid socket name: %s", array[i]);
isulad_set_error_message("Invalid socket name: %s", array[i]);
ret = -1;
goto out;
}
@ -340,7 +341,7 @@ static int check_hosts_specified_conflict(const struct service_arguments *args)
ret = -1;
goto out;
}
COMMAND_ERROR("unable to configure the lcrd with file %s: "
COMMAND_ERROR("unable to configure the isulad with file %s: "
"the following directives are specified both as a flag and in the configuration file: hosts: "
"(from flag: [%s], from file: [%s])",
ISULAD_DAEMON_JSON_CONF_FILE, flag_hosts, file_hosts);
@ -523,7 +524,7 @@ static int check_conf_default_ulimit(const struct service_arguments *args)
goto out;
}
COMMAND_ERROR("unable to configure the lcrd with file %s: "
COMMAND_ERROR("unable to configure the isulad with file %s: "
"the following directives are specified both as a flag and in the configuration file: "
"default-ulimits: (from flag: %s, from file: %s)",
ISULAD_DAEMON_JSON_CONF_FILE, flag_def_ulimit, file_def_ulimit);

14
src/cmd/lcrd/commands.h → src/cmd/isulad/commands.h
View File

@ -12,8 +12,8 @@
* Create: 2017-11-22
* Description: provide container commands definition
******************************************************************************/
#ifndef __LCRD_COMMAND_H
#define __LCRD_COMMAND_H
#ifndef __ISULAD_COMMAND_H
#define __ISULAD_COMMAND_H
#include "arguments.h"
void print_common_help();
@ -21,14 +21,14 @@ void print_version();
// Default help command if implementation doesn't prvide one
int commmand_default_help(const char * const program_name, int argc, char **argv);
int command_lcrd_valid_socket(command_option_t *option, const char *arg);
int command_isulad_valid_socket(command_option_t *option, const char *arg);
int parse_args(struct service_arguments *args, int argc, const char **argv);
int check_args(struct service_arguments *args);
int update_hosts(struct service_arguments *args);
int update_default_ulimit(struct service_arguments *args);
#define LCRD_OPTIONS(cmdargs) \
#define ISULAD_OPTIONS(cmdargs) \
{ CMD_OPT_TYPE_CALLBACK, false, "host", 'H', &(cmdargs)->hosts, \
"The socket name used to create gRPC server", command_valid_socket_append_array }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "pidfile", 'p', &(cmdargs)->json_confs->pidfile, \
@ -37,7 +37,7 @@ int update_default_ulimit(struct service_arguments *args);
{ CMD_OPT_TYPE_STRING_DUP, false, "hook-spec", 0, &(cmdargs)->json_confs->hook_spec, \
"Default hook spec file applied to all containers", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "graph", 'g', &(cmdargs)->json_confs->graph, \
"Root directory of the LCRD runtime", NULL }, \
"Root directory of the iSulad runtime", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "state", 'S', &(cmdargs)->json_confs->state, \
"Root directory for execution state files", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "start-timeout", 0, &(cmdargs)->json_confs->start_timeout, \
@ -52,7 +52,7 @@ int update_default_ulimit(struct service_arguments *args);
server_callback_log_opt }, \
{ CMD_OPT_TYPE_BOOL, false, "version", 'V', &(cmdargs)->version, "Print the version", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "group", 'G', &(cmdargs)->json_confs->group, \
"Group for the unix socket(default is lcrd)", NULL }, \
"Group for the unix socket(default is isulad)", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "storage-driver", 0, &(cmdargs)->json_confs->storage_driver, \
"Storage driver to use(default overlay2)", NULL }, \
{ CMD_OPT_TYPE_CALLBACK, false, "storage-opt", 's', &(cmdargs)->json_confs->storage_opts, \
@ -72,7 +72,7 @@ int update_default_ulimit(struct service_arguments *args);
{ CMD_OPT_TYPE_STRING_DUP, false, "image-opt-timeout", 0, &(cmdargs)->json_confs->image_opt_timeout, \
"Max timeout(default 5m) for image operation", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "image_server_sock_addr", 0, &(cmdargs)->json_confs->image_server_sock_addr, \
"Set isula image remote server socket address, Default: unix:///var/run/lcrd/isula_image.sock", NULL }, \
"Set isula image remote server socket address, Default: unix:///var/run/isulad/isula_image.sock", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "network-plugin", 0, &(cmdargs)->json_confs->network_plugin, \
"Set network plugin, default is null, suppport null and cni", NULL }, \
{ CMD_OPT_TYPE_STRING_DUP, false, "cni-bin-dir", 0, &(cmdargs)->json_confs->cni_bin_dir, \

98
src/cmd/lcrd/main.c → src/cmd/isulad/main.c
View File

@ -10,7 +10,7 @@
* See the Mulan PSL v1 for more details.
* Author: lifeng
* Create: 2017-11-22
* Description: provide init process of lcrd
* Description: provide init process of isulad
******************************************************************************/
#include <signal.h>
@ -37,13 +37,13 @@
#endif
#include "constants.h"
#include "liblcrd.h"
#include "libisulad.h"
#include "collector.h"
#include "commands.h"
#include "log.h"
#include "engine.h"
#include "utils.h"
#include "lcrd_config.h"
#include "isulad_config.h"
#include "image.h"
#include "sysinfo.h"
#include "verify.h"
@ -75,7 +75,7 @@ sem_t g_daemon_shutdown_sem;
static int create_client_run_path(const char *group)
{
int ret = 0;
const char *rundir = "/var/run/lcrc";
const char *rundir = "/var/run/isula";
if (group == NULL) {
return -1;
}
@ -178,7 +178,7 @@ static void umount_daemon_mntpoint()
{
char *mntdir = NULL;
mntdir = conf_get_lcrd_mount_rootfs();
mntdir = conf_get_isulad_mount_rootfs();
if (mntdir == NULL) {
ERROR("Out of memory");
} else {
@ -211,9 +211,9 @@ static void clean_residual_files()
free(checked_flag);
/* remove pid file */
fname = conf_get_lcrd_pidfile();
fname = conf_get_isulad_pidfile();
if (fname == NULL) {
ERROR("Failed to get LCRD pid file path");
ERROR("Failed to get isulad pid file path");
} else if (unlink(fname) && errno != ENOENT) {
WARN("Unlink file: %s error: %s", fname, strerror(errno));
}
@ -275,7 +275,7 @@ static int ignore_signals()
struct sigaction sa;
/*
* Ignore SIGHUP so lcrd process still exists after
* Ignore SIGHUP so isulad process still exists after
* terminal die.
*/
(void)memset(&sa, 0, sizeof(struct sigaction));
@ -354,14 +354,14 @@ static int daemonize()
umask(0000);
if (lcrd_server_conf_rdlock()) {
if (isulad_server_conf_rdlock()) {
ret = -1;
goto out;
}
args = conf_get_server_conf();
if (args == NULL) {
ERROR("Failed to get lcrd server config");
ERROR("Failed to get isulad server config");
ret = -1;
goto unlock_out;
}
@ -380,7 +380,7 @@ static int daemonize()
ret = -1;
}
unlock_out:
if (lcrd_server_conf_unlock()) {
if (isulad_server_conf_unlock()) {
ret = -1;
}
out:
@ -394,7 +394,7 @@ int check_and_save_pid(const char *fn)
int ret = 0;
int len = 0;
struct flock lk;
char pidbuf[LCRD_NUMSTRLEN64] = { 0 };
char pidbuf[ISULAD_NUMSTRLEN64] = { 0 };
if (fn == NULL) {
ERROR("Input error");
@ -419,7 +419,7 @@ int check_and_save_pid(const char *fn)
lk.l_len = 0;
if (fcntl(fd, F_SETLK, &lk) != 0) {
/* another daemonize instance is already running, don't start up */
COMMAND_ERROR("Pid file found, ensure lcrd is not running or delete pid file %s"
COMMAND_ERROR("Pid file found, ensure isulad is not running or delete pid file %s"
" or please specify another pid file", fn);
ret = -1;
goto out;
@ -451,7 +451,7 @@ out:
return ret;
}
int check_and_set_default_lcrd_log_file(struct service_arguments *args)
int check_and_set_default_isulad_log_file(struct service_arguments *args)
{
if (args == NULL) {
return -1;
@ -482,7 +482,7 @@ static int set_parent_mount_dir(struct service_arguments *args)
goto out;
}
if (strlen(args->json_confs->graph) > (SIZE_MAX - strlen("/mnt/rootfs")) - 1) {
ERROR("Root directory of the LCRD runtime is too long");
ERROR("Root directory of the isulad runtime is too long");
goto out;
}
len = strlen(args->json_confs->graph) + strlen("/mnt/rootfs") + 1;
@ -547,7 +547,7 @@ static int parse_hook_spec(const char *specfile, oci_runtime_spec_hooks **phooks
hooks = oci_runtime_spec_hooks_parse_file(specfile, NULL, &err);
if (hooks == NULL) {
ERROR("Failed to parse hook-spec file: %s", err);
lcrd_set_error_message("Invalid hook-spec file(%s) in server conf.", specfile);
isulad_set_error_message("Invalid hook-spec file(%s) in server conf.", specfile);
ret = -1;
goto out;
}
@ -728,7 +728,7 @@ static int update_set_default_log_file(struct service_arguments *args)
args->quiet = false;
}
if (check_and_set_default_lcrd_log_file(args)) {
if (check_and_set_default_isulad_log_file(args)) {
ret = -1;
goto out;
}
@ -911,16 +911,16 @@ static int init_log_gather_thread(const char *log_full_path, struct log_config *
return log_gather_exitcode;
}
static int lcrd_get_log_path(char **log_full_path, char **fifo_full_path)
static int isulad_get_log_path(char **log_full_path, char **fifo_full_path)
{
int ret = 0;
*log_full_path = conf_get_lcrd_log_file();
*log_full_path = conf_get_isulad_log_file();
if (*log_full_path == NULL) {
ret = -1;
goto out;
}
*fifo_full_path = conf_get_lcrd_log_gather_fifo_path();
*fifo_full_path = conf_get_isulad_log_gather_fifo_path();
if (*fifo_full_path == NULL) {
ret = -1;
goto out;
@ -929,7 +929,7 @@ out:
return ret;
}
static int lcrd_server_init_log(const struct service_arguments *args, const char *log_full_path,
static int isulad_server_init_log(const struct service_arguments *args, const char *log_full_path,
const char *fifo_full_path)
{
#define FIFO_DRIVER "fifo"
@ -964,7 +964,7 @@ out:
return ret;
}
static int lcrd_server_pre_init(const struct service_arguments *args, const char *log_full_path,
static int isulad_server_pre_init(const struct service_arguments *args, const char *log_full_path,
const char *fifo_full_path)
{
int ret = 0;
@ -975,7 +975,7 @@ static int lcrd_server_pre_init(const struct service_arguments *args, const char
goto out;
}
if (lcrd_server_init_log(args, log_full_path, fifo_full_path) != 0) {
if (isulad_server_init_log(args, log_full_path, fifo_full_path) != 0) {
ret = -1;
goto out;
}
@ -1016,28 +1016,28 @@ out:
return ret;
}
static int lcrd_server_init_common()
static int isulad_server_init_common()
{
int ret = -1;
struct service_arguments *args = NULL;
char *log_full_path = NULL;
char *fifo_full_path = NULL;
if (lcrd_get_log_path(&log_full_path, &fifo_full_path) != 0) {
if (isulad_get_log_path(&log_full_path, &fifo_full_path) != 0) {
goto out;
}
if (lcrd_server_conf_rdlock()) {
if (isulad_server_conf_rdlock()) {
goto out;
}
args = conf_get_server_conf();
if (args == NULL) {
ERROR("Failed to get lcrd server config");
ERROR("Failed to get isulad server config");
goto unlock_out;
}
if (lcrd_server_pre_init(args, log_full_path, fifo_full_path) != 0) {
if (isulad_server_pre_init(args, log_full_path, fifo_full_path) != 0) {
goto unlock_out;
}
@ -1063,7 +1063,7 @@ static int lcrd_server_init_common()
ret = 0;
unlock_out:
if (lcrd_server_conf_unlock()) {
if (isulad_server_conf_unlock()) {
ret = -1;
goto out;
}
@ -1153,18 +1153,18 @@ out:
return ret;
}
static int lcrd_server_init_service()
static int isulad_server_init_service()
{
int ret = -1;
struct service_arguments *args = NULL;
if (lcrd_server_conf_rdlock()) {
if (isulad_server_conf_rdlock()) {
goto out;
}
args = conf_get_server_conf();
if (args == NULL) {
ERROR("Failed to get lcrd server config");
ERROR("Failed to get isulad server config");
goto unlock_out;
}
#ifdef GRPC_CONNECTOR
@ -1184,7 +1184,7 @@ static int lcrd_server_init_service()
}
unlock_out:
if (lcrd_server_conf_unlock()) {
if (isulad_server_conf_unlock()) {
ret = -1;
goto out;
}
@ -1192,12 +1192,12 @@ out:
return ret;
}
static int lcrd_server_init_engines()
static int isulad_server_init_engines()
{
int ret = 0;
char *engine = NULL;
engine = conf_get_lcrd_engine();
engine = conf_get_isulad_engine();
if (engine == NULL) {
ret = -1;
goto out;
@ -1246,13 +1246,13 @@ static int start_monitord()
msync.monitord_sem = &monitord_sem;
msync.exit_code = &monitord_exitcode;
if (sem_init(msync.monitord_sem, 0, 0)) {
lcrd_set_error_message("Failed to init monitor sem");
isulad_set_error_message("Failed to init monitor sem");
ret = -1;
goto out;
}
if (new_monitord(&msync)) {
lcrd_set_error_message("Create monitord thread failed");
isulad_set_error_message("Create monitord thread failed");
ret = -1;
sem_destroy(msync.monitord_sem);
goto out;
@ -1261,7 +1261,7 @@ static int start_monitord()
sem_wait(msync.monitord_sem);
sem_destroy(msync.monitord_sem);
if (monitord_exitcode) {
lcrd_set_error_message("Monitord start failed");
isulad_set_error_message("Monitord start failed");
ret = -1;
goto out;
}
@ -1323,7 +1323,7 @@ static int start_daemon_threads(char **msg)
}
if (start_monitord()) {
*msg = g_lcrd_errmsg ? g_lcrd_errmsg : "Failed to init cgroups path";
*msg = g_isulad_errmsg ? g_isulad_errmsg : "Failed to init cgroups path";
goto out;
}
@ -1356,7 +1356,7 @@ static int pre_init_daemon_log()
{
struct log_config lconf = { 0 };
lconf.name = "lcrd";
lconf.name = "isulad";
lconf.quiet = true;
lconf.file = NULL;
lconf.priority = "ERROR";
@ -1373,15 +1373,15 @@ static int pre_init_daemon(int argc, char **argv, char **msg)
{
int ret = -1;
/*
* must call lcrd by root
* must call isulad by root
*/
if (geteuid() != 0) {
*msg = "LCRD must be called by root";
*msg = "iSulad must be called by root";
goto out;
}
if (server_conf_parse_save(argc, (const char **)argv)) {
*msg = g_lcrd_errmsg ? g_lcrd_errmsg : "Failed to parse and save server conf";
*msg = g_isulad_errmsg ? g_isulad_errmsg : "Failed to parse and save server conf";
goto out;
}
@ -1391,7 +1391,7 @@ static int pre_init_daemon(int argc, char **argv, char **msg)
goto out;
}
if (lcrd_server_init_engines()) {
if (isulad_server_init_engines()) {
*msg = "Failed to init engines";
goto out;
}
@ -1418,7 +1418,7 @@ int main(int argc, char **argv)
double use_time = 0;
char *msg = NULL;
prctl(PR_SET_NAME, "lcrd");
prctl(PR_SET_NAME, "isulad");
if (pre_init_daemon_log() != 0) {
exit(ECOMMON);
@ -1434,12 +1434,12 @@ int main(int argc, char **argv)
goto failure;
}
if (lcrd_server_init_common() != 0) {
if (isulad_server_init_common() != 0) {
goto failure;
}
if (init_cgroups_path("/lxc", 0)) {
msg = g_lcrd_errmsg ? g_lcrd_errmsg : "Failed to init cgroups path";
msg = g_isulad_errmsg ? g_isulad_errmsg : "Failed to init cgroups path";
goto failure;
}
@ -1452,7 +1452,7 @@ int main(int argc, char **argv)
goto failure;
}
if (lcrd_server_init_service()) {
if (isulad_server_init_service()) {
msg = "Failed to init services";
goto failure;
}
@ -1465,7 +1465,7 @@ int main(int argc, char **argv)
clock_gettime(CLOCK_MONOTONIC, &t_end);
use_time = (double)(t_end.tv_sec - t_start.tv_sec) * (double)1000000000 + (double)(t_end.tv_nsec - t_start.tv_nsec);
use_time /= 1000000000;
INFO("Lcrd successfully booted in %.3f s", use_time);
INFO("iSulad successfully booted in %.3f s", use_time);
#ifdef GRPC_CONNECTOR
INFO("Starting grpc server...");
#else

7
src/cmd/lcrc/base/CMakeLists.txt
View File

@ -1,7 +0,0 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} lcrc_base_srcs)
set(LCRC_BASE_SRCS
${lcrc_base_srcs}
PARENT_SCOPE
)

7
src/cmd/lcrc/extend/CMakeLists.txt
View File

@ -1,7 +0,0 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} lcrc_extend_srcs)
set(LCRC_EXTEND_SRCS
${lcrc_extend_srcs}
PARENT_SCOPE
)

7
src/cmd/lcrc/images/CMakeLists.txt
View File

@ -1,7 +0,0 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} lcrc_images_srcs)
set(LCRC_IMAGES_SRCS
${lcrc_images_srcs}
PARENT_SCOPE
)

7
src/cmd/lcrc/information/CMakeLists.txt
View File

@ -1,7 +0,0 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} lcrc_information_srcs)
set(LCRC_INFORMATION_SRCS
${lcrc_information_srcs}
PARENT_SCOPE
)

7
src/cmd/lcrc/stream/CMakeLists.txt
View File

@ -1,7 +0,0 @@
# get current directory sources files
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} lcrc_stream_srcs)
set(LCRC_STREAM_SRCS
${lcrc_stream_srcs}
PARENT_SCOPE
)

Some files were not shown because too many files have changed in this diff Show More