--- /dev/null
+debug
+glide.lock
+bin/**
+tools/**
+vendor/**
--- /dev/null
+{
+ "version": "0.2.0",
+ "configurations": [{
+ "name": "xds-cli (version)",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceRoot}",
+ "env": {
+ "GOPATH": "${workspaceRoot}/../../../..:${env:GOPATH}",
+ "XDS_APPNAME": "xds-cli",
+ "XDS_SERVER_URL": "localhost:8800",
+ "XDS_LOGLEVEL": "debug"
+ },
+ "args": ["misc", "version"],
+ "showLog": false
+ },
+ {
+ "name": "xds-cli (list)",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceRoot}",
+ "env": {
+ "GOPATH": "${workspaceRoot}/../../../..:${env:GOPATH}",
+ "XDS_APPNAME": "xds-cli",
+ "XDS_SERVER_URL": "localhost:8800",
+ "XDS_LOGLEVEL": "debug"
+ },
+ "args": ["sdks", "list"],
+ "showLog": false
+ },
+ {
+ "name": "xds-cli (add Projects)",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceRoot}",
+ "env": {
+ "GOPATH": "${workspaceRoot}/../../../..:${env:GOPATH}",
+ "XDS_APPNAME": "xds-cli",
+ "XDS_SERVER_URL": "localhost:8800",
+ "XDS_LOGLEVEL": "debug"
+ },
+ "args": ["prj", "add",
+ "-type", "pm",
+ "-path", "/home/seb/xds-workspace/test1",
+ "-server-path", "/home/seb/xds-workspace/test1"
+ ],
+ "showLog": false
+ },
+ {
+ "name": "xds-cli (exec Projects)",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceRoot}",
+ "env": {
+ "GOPATH": "${workspaceRoot}/../../../..:${env:GOPATH}",
+ "XDS_APPNAME": "xds-cli",
+ "XDS_SERVER_URL": "localhost:8800",
+ "XDS_LOGLEVEL": "debug"
+ },
+ "args": ["exec",
+ "-id", "IW7B4EE-DBY4Z74_Agent-TCF",
+ "-rpath", "build",
+ "pwd && ls .."
+ ],
+ "showLog": false
+ },
+ {
+ "name": "xds-cli (with xds-config.env)",
+ "type": "go",
+ "request": "launch",
+ "mode": "debug",
+ "program": "${workspaceRoot}",
+ "env": {
+ "GOPATH": "${workspaceRoot}/../../../..:${env:GOPATH}",
+ "XDS_APPNAME": "xds-cli",
+ "XDS_LOGLEVEL": "debug"
+ },
+ "args": ["-c", "xds-config-sample.env", "sdks", "ls"],
+ "showLog": false
+ }
+
+ ]
+}
--- /dev/null
+// Place your settings in this file to overwrite default and user settings.
+{
+ // Configure glob patterns for excluding files and folders.
+ "files.exclude": {
+ "**/.tmp": true,
+ ".git": true,
+ "glide.lock": true,
+ "vendor": true,
+ "debug": true,
+ "bin": true,
+ "tools": true
+ },
+ // Words to add to dictionary for a workspace.
+ "cSpell.words": [
+ "apiv",
+ "iosk",
+ "zhouhui",
+ "ldflags",
+ "socketio",
+ "xdsconfig",
+ "sdkid",
+ "godotenv",
+ "crosssdk",
+ "prjs"
+ ]
+}
--- /dev/null
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ 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.
--- /dev/null
+# Makefile used to build xds-cli commands
+
+# Application Version
+TARGET=xds-cli
+
+
+# Retrieve git tag/commit to set version & sub-version strings
+GIT_DESC := $(shell git describe --always --tags)
+VERSION := $(firstword $(subst -, ,$(GIT_DESC)))
+SUB_VERSION := $(wordlist 2,3,$(subst -, ,$(GIT_DESC)))
+ifeq ($(VERSION), )
+ VERSION := unknown-dev
+endif
+ifeq ($(SUB_VERSION), )
+ SUB_VERSION := $(shell date +'%Y-%m-%d_%H%M%S')
+endif
+
+# Configurable variables for installation (default /opt/AGL/...)
+ifeq ($(origin DESTDIR), undefined)
+ DESTDIR := /opt/AGL/xds/cli
+endif
+
+HOST_GOOS=$(shell go env GOOS)
+HOST_GOARCH=$(shell go env GOARCH)
+ARCH=$(HOST_GOOS)-$(HOST_GOARCH)
+REPOPATH=github.com/iotbzh/$(TARGET)
+
+EXT=
+ifeq ($(HOST_GOOS), windows)
+ EXT=.exe
+endif
+
+mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
+ROOT_SRCDIR := $(patsubst %/,%,$(dir $(mkfile_path)))
+ROOT_GOPRJ := $(abspath $(ROOT_SRCDIR)/../../../..)
+LOCAL_BINDIR := $(ROOT_SRCDIR)/bin
+LOCAL_TOOLSDIR := $(ROOT_SRCDIR)/tools/${HOST_GOOS}
+PACKAGE_DIR := $(ROOT_SRCDIR)/package
+
+export GOPATH := $(shell go env GOPATH):$(ROOT_GOPRJ)
+export PATH := $(PATH):$(LOCAL_TOOLSDIR)
+
+VERBOSE_1 := -v
+VERBOSE_2 := -v -x
+
+# Release or Debug mode
+ifeq ($(filter 1,$(RELEASE) $(REL)),)
+ GO_LDFLAGS=
+ # disable compiler optimizations and inlining
+ GO_GCFLAGS=-N -l
+ BUILD_MODE="Debug mode"
+else
+ # optimized code without debug info
+ GO_LDFLAGS=-s -w
+ GO_GCFLAGS=
+ BUILD_MODE="Release mode"
+endif
+
+
+ifeq ($(SUB_VERSION), )
+ PACKAGE_ZIPFILE := $(TARGET)_$(ARCH)-v$(VERSION).zip
+else
+ PACKAGE_ZIPFILE := $(TARGET)_$(ARCH)-v$(VERSION)_$(SUB_VERSION).zip
+endif
+
+.PHONY: all
+all: vendor build
+
+.PHONY: build
+build:
+ @echo "### Build $(TARGET) (version $(VERSION), subversion $(SUB_VERSION) - $(BUILD_MODE))";
+ @cd $(ROOT_SRCDIR); $(BUILD_ENV_FLAGS) go build $(VERBOSE_$(V)) -i -o $(LOCAL_BINDIR)/$(TARGET)$(EXT) -ldflags "$(GO_LDFLAGS) -X main.AppVersion=$(VERSION) -X main.AppSubVersion=$(SUB_VERSION)" -gcflags "$(GO_GCFLAGS)" .
+
+test: tools/glide
+ go test --race $(shell $(LOCAL_TOOLSDIR)/glide novendor)
+
+vet: tools/glide
+ go vet $(shell $(LOCAL_TOOLSDIR)/glide novendor)
+
+fmt: tools/glide
+ go fmt $(shell $(LOCAL_TOOLSDIR)/glide novendor)
+
+.PHONY: clean
+clean:
+ rm -rf $(LOCAL_BINDIR)/* debug $(ROOT_GOPRJ)/pkg/*/$(REPOPATH) $(PACKAGE_DIR)
+
+.PHONY: distclean
+distclean: clean
+ rm -rf $(LOCAL_BINDIR) $(ROOT_SRCDIR)/tools glide.lock vendor
+
+
+.PHONY: scripts
+scripts:
+ @mkdir -p $(LOCAL_BINDIR) && cp -rf scripts/*.sh scripts/xds-utils $(LOCAL_BINDIR)
+
+.PHONY: release
+release:
+ RELEASE=1 make -f $(ROOT_SRCDIR)/Makefile clean build
+
+package: clean vendor build
+ @mkdir -p $(PACKAGE_DIR)/$(TARGET)
+ @cp -a $(LOCAL_BINDIR)/*cli$(EXT) $(PACKAGE_DIR)/$(TARGET)
+ @cp -r $(ROOT_SRCDIR)/conf.d $(ROOT_SRCDIR)/scripts $(PACKAGE_DIR)/$(TARGET)
+ cd $(PACKAGE_DIR) && zip -r $(ROOT_SRCDIR)/$(PACKAGE_ZIPFILE) ./$(TARGET)
+
+.PHONY: package-all
+package-all:
+ @echo "# Build linux amd64..."
+ GOOS=linux GOARCH=amd64 RELEASE=1 make -f $(ROOT_SRCDIR)/Makefile package
+ @echo "# Build windows amd64..."
+ GOOS=windows GOARCH=amd64 RELEASE=1 make -f $(ROOT_SRCDIR)/Makefile package
+ @echo "# Build darwin amd64..."
+ GOOS=darwin GOARCH=amd64 RELEASE=1 make -f $(ROOT_SRCDIR)/Makefile package
+ make -f $(ROOT_SRCDIR)/Makefile clean
+
+.PHONY: install
+install:
+ @test -e $(LOCAL_BINDIR)/$(TARGET)$(EXT) || { echo "Please execute first: make all\n"; exit 1; }
+ export DESTDIR=$(DESTDIR) && $(ROOT_SRCDIR)/scripts/install.sh
+
+.PHONY: uninstall
+uninstall:
+ export DESTDIR=$(DESTDIR) && $(ROOT_SRCDIR)/scripts/install.sh uninstall
+
+vendor: tools/glide glide.yaml
+ $(LOCAL_TOOLSDIR)/glide install --strip-vendor
+
+vendor/debug: vendor
+ (cd vendor/github.com/iotbzh && \
+ rm -rf xds-common && ln -s ../../../../xds-common && \
+ rm -rf xds-agent && ln -s ../../../../xds-agent )
+
+.PHONY: tools/glide
+tools/glide:
+ @test -f $(LOCAL_TOOLSDIR)/glide || { \
+ echo "Downloading glide"; \
+ mkdir -p $(LOCAL_TOOLSDIR); \
+ curl --silent -L https://glide.sh/get | GOBIN=$(LOCAL_TOOLSDIR) sh; \
+ }
+
+help:
+ @echo "Main supported rules:"
+ @echo " all (default)"
+ @echo " build"
+ @echo " release"
+ @echo " clean"
+ @echo " package"
+ @echo " install / uninstall"
+ @echo " distclean"
+ @echo ""
+ @echo "Influential make variables:"
+ @echo " V - Build verbosity {0,1,2}."
+ @echo " BUILD_ENV_FLAGS - Environment added to 'go build'."
--- /dev/null
+# xds-cli
+
+`xds-cli` is a command line tool used to control / interface X(cross) Development System.
+
+## Documentation
+
+Please find XDS User's Guide online at :
+
+[http://docs.automotivelinux.org/docs/devguides/en/dev/#xcross-development-system-user's-guide](http://docs.automotivelinux.org/docs/devguides/en/dev/#xcross-development-system-user's-guide)
+
+and `xds-cli` advanced documentation at :
+
+[http://docs.automotivelinux.org/docs/devguides/en/dev/reference/xds/part-2/4_xds-cli.html](http://docs.automotivelinux.org/docs/devguides/en/dev/reference/xds/part-2/4_xds-cli.html)
--- /dev/null
+package main
+
+import (
+ "fmt"
+ "os"
+ "strings"
+
+ "github.com/iotbzh/xds-agent/lib/apiv1"
+ common "github.com/iotbzh/xds-common/golib"
+ "github.com/joho/godotenv"
+ "github.com/urfave/cli"
+)
+
+func initCmdExec(cmdDef *[]cli.Command) {
+ *cmdDef = append(*cmdDef, cli.Command{
+ Name: "exec",
+ Usage: "execute a command in XDS",
+ Action: exec,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "id",
+ EnvVar: "XDS_PROJECT_ID",
+ Usage: "project ID you want to build (mandatory variable)",
+ },
+ cli.StringFlag{
+ Name: "rpath",
+ EnvVar: "XDS_RPATH",
+ Usage: "relative path into project",
+ },
+ cli.StringFlag{
+ Name: "sdkid",
+ EnvVar: "XDS_SDK_ID",
+ Usage: "Cross Sdk ID to use to build project",
+ },
+ },
+ })
+}
+
+func exec(ctx *cli.Context) error {
+ prjID := ctx.String("id")
+ confFile := ctx.String("config")
+ rPath := ctx.String("rPath")
+ sdkid := ctx.String("sdkid")
+
+ // Check mandatory args
+ if prjID == "" {
+ return cli.NewExitError("project id must be set (see --id option)", 1)
+ }
+
+ // Load config file if requested
+ envMap := make(map[string]string)
+ if confFile != "" {
+ if !common.Exists(confFile) {
+ exitError(1, "Error env config file not found")
+ }
+ // Load config file variables that will overwrite env variables
+ err := godotenv.Overload(confFile)
+ if err != nil {
+ exitError(1, "Error loading env config file "+confFile)
+ }
+ envMap, err = godotenv.Read(confFile)
+ if err != nil {
+ exitError(1, "Error reading env config file "+confFile)
+ }
+ }
+
+ argsCommand := make([]string, len(ctx.Args()))
+ copy(argsCommand, ctx.Args())
+ Log.Infof("Execute: /exec %v", argsCommand)
+
+ // Log useful info for debugging
+ ver := apiv1.XDSVersion{}
+ XdsVersionGet(&ver)
+ Log.Infof("XDS version: %v", ver)
+
+ // Process Socket IO events
+ type exitResult struct {
+ error error
+ code int
+ }
+ exitChan := make(chan exitResult, 1)
+
+ IOsk.On("disconnection", func(err error) {
+ exitChan <- exitResult{err, 2}
+ })
+
+ outFunc := func(timestamp, stdout, stderr string) {
+ tm := ""
+ if ctx.Bool("WithTimestamp") {
+ tm = timestamp + "| "
+ }
+ if stdout != "" {
+ fmt.Printf("%s%s", tm, stdout)
+ }
+ if stderr != "" {
+ fmt.Fprintf(os.Stderr, "%s%s", tm, stderr)
+ }
+ }
+
+ IOsk.On(apiv1.ExecOutEvent, func(ev apiv1.ExecOutMsg) {
+ outFunc(ev.Timestamp, ev.Stdout, ev.Stderr)
+ })
+
+ IOsk.On(apiv1.ExecExitEvent, func(ev apiv1.ExecExitMsg) {
+ exitChan <- exitResult{ev.Error, ev.Code}
+ })
+
+ // Retrieve the project definition
+ prj := apiv1.ProjectConfig{}
+ if err := HTTPCli.Get("/projects/"+prjID, &prj); err != nil {
+ return cli.NewExitError(err, 1)
+ }
+
+ // Auto setup rPath if needed
+ if rPath == "" {
+ cwd, err := os.Getwd()
+ if err == nil {
+ fldRp := prj.ClientPath
+ if !strings.HasPrefix(fldRp, "/") {
+ fldRp = "/" + fldRp
+ }
+ Log.Debugf("Try to auto-setup rPath: cwd=%s ; ClientPath=%s", cwd, fldRp)
+ if sp := strings.SplitAfter(cwd, fldRp); len(sp) == 2 {
+ rPath = strings.Trim(sp[1], "/")
+ Log.Debugf("Auto-setup rPath to: '%s'", rPath)
+ }
+ }
+ }
+
+ // Build env
+ Log.Debugf("Command env: %v", envMap)
+ env := []string{}
+ for k, v := range envMap {
+ env = append(env, k+"="+v)
+ }
+
+ // Send build command
+ args := apiv1.ExecArgs{
+ ID: prjID,
+ SdkID: sdkid,
+ Cmd: strings.Trim(argsCommand[0], " "),
+ Args: argsCommand[1:],
+ Env: env,
+ RPath: rPath,
+ CmdTimeout: 60,
+ }
+
+ LogPost("POST /exec %v", args)
+ if err := HTTPCli.Post("/exec", args, nil); err != nil {
+ return cli.NewExitError(err.Error(), 1)
+ }
+
+ // Wait exit
+ select {
+ case res := <-exitChan:
+ errStr := ""
+ if res.code == 0 {
+ Log.Debugln("Exit successfully")
+ }
+ if res.error != nil {
+ Log.Debugln("Exit with ERROR: ", res.error.Error())
+ errStr = res.error.Error()
+ }
+ return cli.NewExitError(errStr, res.code)
+ }
+}
--- /dev/null
+package main
+
+import (
+ "fmt"
+
+ "github.com/iotbzh/xds-agent/lib/apiv1"
+ "github.com/urfave/cli"
+)
+
+func initCmdMisc(cmdDef *[]cli.Command) {
+ *cmdDef = append(*cmdDef, cli.Command{
+ Name: "misc",
+ HideHelp: true,
+ Usage: "miscellaneous commands group",
+ Subcommands: []cli.Command{
+ {
+ Name: "version",
+ Aliases: []string{"v"},
+ Usage: "Get version of XDS agent and XDS server",
+ Action: xdsVersion,
+ Flags: []cli.Flag{
+ cli.BoolFlag{
+ Name: "verbose, v",
+ Usage: "display verbose output",
+ },
+ },
+ },
+ },
+ })
+}
+
+func xdsVersion(ctx *cli.Context) error {
+ verbose := ctx.Bool("verbose")
+
+ // Get version
+ ver := apiv1.XDSVersion{}
+ if err := XdsVersionGet(&ver); err != nil {
+ return cli.NewExitError(err.Error(), 1)
+ }
+
+ writer := NewTableWriter()
+ fmt.Fprintln(writer, "Agent ID:\t", ver.Client.ID)
+ v := ver.Client.Version
+ if verbose {
+ v += " (" + ver.Client.VersionGitTag + ")"
+ }
+ fmt.Fprintln(writer, " Version:\t", v)
+ if verbose {
+ fmt.Fprintln(writer, " API Version:\t", ver.Client.APIVersion)
+ }
+
+ for _, svr := range ver.Server {
+ fmt.Fprintln(writer, "Server ID:\t", svr.ID)
+ v = svr.Version
+ if verbose {
+ v += " (" + svr.VersionGitTag + ")"
+ }
+ fmt.Fprintln(writer, " Version:\t", v)
+ if verbose {
+ fmt.Fprintln(writer, " API Version:\t", svr.APIVersion)
+ }
+ }
+ writer.Flush()
+
+ return nil
+}
--- /dev/null
+package main
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/iotbzh/xds-agent/lib/apiv1"
+ "github.com/urfave/cli"
+)
+
+func initCmdProjects(cmdDef *[]cli.Command) {
+ *cmdDef = append(*cmdDef, cli.Command{
+ Name: "projects",
+ Aliases: []string{"prj"},
+ HideHelp: true,
+ Usage: "project commands group",
+ Subcommands: []cli.Command{
+ {
+ Name: "add",
+ Aliases: []string{"a"},
+ Usage: "Add a new project",
+ Action: projectsAdd,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "label",
+ Usage: "project label (free form string)",
+ },
+ cli.StringFlag{
+ Name: "path",
+ Usage: "project local path",
+ },
+ cli.StringFlag{
+ Name: "server-path",
+ Usage: "project server path (only used with pathmap type)",
+ },
+ cli.StringFlag{
+ Name: "type",
+ Usage: "project type (pathmap|pm, cloudsync|sc)",
+ },
+ },
+ },
+ {
+ Name: "get",
+ Usage: "Get a property of a project",
+ Action: projectsGet,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "id",
+ Usage: "project id",
+ },
+ },
+ },
+ {
+ Name: "list",
+ Aliases: []string{"ls"},
+ Usage: "List existing projects",
+ Action: projectsList,
+ Flags: []cli.Flag{
+ cli.BoolFlag{
+ Name: "verbose, v",
+ Usage: "display verbose output",
+ },
+ },
+ },
+ {
+ Name: "remove",
+ Aliases: []string{"rm"},
+ Usage: "Remove an existing project",
+ Action: projectsRemove,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "id",
+ Usage: "project id",
+ },
+ },
+ },
+ {
+ Name: "sync",
+ Aliases: []string{},
+ Usage: "Force synchronization of project sources",
+ Action: projectsSync,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "id",
+ Usage: "project id",
+ },
+ },
+ },
+ },
+ })
+}
+
+func projectsList(ctx *cli.Context) error {
+ // Get projects list
+ prjs := []apiv1.ProjectConfig{}
+ if err := ProjectsListGet(&prjs); err != nil {
+ return cli.NewExitError(err.Error(), 1)
+ }
+ _displayProjects(prjs, ctx.Bool("verbose"))
+ return nil
+}
+
+func projectsGet(ctx *cli.Context) error {
+ id := GetID(ctx)
+ if id == "" {
+ return cli.NewExitError("id parameter or option must be set", 1)
+ }
+ prjs := make([]apiv1.ProjectConfig, 1)
+ if err := HTTPCli.Get("/projects/"+id, &prjs[0]); err != nil {
+ return cli.NewExitError(err, 1)
+ }
+ _displayProjects(prjs, true)
+ return nil
+}
+
+func _displayProjects(prjs []apiv1.ProjectConfig, verbose bool) {
+ // Display result
+ first := true
+ writer := NewTableWriter()
+ for _, folder := range prjs {
+ if verbose {
+ if !first {
+ fmt.Fprintln(writer)
+ }
+ fmt.Fprintln(writer, "ID:\t", folder.ID)
+ fmt.Fprintln(writer, "Label:\t", folder.Label)
+ fmt.Fprintln(writer, "Path type:\t", folder.Type)
+ fmt.Fprintln(writer, "Local Path:\t", folder.ClientPath)
+ if folder.Type != apiv1.TypeCloudSync {
+ fmt.Fprintln(writer, "Server Path:\t", folder.ServerPath)
+ }
+ fmt.Fprintln(writer, "Status:\t", folder.Status)
+ fmt.Fprintln(writer, "Is in Sync:\t", folder.IsInSync)
+ ds := folder.DefaultSdk
+ if ds == "" {
+ ds = "-"
+ }
+ fmt.Fprintln(writer, "Default Sdk:\t", ds)
+
+ } else {
+ if first {
+ fmt.Fprintln(writer, "ID\t Label\t LocalPath")
+ }
+ fmt.Fprintln(writer, folder.ID, "\t", folder.Label, "\t", folder.ClientPath)
+ }
+ first = false
+ }
+ writer.Flush()
+}
+
+func projectsAdd(ctx *cli.Context) error {
+
+ // Decode project type
+ var ptype apiv1.ProjectType
+ switch strings.ToLower(ctx.String("type")) {
+ case "pathmap", "pm":
+ ptype = apiv1.TypePathMap
+ case "cloudsync", "cs":
+ ptype = apiv1.TypeCloudSync
+ default:
+ return cli.NewExitError("Unknown project type", 1)
+ }
+
+ prj := apiv1.ProjectConfig{
+ ServerID: XdsServerIDGet(),
+ Label: ctx.String("label"),
+ Type: ptype,
+ ClientPath: ctx.String("path"),
+ ServerPath: ctx.String("server-path"),
+ }
+
+ Log.Infof("POST /project %v", prj)
+ newPrj := apiv1.ProjectConfig{}
+ err := HTTPCli.Post("/projects", prj, &newPrj)
+ if err != nil {
+ return cli.NewExitError(err, 1)
+ }
+
+ fmt.Printf("New project '%s' (id %v) successfully created.\n", newPrj.Label, newPrj.ID)
+
+ return nil
+}
+
+func projectsRemove(ctx *cli.Context) error {
+ var res apiv1.ProjectConfig
+ id := GetID(ctx)
+ if id == "" {
+ return cli.NewExitError("id parameter or option must be set", 1)
+ }
+
+ if err := HTTPCli.Delete("/projects/"+id, &res); err != nil {
+ return cli.NewExitError(err, 1)
+ }
+
+ fmt.Println("Project ID " + res.ID + " successfully deleted.")
+ return nil
+}
+
+func projectsSync(ctx *cli.Context) error {
+ id := GetID(ctx)
+ if id == "" {
+ return cli.NewExitError("id parameter or option must be set", 1)
+ }
+ if err := HTTPCli.Post("/projects/sync/"+id, "", nil); err != nil {
+ return cli.NewExitError(err, 1)
+ }
+ fmt.Println("Sync successfully resquested.")
+ return nil
+}
--- /dev/null
+package main
+
+import (
+ "fmt"
+ "strconv"
+
+ "github.com/iotbzh/xds-agent/lib/apiv1"
+ "github.com/urfave/cli"
+)
+
+func initCmdSdks(cmdDef *[]cli.Command) {
+ *cmdDef = append(*cmdDef, cli.Command{
+ Name: "sdks",
+ Aliases: []string{"sdk"},
+ HideHelp: true,
+ Usage: "SDKs commands group",
+ Subcommands: []cli.Command{
+ {
+ Name: "add",
+ Aliases: []string{"a"},
+ Usage: "Add a new SDK",
+ Action: sdksAdd,
+ },
+ {
+ Name: "get",
+ Usage: "Get a property of a SDK",
+ Action: sdksGet,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "id",
+ Usage: "sdk id",
+ },
+ },
+ },
+ {
+ Name: "list",
+ Aliases: []string{"ls"},
+ Usage: "List installed SDKs",
+ Action: sdksList,
+ Flags: []cli.Flag{
+ cli.BoolFlag{
+ Name: "verbose, v",
+ Usage: "display verbose output",
+ },
+ },
+ },
+ {
+ Name: "remove",
+ Aliases: []string{"rm"},
+ Usage: "Remove an existing SDK",
+ Action: sdksRemove,
+ Flags: []cli.Flag{
+ cli.StringFlag{
+ Name: "id",
+ Usage: "sdk id",
+ },
+ },
+ },
+ },
+ })
+}
+
+func sdksList(ctx *cli.Context) error {
+ // Get SDKs list
+ sdks := []apiv1.SDK{}
+ if err := sdksListGet(&sdks); err != nil {
+ return cli.NewExitError(err.Error(), 1)
+ }
+ _displaySdks(sdks, ctx.Bool("verbose"))
+ return nil
+}
+
+func sdksGet(ctx *cli.Context) error {
+ id := GetID(ctx)
+ if id == "" {
+ return cli.NewExitError("id parameter or option must be set", 1)
+ }
+ sdks := apiv1.SDK{}
+ url := "server/" + strconv.Itoa(XdsServerIndexGet()) + "/sdks/" + id
+ if err := HTTPCli.Get(url, &sdks); err != nil {
+ return cli.NewExitError(err.Error(), 1)
+ }
+ _displaySdks([]apiv1.SDK{sdks}, true)
+ return nil
+}
+
+func _displaySdks(sdks []apiv1.SDK, verbose bool) {
+ // Display result
+ first := true
+ writer := NewTableWriter()
+ for _, s := range sdks {
+ if verbose {
+ if !first {
+ fmt.Fprintln(writer)
+ }
+ fmt.Fprintln(writer, "ID\t"+s.ID)
+ fmt.Fprintln(writer, "Name\t"+s.Name)
+ fmt.Fprintln(writer, "Profile\t"+s.Profile)
+ fmt.Fprintln(writer, "Arch\t"+s.Arch)
+ fmt.Fprintln(writer, "Version\t"+s.Version)
+ fmt.Fprintln(writer, "Path\t"+s.Path)
+
+ } else {
+ if first {
+ fmt.Fprintf(writer, "List of installed SDKs: \n")
+ fmt.Fprintf(writer, " ID\tNAME\n")
+ }
+ fmt.Fprintf(writer, " %s\t%s\n", s.ID, s.Name)
+ }
+ first = false
+ }
+ writer.Flush()
+}
+
+func sdksListGet(sdks *[]apiv1.SDK) error {
+ url := "server/" + strconv.Itoa(XdsServerIndexGet()) + "/sdks"
+ if err := HTTPCli.Get(url, &sdks); err != nil {
+ return err
+ }
+ Log.Debugf("Result of %s: %v", url, sdks)
+
+ return nil
+}
+
+func sdksAdd(ctx *cli.Context) error {
+ return fmt.Errorf("not supported yet")
+}
+
+func sdksRemove(ctx *cli.Context) error {
+ id := GetID(ctx)
+ if id == "" {
+ return cli.NewExitError("id parameter or option must be set", 1)
+ }
+
+ return fmt.Errorf("not supported yet")
+}
--- /dev/null
+package: github.com/iotbzh/xds-cli
+license: Apache-2.0
+owners:
+- name: Sebastien Douheret
+ email: sebastien@iot.bzh
+import:
+- package: github.com/urfave/cli
+ version: ^1.19.1
+- package: github.com/Sirupsen/logrus
+ version: ^0.11.5
+- package: github.com/zhouhui8915/engine.io-go
+- package: github.com/sebd71/go-socket.io-client
+ version: 46defcb47f
+- package: github.com/iotbzh/xds-agent
+ version: ^1.0.0-rc.1
+ subpackages:
+ - agent
+- package: github.com/iotbzh/xds-common
+ version: ^0.1.0
+ subpackages:
+ - golib/common
+- package: github.com/joho/godotenv
+ version: ^1.1.0
+ subpackages:
+ - cmd/godotenv
--- /dev/null
+// xds-cli: command line tool used to control / interface X(cross) Development System.
+package main
+
+import (
+ "fmt"
+ "os"
+ "regexp"
+ "sort"
+ "strings"
+ "text/tabwriter"
+
+ "github.com/Sirupsen/logrus"
+ common "github.com/iotbzh/xds-common/golib"
+ socketio_client "github.com/sebd71/go-socket.io-client"
+ "github.com/urfave/cli"
+)
+
+var appAuthors = []cli.Author{
+ cli.Author{Name: "Sebastien Douheret", Email: "sebastien@iot.bzh"},
+}
+
+// AppName name of this application
+var AppName = "xds-cli"
+
+// AppNativeName native command name that this application can overload
+var AppNativeName = "cli"
+
+// AppVersion Version of this application
+// (set by Makefile)
+var AppVersion = "?.?.?"
+
+// AppSubVersion is the git tag id added to version string
+// Should be set by compilation -ldflags "-X main.AppSubVersion=xxx"
+// (set by Makefile)
+var AppSubVersion = "unknown-dev"
+
+// Application details
+const (
+ appCopyright = "Apache-2.0"
+ defaultLogLevel = "error"
+)
+
+// Log Global variable that hold logger
+var Log = logrus.New()
+
+// HTTPCli Global variable that hold HTTP Client
+var HTTPCli *common.HTTPClient
+
+// IOsk Global variable that hold SocketIo client
+var IOsk *socketio_client.Client
+
+// exitError exists this program with the specified error
+func exitError(code int, f string, a ...interface{}) {
+ err := fmt.Sprintf(f, a...)
+ fmt.Fprintf(os.Stderr, err+"\n")
+ os.Exit(code)
+}
+
+// main
+func main() {
+
+ // Allow to set app name from cli (useful for debugging)
+ if AppName == "" {
+ AppName = os.Getenv("XDS_APPNAME")
+ }
+ if AppName == "" {
+ panic("Invalid setup, AppName not define !")
+ }
+ if AppNativeName == "" {
+ AppNativeName = AppName[4:]
+ }
+ appUsage := fmt.Sprintf("command line tool for X(cross) Development System.")
+ appDescription := fmt.Sprintf("%s utility for X(cross) Development System\n", AppName)
+ /* SEB UPDATE DOC
+ appDescription += `
+ xds-cli configuration is driven either by environment variables or by command line
+ options or using a config file knowning that the following priority order is used:
+ 1. use option value (for example use project ID set by --id option),
+ 2. else use variable 'XDS_xxx' (for example 'XDS_PROJECT_ID' variable) when a
+ config file is specified with '--config|-c' option,
+ 3. else use 'XDS_xxx' (for example 'XDS_PROJECT_ID') environment variable.
+ `
+ */
+ // Create a new App instance
+ app := cli.NewApp()
+ app.Name = AppName
+ app.Usage = appUsage
+ app.Version = AppVersion + " (" + AppSubVersion + ")"
+ app.Authors = appAuthors
+ app.Copyright = appCopyright
+ app.Metadata = make(map[string]interface{})
+ app.Metadata["version"] = AppVersion
+ app.Metadata["git-tag"] = AppSubVersion
+ app.Metadata["logger"] = Log
+
+ // Create env vars help
+ dynDesc := "\nENVIRONMENT VARIABLES:"
+ for _, f := range app.Flags {
+ var env, usage string
+ switch f.(type) {
+ case cli.StringFlag:
+ fs := f.(cli.StringFlag)
+ env = fs.EnvVar
+ usage = fs.Usage
+ case cli.BoolFlag:
+ fb := f.(cli.BoolFlag)
+ env = fb.EnvVar
+ usage = fb.Usage
+ default:
+ exitError(1, "Un-implemented option type")
+ }
+ if env != "" {
+ dynDesc += fmt.Sprintf("\n %s \t\t %s", env, usage)
+ }
+ }
+ app.Description = appDescription + dynDesc
+
+ // Declare global flags
+ app.Flags = []cli.Flag{
+ cli.StringFlag{
+ Name: "config, c",
+ EnvVar: "XDS_CONFIG",
+ Usage: "env config file to source on startup",
+ },
+ cli.StringFlag{
+ Name: "log, l",
+ EnvVar: "XDS_LOGLEVEL",
+ Usage: "logging level (supported levels: panic, fatal, error, warn, info, debug)",
+ Value: defaultLogLevel,
+ },
+ cli.StringFlag{
+ Name: "url",
+ EnvVar: "XDS_SERVER_URL",
+ Value: "localhost:8000",
+ Usage: "remote XDS server url",
+ },
+ cli.BoolFlag{
+ Name: "timestamp, ts",
+ EnvVar: "XDS_TIMESTAMP",
+ Usage: "prefix output with timestamp",
+ },
+ }
+
+ // Declare commands
+ app.Commands = []cli.Command{}
+
+ initCmdProjects(&app.Commands)
+ initCmdSdks(&app.Commands)
+ initCmdExec(&app.Commands)
+ initCmdMisc(&app.Commands)
+
+ sort.Sort(cli.FlagsByName(app.Flags))
+ sort.Sort(cli.CommandsByName(app.Commands))
+
+ app.Before = func(ctx *cli.Context) error {
+ var err error
+ loglevel := ctx.String("log")
+ // Set logger level and formatter
+ if Log.Level, err = logrus.ParseLevel(loglevel); err != nil {
+ msg := fmt.Sprintf("Invalid log level : \"%v\"\n", loglevel)
+ return cli.NewExitError(msg, 1)
+ }
+ Log.Formatter = &logrus.TextFormatter{}
+
+ Log.Infof("%s version: %s", AppName, app.Version)
+ // SEB Add again Log.Debugf("Environment: %v", os.Environ())
+
+ if err = XdsConnInit(ctx); err != nil {
+ // Directly call HandleExitCoder to avoid to print help (ShowAppHelp)
+ // Note that this function wil never return and program will exit
+ cli.HandleExitCoder(err)
+ }
+
+ return nil
+ }
+
+ // Close HTTP client and WS connection on exit
+ defer func() {
+ XdsConnClose()
+ }()
+
+ app.Run(os.Args)
+}
+
+// XdsConnInit Initialized HTTP and WebSocket connection to XDS agent
+func XdsConnInit(ctx *cli.Context) error {
+ var err error
+
+ // Define HTTP and WS url
+ baseURL := ctx.String("url")
+ if !strings.HasPrefix(ctx.String("url"), "http://") {
+ baseURL = "http://" + ctx.String("url")
+ }
+
+ // Create HTTP client
+ Log.Debugln("Connect HTTP client on ", baseURL)
+ conf := common.HTTPClientConfig{
+ URLPrefix: "/api/v1",
+ HeaderClientKeyName: "Xds-Agent-Sid",
+ CsrfDisable: true,
+ LogOut: Log.Out,
+ LogPrefix: "XDSAGENT: ",
+ LogLevel: common.HTTPLogLevelWarning,
+ }
+
+ HTTPCli, err = common.HTTPNewClient(baseURL, conf)
+ if err != nil {
+ errmsg := err.Error()
+ if m, err := regexp.MatchString("Get http.?://", errmsg); m && err == nil {
+ i := strings.LastIndex(errmsg, ":")
+ errmsg = "Cannot connection to " + baseURL + errmsg[i:]
+ }
+ return cli.NewExitError(errmsg, 1)
+ }
+ HTTPCli.SetLogLevel(ctx.String("loglevel"))
+
+ // Create io Websocket client
+ Log.Debugln("Connecting IO.socket client on ", baseURL)
+
+ opts := &socketio_client.Options{
+ Transport: "websocket",
+ Header: make(map[string][]string),
+ }
+ opts.Header["XDS-AGENT-SID"] = []string{HTTPCli.GetClientID()}
+
+ IOsk, err = socketio_client.NewClient(baseURL, opts)
+ if err != nil {
+ return cli.NewExitError("IO.socket connection error: "+err.Error(), 1)
+ }
+
+ IOsk.On("error", func(err error) {
+ fmt.Println("ERROR Websocket: ", err.Error())
+ })
+
+ ctx.App.Metadata["httpCli"] = HTTPCli
+ ctx.App.Metadata["ioskCli"] = IOsk
+
+ return nil
+}
+
+// XdsConnClose Terminate connection to XDS agent
+func XdsConnClose() {
+ Log.Debugf("Closing HTTP client session...")
+ /* TODO
+ if httpCli, ok := app.Metadata["httpCli"]; ok {
+ c := httpCli.(*common.HTTPClient)
+ }
+ */
+
+ Log.Debugf("Closing WebSocket connection...")
+ /*
+ if ioskCli, ok := app.Metadata["ioskCli"]; ok {
+ c := ioskCli.(*socketio_client.Client)
+ }
+ */
+}
+
+// NewTableWriter Create a writer that inserts padding around tab-delimited
+func NewTableWriter() *tabwriter.Writer {
+ writer := new(tabwriter.Writer)
+ writer.Init(os.Stdout, 0, 8, 0, '\t', 0)
+ return writer
+}
--- /dev/null
+package main
+
+import (
+ "encoding/json"
+
+ "github.com/iotbzh/xds-agent/lib/apiv1"
+ "github.com/urfave/cli"
+)
+
+var cacheXdsVersion *apiv1.XDSVersion
+
+// XdsVersionGet Get version of XDS agent & server
+func XdsVersionGet(ver *apiv1.XDSVersion) error {
+ // Use cached data
+ if cacheXdsVersion != nil {
+ ver = cacheXdsVersion
+ return nil
+ }
+
+ dataVer := apiv1.XDSVersion{}
+ if err := HTTPCli.Get("/version", &dataVer); err != nil {
+ return err
+ }
+
+ cacheXdsVersion = &dataVer
+ *ver = dataVer
+ return nil
+}
+
+// XdsServerIDGet returns the XDS Server ID
+func XdsServerIDGet() string {
+ ver := apiv1.XDSVersion{}
+ if err := XdsVersionGet(&ver); err != nil {
+ return ""
+ }
+ if len(ver.Server) < 1 {
+ return ""
+ }
+ return ver.Server[XdsServerIndexGet()].ID
+}
+
+// XdsServerIndexGet returns the index number of XDS Server
+func XdsServerIndexGet() int {
+ // FIXME support multiple server
+ return 0
+}
+
+// ProjectsListGet Get the list of existing projects
+func ProjectsListGet(prjs *[]apiv1.ProjectConfig) error {
+ var data []byte
+ if err := HTTPCli.HTTPGet("/projects", &data); err != nil {
+ return err
+ }
+ Log.Debugf("Result of /projects: %v", string(data[:]))
+
+ return json.Unmarshal(data, &prjs)
+}
+
+// LogPost Helper to log a POST request
+func LogPost(format string, data interface{}) {
+ b, _ := json.Marshal(data)
+ Log.Infof(format, string(b))
+}
+
+// GetID Return a string ID set with --id option or as simple parameter
+func GetID(ctx *cli.Context) string {
+ id := ctx.String("id")
+ idArgs := ctx.Args().First()
+ if id == "" && idArgs != "" {
+ id = idArgs
+ }
+ return id
+}
Code Review / src / xds / xds-cli.git / commitdiff