commands

var Actions = &cobra.Command{
	Use:   "actions",
	Short: "Manage and Perform Structured Actions.",
	Long: `Display and Manage actions for various components of the
Eris platform and for the platform itself.

Actions are bundles of commands which rely upon a project
which is currently in scope or on a global set of actions.
Actions are held in yaml, toml, or json action-definition
files within the action folder in the eris tree (globally
scoped actions) or in a directory pointed to by the
actions field of the currently checked out project
(project scoped actions). Actions are a sequence of
commands which operate in a similar fashion to how a
circle.yml file or a .travis.yml script field may operate.

Actions execute in a series of individual sub-shells ran
on the host. Note actions do not run from inside containers
but can interact with containers either via the installed
eris commands or via the docker cli itself or, indeed, any
other programs installed *on the host*.`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Chains = &cobra.Command{
	Use:   "chains",
	Short: "Start, Stop, and Manage Blockchains.",
	Long: `Start, Stop, and Manage Blockchains.

The chains subcommand is used to work on erisdb smart contract
blockchain networks. The name is not perfect, as eris is able
to operate a wide variety of blockchains out of the box. Most
of those existing blockchains should be ran via the

eris services ...

commands. As they fall under the rubric of "things I just want
to turn on or off". While you can develop against those
blockchains, you generally aren't developing those blockchains
themselves.

Eris chains is built to help you build blockchains. It is our
opinionated gateway to the wonderful world of permissioned
smart contract networks.

Your own baby blockchain/smart contract machine is just an

eris chains new

away!`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Config = &cobra.Command{
	Use:   "config",
	Short: "Manage Configuration Settings for Eris.",
	Long: `Display and Manage configuration settings for various components of the
Eris platform and for the platform itself.

NOTE: [eris config] is only for configuring the Eris platform
it will not work to configure any of the blockchains, services
or projects which are managed by the Eris platform. To configure
blockchains use [eris chains config]; to configure services
use [eris services config]; to configure projects use
[eris projects config].`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Contracts = &cobra.Command{
	Use:   "contracts",
	Short: "Manage Files containers for your Application.",
	Long: `The files subcommand is used to import, and export
files into containers for use by your application.`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Cum []int

var Data = &cobra.Command{
	Use:   "data",
	Short: "Manage Data Containers for your Application.",
	Long: `The data subcommand is used to import, and export
data into containers for use by your application.

eris data import and eris data export should be thought of from
the point of view of the container.

eris data import sends files *as is* from ~/.eris/data/NAME on
the host to ~/.eris/ inside of the data container.

eris data export performs this process in the reverse. It sucks
out whatever is in the volumes of the data container and sticks
it back into ~/.eris/data/NAME on the host.

At eris, we use this functionality to formulate little jsons
and configs on the host and then "stick them back into the
containers"
`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var ErisCmd = &cobra.Command{
	Use:   "eris [command] [flags]",
	Short: "The Blockchain Application Platform",
	Long: `Eris is a platform for building, testing, maintaining, and operating
distributed applications with a blockchain backend. Eris makes it easy
and simple to wrangle the dragons of smart contract blockchains.

Made with <3 by Eris Industries.

Complete documentation is available at https://docs.erisindustries.com
` + "\nVersion:\n  " + VERSION,
	PersistentPreRun: func(cmd *cobra.Command, args []string) {
		var logLevel log.LogLevel
		if do.Verbose {
			logLevel = 2
		} else if do.Debug {
			logLevel = 3
		}
		log.SetLoggers(logLevel, config.GlobalConfig.Writer, config.GlobalConfig.ErrorWriter)

		common.InitErisDir()
		util.DockerConnect(do.Verbose, do.MachineName)
		do.ChainName, _ = util.GetHead()
	},
	PersistentPostRun: func(cmd *cobra.Command, args []string) {
		err := config.SaveGlobalConfig(config.GlobalConfig.Config)
		if err != nil {
			logger.Errorln(err)
		}
		log.Flush()
	},
}

var Files = &cobra.Command{
	Use:   "files",
	Short: "Manage Files containers for your Application.",
	Long: `The files subcommand is used to import, and export
files into containers for use by your application.`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Init = &cobra.Command{
	Use:   "init",
	Short: "Initialize the ~/.eris directory with some default services and actions",
	Long: `Create the ~/.eris directory with actions and services subfolders
and clone eris-ltd/eris-actions eris-ltd/eris-services into them, respectively.
`,
	Run: func(cmd *cobra.Command, args []string) {
		ini.Initialize(do.Pull, do.Verbose)
	},
}

var ListExisting = &cobra.Command{
	Use:   "ls",
	Short: "List everything that is installed and built.",
	Long: `Lists the built services and chains known to Eris.

To list the known services: [eris services known]. This will show
all services which exist in the form of locally held service
definition files.

To list the running services: [eris services ps]. This is the service
which are currently running.

To start a service use: [eris services start serviceName].`,
	Run: func(cmd *cobra.Command, args []string) {
		ListAllExisting()
	},
}

var ListKnown = &cobra.Command{
	Use:   "known",
	Short: "List everything Eris knows about.",
	Long: `Lists all the services, chains, & data containers which Eris
has installed locally as definition files.

To install a new service, use: [eris services import].

To install a new chain, use: [eris chains import].

Services include all executable services supported by the Eris platform which are
NOT blockchains or key managers.

Blockchains are handled using the [eris chains] command.
`,
	Run: func(cmd *cobra.Command, args []string) {
		ListAllKnown()
	},
}

var Projects = &cobra.Command{
	Use:   "projects",
	Short: "Start, Stop, and Manage Projects or Applications.",
	Long: `Start, stop, and manage projects or applications.

Within the Eris platform, projects are a bundle of services,
and actions which are configured to run in a specific manner.
Projects may be defined either by a package.json file in the
root of an application's directory or via a docker-compose.yml
file in the root of an application's directory. Projects are
given a human readable name so that Eris can checkout and
operate the application or project.`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Remotes = &cobra.Command{
	Use:   "remotes",
	Short: "Manage and Perform Remote Machines and Services.",
	Long: `Display and Manage remote machines which are operating
various services reachable by the Eris platform.

Actions, if configured as such, can utilize remote machines.
To register and manage remote machines for sending of actions
to those machines, use this command.`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var Services = &cobra.Command{
	Use:   "services",
	Short: "Start, Stop, and Manage Services Required for your Application.",
	Long: `Start, Stop, and Manage Services Required for your Application.

Services are all services known and used by the Eris platform with the
exception of blockchain services.`,
	Run: func(cmd *cobra.Command, args []string) { cmd.Help() },
}

var VerSion = &cobra.Command{
	Use:   "version",
	Short: "Display Eris's Platform Version.",
	Long:  `Display the versions of what your platform.`,
	Run: func(cmd *cobra.Command, args []string) {
		logger.Println("Eris CLI Version: " + VERSION)
	},
}