// GetAPIClient is @@@
func (c *CLI) GetAPIClient(ctx *cli.Context) *gondor.Client {
if c.api == nil {
LoadSiteConfig()
if siteCfg.Cluster != "" {
var siteCloud, siteCluster string
if strings.Count(siteCfg.Cluster, "/") == 0 {
siteCluster = siteCfg.Cluster
} else {
parts := strings.Split(siteCfg.Cluster, "/")
siteCloud, siteCluster = parts[0], parts[1]
}
if siteCloud != "" {
cloud, err := c.Config.GetCloudByName(siteCloud)
if err != nil {
fatal(err.Error())
}
c.SetCloud(cloud)
}
if siteCluster != "" {
cluster, err := c.Config.Cloud.GetClusterByName(siteCluster)
if err != nil {
fatal(err.Error())
}
c.SetCluster(cluster)
}
}
httpClient := c.GetHTTPClient(ctx)
c.api = gondor.NewClient(c.Config.GetClientConfig(), httpClient)
if ctx.GlobalBool("log-http") {
c.api.EnableHTTPLogging(true)
}
c.api.SetClientVersion(fmt.Sprintf("%s %s", c.Name, c.Version))
}
return c.api
}
func createContainer(context *cli.Context, id string, spec *specs.Spec) (libcontainer.Container, error) {
config, err := specconv.CreateLibcontainerConfig(&specconv.CreateOpts{
CgroupName: id,
UseSystemdCgroup: context.GlobalBool("systemd-cgroup"),
NoPivotRoot: context.Bool("no-pivot"),
NoNewKeyring: context.Bool("no-new-keyring"),
Spec: spec,
})
if err != nil {
return nil, err
}
if _, err := os.Stat(config.Rootfs); err != nil {
if os.IsNotExist(err) {
return nil, fmt.Errorf("rootfs (%q) does not exist", config.Rootfs)
}
return nil, err
}
factory, err := loadFactory(context)
if err != nil {
return nil, err
}
return factory.Create(id, config)
}
func (cmd *Login) Run(scope scope.Scope, c *cli.Context) {
if !c.Args().Present() {
error_handler.ErrorExit("A URL must be provided as the first argument", error_handler.CLIUsageErrorExitCode)
}
// If an argument was not supplied, it is set to empty string
cmd.network.BrooklynUrl = c.Args().Get(0)
cmd.network.BrooklynUser = c.Args().Get(1)
cmd.network.BrooklynPass = c.Args().Get(2)
cmd.network.SkipSslChecks = c.GlobalBool("skipSslChecks")
if err := net.VerifyLoginURL(cmd.network); err != nil {
error_handler.ErrorExit(err)
}
// Strip off trailing '/' from URL if present.
if cmd.network.BrooklynUrl[len(cmd.network.BrooklynUrl)-1] == '/' {
if len(cmd.network.BrooklynUrl) == 1 {
error_handler.ErrorExit("URL must not be a single \"/\" character", error_handler.CLIUsageErrorExitCode)
}
cmd.network.BrooklynUrl = cmd.network.BrooklynUrl[0 : len(cmd.network.BrooklynUrl)-1]
}
// Prompt for password if not supplied (password is not echoed to screen
if cmd.network.BrooklynUser != "" && cmd.network.BrooklynPass == "" {
fmt.Print("Enter Password: "******"\n")
cmd.network.BrooklynPass = string(bytePassword)
}
if cmd.config.Map == nil {
cmd.config.Map = make(map[string]interface{})
}
// now persist these credentials to the yaml file
auth, ok := cmd.config.Map["auth"].(map[string]interface{})
if !ok {
auth = make(map[string]interface{})
cmd.config.Map["auth"] = auth
}
auth[cmd.network.BrooklynUrl] = map[string]string{
"username": cmd.network.BrooklynUser,
"password": cmd.network.BrooklynPass,
}
cmd.config.Map["target"] = cmd.network.BrooklynUrl
cmd.config.Map["skipSslChecks"] = cmd.network.SkipSslChecks
cmd.config.Write()
loginVersion, err := version.Version(cmd.network)
if nil != err {
error_handler.ErrorExit(err)
}
fmt.Printf("Connected to Brooklyn version %s at %s\n", loginVersion.Version, cmd.network.BrooklynUrl)
}
// BeforeApp is an action that is executed before any cli command.
func BeforeApp(c *cli.Context) error {
if c.GlobalBool("verbose") {
logrus.SetLevel(logrus.DebugLevel)
}
if version.ShowWarning() {
logrus.Warning("Note: This is an experimental alternate implementation of the Compose CLI (https://github.com/docker/compose)")
}
return nil
}
func mustNewAuthAPI(c *cli.Context) client.AuthAPI {
hc := mustNewClient(c)
if c.GlobalBool("debug") {
fmt.Fprintf(os.Stderr, "Cluster-Endpoints: %s\n", strings.Join(hc.Endpoints(), ", "))
}
return client.NewAuthAPI(hc)
}
func mustNewClient(c *cli.Context) client.Client {
hc, err := newClient(c)
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
debug := c.GlobalBool("debug")
if debug {
client.EnablecURLDebug()
}
if !c.GlobalBool("no-sync") {
if debug {
fmt.Fprintf(os.Stderr, "start to sync cluster using endpoints(%s)\n", strings.Join(hc.Endpoints(), ","))
}
ctx, cancel := contextWithTotalTimeout(c)
err := hc.Sync(ctx)
cancel()
if err != nil {
if err == client.ErrNoEndpoints {
fmt.Fprintf(os.Stderr, "etcd cluster has no published client endpoints.\n")
fmt.Fprintf(os.Stderr, "Try '--no-sync' if you want to access non-published client endpoints(%s).\n", strings.Join(hc.Endpoints(), ","))
handleError(ExitServerError, err)
}
if isConnectionError(err) {
handleError(ExitBadConnection, err)
}
// fail-back to try sync cluster with peer API. this is for making etcdctl work with etcd 0.4.x.
// TODO: remove this when we deprecate the support for etcd 0.4.
eps, serr := syncWithPeerAPI(c, ctx, hc.Endpoints())
if serr != nil {
if isConnectionError(serr) {
handleError(ExitBadConnection, serr)
} else {
handleError(ExitServerError, serr)
}
}
err = hc.SetEndpoints(eps)
if err != nil {
handleError(ExitServerError, err)
}
}
if debug {
fmt.Fprintf(os.Stderr, "got endpoints(%s) after sync\n", strings.Join(hc.Endpoints(), ","))
}
}
if debug {
fmt.Fprintf(os.Stderr, "Cluster-Endpoints: %s\n", strings.Join(hc.Endpoints(), ", "))
}
return hc
}
func getDiscoveryDomain(c *cli.Context) (domainstr string, insecure bool) {
domainstr = c.GlobalString("discovery-srv")
// Use an environment variable if nothing was supplied on the
// command line
if domainstr == "" {
domainstr = os.Getenv("ETCDCTL_DISCOVERY_SRV")
}
insecure = c.GlobalBool("insecure-discovery") || (os.Getenv("ETCDCTL_INSECURE_DISCOVERY") != "")
return domainstr, insecure
}
func setup(c *cli.Context) error {
logrus.SetOutput(os.Stderr)
if c.GlobalBool("debug") {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.WarnLevel)
}
return nil
}
func mustNewClientNoSync(c *cli.Context) client.Client {
hc, err := newClient(c)
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
if c.GlobalBool("debug") {
fmt.Fprintf(os.Stderr, "Cluster-Endpoints: %s\n", strings.Join(hc.Endpoints(), ", "))
client.EnablecURLDebug()
}
return hc
}
//parse sql connection string from cli flags
func ParseConnStr(c *cli.Context) string {
otherParams := "sslmode=disable connect_timeout=5"
if c.GlobalBool("ssl") {
otherParams = "sslmode=require connect_timeout=5"
}
return fmt.Sprintf("user=%s dbname=%s password='******' host=%s port=%s %s",
c.GlobalString("username"),
c.GlobalString("dbname"),
c.GlobalString("pass"),
c.GlobalString("host"),
c.GlobalString("port"),
otherParams,
)
}
// loadFactory returns the configured factory instance for execing containers.
func loadFactory(context *cli.Context) (libcontainer.Factory, error) {
root := context.GlobalString("root")
abs, err := filepath.Abs(root)
if err != nil {
return nil, err
}
cgroupManager := libcontainer.Cgroupfs
if context.GlobalBool("systemd-cgroup") {
if systemd.UseSystemd() {
cgroupManager = libcontainer.SystemdCgroups
} else {
return nil, fmt.Errorf("systemd cgroup flag passed, but systemd support for managing cgroups is not available")
}
}
return libcontainer.New(abs, cgroupManager, libcontainer.CriuPath(context.GlobalString("criu")))
}
func createContainer(context *cli.Context, id string, spec *specs.Spec) (libcontainer.Container, error) {
config, err := specconv.CreateLibcontainerConfig(&specconv.CreateOpts{
CgroupName: id,
UseSystemdCgroup: context.GlobalBool("systemd-cgroup"),
NoPivotRoot: context.Bool("no-pivot"),
NoNewKeyring: context.Bool("no-new-keyring"),
Spec: spec,
})
if err != nil {
return nil, err
}
factory, err := loadFactory(context)
if err != nil {
return nil, err
}
return factory.Create(id, config)
}
// Populate updates the specified docker context based on command line arguments and subcommands.
func Populate(context *docker.Context, c *cli.Context) {
command.Populate(&context.Context, c)
context.ConfigDir = c.String("configdir")
opts := client.Options{}
opts.TLS = c.GlobalBool("tls")
opts.TLSVerify = c.GlobalBool("tlsverify")
opts.TLSOptions.CAFile = c.GlobalString("tlscacert")
opts.TLSOptions.CertFile = c.GlobalString("tlscert")
opts.TLSOptions.KeyFile = c.GlobalString("tlskey")
clientFactory, err := client.NewDefaultFactory(opts)
if err != nil {
logrus.Fatalf("Failed to construct Docker client: %v", err)
}
context.ClientFactory = clientFactory
}
func mustNewClient(c *cli.Context) client.Client {
hc, err := newClient(c)
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
debug := c.GlobalBool("debug")
if debug {
client.EnablecURLDebug()
}
if !c.GlobalBool("no-sync") {
if debug {
fmt.Fprintf(os.Stderr, "start to sync cluster using endpoints(%s)\n", strings.Join(hc.Endpoints(), ","))
}
ctx, cancel := contextWithTotalTimeout(c)
err := hc.Sync(ctx)
cancel()
if err != nil {
if err == client.ErrNoEndpoints {
fmt.Fprintf(os.Stderr, "etcd cluster has no published client endpoints.\n")
fmt.Fprintf(os.Stderr, "Try '--no-sync' if you want to access non-published client endpoints(%s).\n", strings.Join(hc.Endpoints(), ","))
handleError(ExitServerError, err)
}
if isConnectionError(err) {
handleError(ExitBadConnection, err)
}
}
if debug {
fmt.Fprintf(os.Stderr, "got endpoints(%s) after sync\n", strings.Join(hc.Endpoints(), ","))
}
}
if debug {
fmt.Fprintf(os.Stderr, "Cluster-Endpoints: %s\n", strings.Join(hc.Endpoints(), ", "))
}
return hc
}
func handleTOS(c *cli.Context, client *acme.Client, acc *Account) {
// Check for a global accept override
if c.GlobalBool("accept-tos") {
err := client.AgreeToTOS()
if err != nil {
logger().Fatalf("Could not agree to TOS: %s", err.Error())
}
acc.Save()
return
}
reader := bufio.NewReader(os.Stdin)
logger().Printf("Please review the TOS at %s", acc.Registration.TosURL)
for {
logger().Println("Do you accept the TOS? Y/n")
text, err := reader.ReadString('\n')
if err != nil {
logger().Fatalf("Could not read from console: %s", err.Error())
}
text = strings.Trim(text, "\r\n")
if text == "n" {
logger().Fatal("You did not accept the TOS. Unable to proceed.")
}
if text == "Y" || text == "y" || text == "" {
err = client.AgreeToTOS()
if err != nil {
logger().Fatalf("Could not agree to TOS: %s", err.Error())
}
acc.Save()
break
}
logger().Println("Your input was invalid. Please answer with one of Y/y, n or by pressing enter.")
}
}
func cmdBatch(app *cli.App, c *cli.Context) error {
bufReader := bufio.NewReader(os.Stdin)
for {
line, more, err := bufReader.ReadLine()
if more {
return errors.New("Input line is too long")
} else if err == io.EOF {
break
} else if len(line) == 0 {
continue
} else if err != nil {
return err
}
args := []string{"tmsp-cli"}
if c.GlobalBool("verbose") {
args = append(args, "--verbose")
}
args = append(args, strings.Split(string(line), " ")...)
app.Run(args)
}
return nil
}
func printResponse(c *cli.Context, res types.Result, s string, printCode bool) {
if c.GlobalBool("verbose") {
fmt.Println(">", c.Command.Name, strings.Join(c.Args(), " "))
}
if printCode {
fmt.Printf("-> code: %s\n", res.Code.String())
}
/*if res.Error != "" {
fmt.Printf("-> error: %s\n", res.Error)
}*/
if s != "" {
fmt.Printf("-> data: {%s}\n", s)
}
if res.Log != "" {
fmt.Printf("-> log: %s\n", res.Log)
}
if c.GlobalBool("verbose") {
fmt.Println("")
}
}
func trigger(c *cli.Context) error {
PrintBitriseHeaderASCIIArt(version.VERSION)
// Expand cli.Context
prGlobalFlag := c.GlobalBool(PRKey)
ciGlobalFlag := c.GlobalBool(CIKey)
triggerPattern := c.String(PatternKey)
if triggerPattern == "" && len(c.Args()) > 0 {
triggerPattern = c.Args()[0]
}
pushBranch := c.String(PushBranchKey)
prSourceBranch := c.String(PRSourceBranchKey)
prTargetBranch := c.String(PRTargetBranchKey)
bitriseConfigBase64Data := c.String(ConfigBase64Key)
bitriseConfigPath := c.String(ConfigKey)
deprecatedBitriseConfigPath := c.String(PathKey)
if bitriseConfigPath == "" && deprecatedBitriseConfigPath != "" {
log.Warn("'path' key is deprecated, use 'config' instead!")
bitriseConfigPath = deprecatedBitriseConfigPath
}
inventoryBase64Data := c.String(InventoryBase64Key)
inventoryPath := c.String(InventoryKey)
jsonParams := c.String(JSONParamsKey)
jsonParamsBase64 := c.String(JSONParamsBase64Key)
triggerParams, err := parseTriggerParams(
triggerPattern,
pushBranch, prSourceBranch, prTargetBranch,
bitriseConfigPath, bitriseConfigBase64Data,
inventoryPath, inventoryBase64Data,
jsonParams, jsonParamsBase64)
if err != nil {
return fmt.Errorf("Failed to parse trigger command params, error: %s", err)
}
// Inventory validation
inventoryEnvironments, err := CreateInventoryFromCLIParams(triggerParams.InventoryBase64Data, triggerParams.InventoryPath)
if err != nil {
log.Fatalf("Failed to create inventory, error: %s", err)
}
// Config validation
bitriseConfig, warnings, err := CreateBitriseConfigFromCLIParams(triggerParams.BitriseConfigBase64Data, triggerParams.BitriseConfigPath)
for _, warning := range warnings {
log.Warnf("warning: %s", warning)
}
if err != nil {
log.Fatalf("Failed to create bitrise config, error: %s", err)
}
// Trigger filter validation
if triggerParams.TriggerPattern == "" {
// no trigger filter specified
// list all the available ones and then exit
log.Error("No pattern specified!")
printAvailableTriggerFilters(bitriseConfig.TriggerMap)
os.Exit(1)
}
//
// Main
isPRMode, err := isPRMode(prGlobalFlag, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check PR mode, error: %s", err)
}
if err := registerPrMode(isPRMode); err != nil {
log.Fatalf("Failed to register PR mode, error: %s", err)
}
isCIMode, err := isCIMode(ciGlobalFlag, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check CI mode, error: %s", err)
}
if err := registerCIMode(isCIMode); err != nil {
log.Fatalf("Failed to register CI mode, error: %s", err)
}
workflowToRunID, err := getWorkflowIDByPattern(bitriseConfig.TriggerMap, triggerParams.TriggerPattern, isPRMode)
if err != nil {
log.Fatalf("Failed to get workflow id by pattern, error: %s", err)
}
log.Infof("Pattern (%s) triggered workflow (%s) ", triggerParams.TriggerPattern, workflowToRunID)
runAndExit(bitriseConfig, inventoryEnvironments, workflowToRunID)
//
return nil
}
// preload initializes any global options and configuration
// before the main or sub commands are run.
func preload(context *cli.Context) error {
if context.GlobalBool("debug") {
logrus.SetLevel(logrus.DebugLevel)
}
return nil
}
func beforeApp(c *cli.Context) error {
if c.GlobalBool("verbose") {
logrus.SetLevel(logrus.DebugLevel)
}
return nil
}
func setupReplication(c *cli.Context, cluster cluster.Cluster, server *api.Server, discovery discovery.Backend, addr string, leaderTTL time.Duration, tlsConfig *tls.Config) {
kvDiscovery, ok := discovery.(*kvdiscovery.Discovery)
if !ok {
log.Fatal("Leader election is only supported with consul, etcd and zookeeper discovery.")
}
client := kvDiscovery.Store()
p := path.Join(kvDiscovery.Prefix(), leaderElectionPath)
candidate := leadership.NewCandidate(client, p, addr, leaderTTL)
follower := leadership.NewFollower(client, p)
primary := api.NewPrimary(cluster, tlsConfig, &statusHandler{cluster, candidate, follower}, c.GlobalBool("debug"), c.Bool("cors"))
replica := api.NewReplica(primary, tlsConfig)
go func() {
for {
run(cluster, candidate, server, primary, replica)
time.Sleep(defaultRecoverTime)
}
}()
go func() {
for {
follow(follower, replica, addr)
time.Sleep(defaultRecoverTime)
}
}()
server.SetHandler(primary)
}
func manage(c *cli.Context) {
var (
tlsConfig *tls.Config
err error
)
// If either --tls or --tlsverify are specified, load the certificates.
if c.Bool("tls") || c.Bool("tlsverify") {
if !c.IsSet("tlscert") || !c.IsSet("tlskey") {
log.Fatal("--tlscert and --tlskey must be provided when using --tls")
}
if c.Bool("tlsverify") && !c.IsSet("tlscacert") {
log.Fatal("--tlscacert must be provided when using --tlsverify")
}
tlsConfig, err = loadTLSConfig(
c.String("tlscacert"),
c.String("tlscert"),
c.String("tlskey"),
c.Bool("tlsverify"))
if err != nil {
log.Fatal(err)
}
} else {
// Otherwise, if neither --tls nor --tlsverify are specified, abort if
// the other flags are passed as they will be ignored.
if c.IsSet("tlscert") || c.IsSet("tlskey") || c.IsSet("tlscacert") {
log.Fatal("--tlscert, --tlskey and --tlscacert require the use of either --tls or --tlsverify")
}
}
refreshMinInterval := c.Duration("engine-refresh-min-interval")
refreshMaxInterval := c.Duration("engine-refresh-max-interval")
if refreshMinInterval <= time.Duration(0)*time.Second {
log.Fatal("min refresh interval should be a positive number")
}
if refreshMaxInterval < refreshMinInterval {
log.Fatal("max refresh interval cannot be less than min refresh interval")
}
// engine-refresh-retry is deprecated
refreshRetry := c.Int("engine-refresh-retry")
if refreshRetry != 3 {
log.Fatal("--engine-refresh-retry is deprecated. Use --engine-failure-retry")
}
failureRetry := c.Int("engine-failure-retry")
if failureRetry <= 0 {
log.Fatal("invalid failure retry count")
}
engineOpts := &cluster.EngineOpts{
RefreshMinInterval: refreshMinInterval,
RefreshMaxInterval: refreshMaxInterval,
FailureRetry: failureRetry,
}
uri := getDiscovery(c)
if uri == "" {
log.Fatalf("discovery required to manage a cluster. See '%s manage --help'.", c.App.Name)
}
discovery := createDiscovery(uri, c)
s, err := strategy.New(c.String("strategy"))
if err != nil {
log.Fatal(err)
}
// see https://github.com/urfave/cli/issues/160
names := c.StringSlice("filter")
if c.IsSet("filter") || c.IsSet("f") {
names = names[DefaultFilterNumber:]
}
fs, err := filter.New(names)
if err != nil {
log.Fatal(err)
}
sched := scheduler.New(s, fs)
var cl cluster.Cluster
switch c.String("cluster-driver") {
case "mesos-experimental":
log.Warn("WARNING: the mesos driver is currently experimental, use at your own risks")
cl, err = mesos.NewCluster(sched, tlsConfig, uri, c.StringSlice("cluster-opt"), engineOpts)
case "swarm":
cl, err = swarm.NewCluster(sched, tlsConfig, discovery, c.StringSlice("cluster-opt"), engineOpts)
default:
log.Fatalf("unsupported cluster %q", c.String("cluster-driver"))
}
if err != nil {
log.Fatal(err)
}
// see https://github.com/urfave/cli/issues/160
hosts := c.StringSlice("host")
if c.IsSet("host") || c.IsSet("H") {
hosts = hosts[1:]
}
server := api.NewServer(hosts, tlsConfig)
if c.Bool("replication") {
addr := c.String("advertise")
if addr == "" {
log.Fatal("--advertise address must be provided when using --leader-election")
}
if !checkAddrFormat(addr) {
log.Fatal("--advertise should be of the form ip:port or hostname:port")
}
leaderTTL, err := time.ParseDuration(c.String("replication-ttl"))
if err != nil {
log.Fatalf("invalid --replication-ttl: %v", err)
}
if leaderTTL <= time.Duration(0)*time.Second {
log.Fatalf("--replication-ttl should be a positive number")
}
setupReplication(c, cl, server, discovery, addr, leaderTTL, tlsConfig)
} else {
server.SetHandler(api.NewPrimary(cl, tlsConfig, &statusHandler{cl, nil, nil}, c.GlobalBool("debug"), c.Bool("cors")))
cluster.NewWatchdog(cl)
}
log.Fatal(server.ListenAndServe())
}
func run(c *cli.Context) error {
PrintBitriseHeaderASCIIArt(version.VERSION)
//
// Expand cli.Context
prGlobalFlag := c.GlobalBool(PRKey)
ciGlobalFlag := c.GlobalBool(CIKey)
workflowToRunID := c.String(WorkflowKey)
if workflowToRunID == "" && len(c.Args()) > 0 {
workflowToRunID = c.Args()[0]
}
bitriseConfigBase64Data := c.String(ConfigBase64Key)
bitriseConfigPath := c.String(ConfigKey)
deprecatedBitriseConfigPath := c.String(PathKey)
if bitriseConfigPath == "" && deprecatedBitriseConfigPath != "" {
log.Warn("'path' key is deprecated, use 'config' instead!")
bitriseConfigPath = deprecatedBitriseConfigPath
}
inventoryBase64Data := c.String(InventoryBase64Key)
inventoryPath := c.String(InventoryKey)
jsonParams := c.String(JSONParamsKey)
jsonParamsBase64 := c.String(JSONParamsBase64Key)
runParams, err := parseRunParams(
workflowToRunID,
bitriseConfigPath, bitriseConfigBase64Data,
inventoryPath, inventoryBase64Data,
jsonParams, jsonParamsBase64)
if err != nil {
return fmt.Errorf("Failed to parse command params, error: %s", err)
}
//
// Inventory validation
inventoryEnvironments, err := CreateInventoryFromCLIParams(runParams.InventoryBase64Data, runParams.InventoryPath)
if err != nil {
log.Fatalf("Failed to create inventory, error: %s", err)
}
// Config validation
bitriseConfig, warnings, err := CreateBitriseConfigFromCLIParams(runParams.BitriseConfigBase64Data, runParams.BitriseConfigPath)
for _, warning := range warnings {
log.Warnf("warning: %s", warning)
}
if err != nil {
log.Fatalf("Failed to create bitrise config, error: %s", err)
}
// Workflow id validation
if runParams.WorkflowToRunID == "" {
// no workflow specified
// list all the available ones and then exit
log.Error("No workfow specified!")
printAvailableWorkflows(bitriseConfig)
os.Exit(1)
}
if strings.HasPrefix(runParams.WorkflowToRunID, "_") {
// util workflow specified
// print about util workflows and then exit
printAboutUtilityWorkflows()
os.Exit(1)
}
//
//
// Main
isPRMode, err := isPRMode(prGlobalFlag, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check PR mode, error: %s", err)
}
if err := registerPrMode(isPRMode); err != nil {
log.Fatalf("Failed to register PR mode, error: %s", err)
}
isCIMode, err := isCIMode(ciGlobalFlag, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check CI mode, error: %s", err)
}
if err := registerCIMode(isCIMode); err != nil {
log.Fatalf("Failed to register CI mode, error: %s", err)
}
runAndExit(bitriseConfig, inventoryEnvironments, runParams.WorkflowToRunID)
//
return nil
}
func triggerCheck(c *cli.Context) error {
warnings := []string{}
//
// Expand cli.Context
prGlobalFlag := c.GlobalBool(PRKey)
triggerPattern := c.String(PatternKey)
if triggerPattern == "" && len(c.Args()) > 0 {
triggerPattern = c.Args()[0]
}
pushBranch := c.String(PushBranchKey)
prSourceBranch := c.String(PRSourceBranchKey)
prTargetBranch := c.String(PRTargetBranchKey)
bitriseConfigBase64Data := c.String(ConfigBase64Key)
bitriseConfigPath := c.String(ConfigKey)
deprecatedBitriseConfigPath := c.String(PathKey)
if bitriseConfigPath == "" && deprecatedBitriseConfigPath != "" {
warnings = append(warnings, "'path' key is deprecated, use 'config' instead!")
bitriseConfigPath = deprecatedBitriseConfigPath
}
inventoryBase64Data := c.String(InventoryBase64Key)
inventoryPath := c.String(InventoryKey)
jsonParams := c.String(JSONParamsKey)
jsonParamsBase64 := c.String(JSONParamsBase64Key)
format := c.String(OuputFormatKey)
triggerParams, err := parseTriggerCheckParams(
triggerPattern,
pushBranch, prSourceBranch, prTargetBranch,
format,
bitriseConfigPath, bitriseConfigBase64Data,
inventoryPath, inventoryBase64Data,
jsonParams, jsonParamsBase64)
if err != nil {
registerFatal(fmt.Sprintf("Failed to parse trigger check params, err: %s", err), warnings, triggerParams.Format)
}
//
// Inventory validation
inventoryEnvironments, err := CreateInventoryFromCLIParams(triggerParams.InventoryBase64Data, triggerParams.InventoryPath)
if err != nil {
registerFatal(fmt.Sprintf("Failed to create inventory, err: %s", err), warnings, triggerParams.Format)
}
// Config validation
bitriseConfig, warns, err := CreateBitriseConfigFromCLIParams(triggerParams.BitriseConfigBase64Data, triggerParams.BitriseConfigPath)
warnings = append(warnings, warns...)
if err != nil {
registerFatal(fmt.Sprintf("Failed to create config, err: %s", err), warnings, triggerParams.Format)
}
// Format validation
if triggerParams.Format == "" {
triggerParams.Format = output.FormatRaw
} else if !(triggerParams.Format == output.FormatRaw || triggerParams.Format == output.FormatJSON) {
registerFatal(fmt.Sprintf("Invalid format: %s", triggerParams.Format), warnings, output.FormatJSON)
}
// Trigger filter validation
if triggerParams.TriggerPattern == "" &&
triggerParams.PushBranch == "" && triggerParams.PRSourceBranch == "" && triggerParams.PRTargetBranch == "" {
registerFatal("No trigger pattern nor trigger params specified", warnings, triggerParams.Format)
}
//
//
// Main
isPRMode, err := isPRMode(prGlobalFlag, inventoryEnvironments)
if err != nil {
registerFatal(fmt.Sprintf("Failed to check PR mode, err: %s", err), warnings, triggerParams.Format)
}
workflowToRunID, err := getWorkflowIDByParamsInCompatibleMode(bitriseConfig.TriggerMap, triggerParams, isPRMode)
if err != nil {
registerFatal(err.Error(), warnings, triggerParams.Format)
}
switch triggerParams.Format {
case output.FormatRaw:
fmt.Printf("%s -> %s\n", triggerParams.TriggerPattern, colorstring.Blue(workflowToRunID))
break
case output.FormatJSON:
triggerModel := map[string]string{
"pattern": triggerParams.TriggerPattern,
"workflow": workflowToRunID,
}
bytes, err := json.Marshal(triggerModel)
if err != nil {
registerFatal(fmt.Sprintf("Failed to parse trigger model, err: %s", err), warnings, triggerParams.Format)
}
fmt.Println(string(bytes))
break
default:
registerFatal(fmt.Sprintf("Invalid format: %s", triggerParams.Format), warnings, output.FormatJSON)
}
//
return nil
}
func setupSpec(g *generate.Generator, context *cli.Context) error {
if context.GlobalBool("host-specific") {
g.HostSpecific = true
}
spec := g.Spec()
if len(spec.Version) == 0 {
g.SetVersion(rspec.Version)
}
if context.IsSet("hostname") {
g.SetHostname(context.String("hostname"))
}
g.SetPlatformOS(context.String("os"))
g.SetPlatformArch(context.String("arch"))
if context.IsSet("label") {
annotations := context.StringSlice("label")
for _, s := range annotations {
pair := strings.Split(s, "=")
if len(pair) != 2 {
return fmt.Errorf("incorrectly specified annotation: %s", s)
}
g.AddAnnotation(pair[0], pair[1])
}
}
g.SetRootPath(context.String("rootfs"))
if context.IsSet("read-only") {
g.SetRootReadonly(context.Bool("read-only"))
}
if context.IsSet("uid") {
g.SetProcessUID(uint32(context.Int("uid")))
}
if context.IsSet("gid") {
g.SetProcessGID(uint32(context.Int("gid")))
}
if context.IsSet("selinux-label") {
g.SetProcessSelinuxLabel(context.String("selinux-label"))
}
g.SetProcessCwd(context.String("cwd"))
if context.IsSet("apparmor") {
g.SetProcessApparmorProfile(context.String("apparmor"))
}
if context.IsSet("no-new-privileges") {
g.SetProcessNoNewPrivileges(context.Bool("no-new-privileges"))
}
if context.IsSet("tty") {
g.SetProcessTerminal(context.Bool("tty"))
}
if context.IsSet("args") {
g.SetProcessArgs(context.StringSlice("args"))
}
if context.IsSet("env") {
envs := context.StringSlice("env")
for _, env := range envs {
g.AddProcessEnv(env)
}
}
if context.IsSet("groups") {
groups := context.StringSlice("groups")
for _, group := range groups {
groupID, err := strconv.Atoi(group)
if err != nil {
return err
}
g.AddProcessAdditionalGid(uint32(groupID))
}
}
if context.IsSet("cgroups-path") {
g.SetLinuxCgroupsPath(context.String("cgroups-path"))
}
if context.IsSet("mount-label") {
g.SetLinuxMountLabel(context.String("mount-label"))
}
if context.IsSet("sysctl") {
sysctls := context.StringSlice("sysctl")
for _, s := range sysctls {
pair := strings.Split(s, "=")
if len(pair) != 2 {
return fmt.Errorf("incorrectly specified sysctl: %s", s)
}
g.AddLinuxSysctl(pair[0], pair[1])
}
}
privileged := false
if context.IsSet("privileged") {
privileged = context.Bool("privileged")
}
g.SetupPrivileged(privileged)
if context.IsSet("cap-add") {
addCaps := context.StringSlice("cap-add")
for _, cap := range addCaps {
if err := g.AddProcessCapability(cap); err != nil {
return err
}
}
}
if context.IsSet("cap-drop") {
dropCaps := context.StringSlice("cap-drop")
for _, cap := range dropCaps {
if err := g.DropProcessCapability(cap); err != nil {
return err
}
}
}
needsNewUser := false
var uidMaps, gidMaps []string
if context.IsSet("uidmappings") {
uidMaps = context.StringSlice("uidmappings")
}
if context.IsSet("gidmappings") {
gidMaps = context.StringSlice("gidmappings")
}
if len(uidMaps) > 0 || len(gidMaps) > 0 {
needsNewUser = true
}
setupLinuxNamespaces(context, g, needsNewUser)
if context.IsSet("tmpfs") {
tmpfsSlice := context.StringSlice("tmpfs")
for _, s := range tmpfsSlice {
dest, options, err := parseTmpfsMount(s)
if err != nil {
return err
}
g.AddTmpfsMount(dest, options)
}
}
mountCgroupOption := context.String("mount-cgroups")
if err := g.AddCgroupsMount(mountCgroupOption); err != nil {
return err
}
if context.IsSet("bind") {
binds := context.StringSlice("bind")
for _, bind := range binds {
source, dest, options, err := parseBindMount(bind)
if err != nil {
return err
}
g.AddBindMount(source, dest, options)
}
}
if context.IsSet("prestart") {
preStartHooks := context.StringSlice("prestart")
for _, hook := range preStartHooks {
path, args := parseHook(hook)
g.AddPreStartHook(path, args)
}
}
if context.IsSet("poststop") {
postStopHooks := context.StringSlice("poststop")
for _, hook := range postStopHooks {
path, args := parseHook(hook)
g.AddPostStopHook(path, args)
}
}
if context.IsSet("poststart") {
postStartHooks := context.StringSlice("poststart")
for _, hook := range postStartHooks {
path, args := parseHook(hook)
g.AddPostStartHook(path, args)
}
}
if context.IsSet("root-propagation") {
rp := context.String("root-propagation")
if err := g.SetLinuxRootPropagation(rp); err != nil {
return err
}
}
for _, uidMap := range uidMaps {
hid, cid, size, err := parseIDMapping(uidMap)
if err != nil {
return err
}
g.AddLinuxUIDMapping(hid, cid, size)
}
for _, gidMap := range gidMaps {
hid, cid, size, err := parseIDMapping(gidMap)
if err != nil {
return err
}
g.AddLinuxGIDMapping(hid, cid, size)
}
if context.IsSet("disable-oom-kill") {
g.SetLinuxResourcesDisableOOMKiller(context.Bool("disable-oom-kill"))
}
if context.IsSet("oom-score-adj") {
g.SetLinuxResourcesOOMScoreAdj(context.Int("oom-score-adj"))
}
if context.IsSet("linux-cpu-shares") {
g.SetLinuxResourcesCPUShares(context.Uint64("linux-cpu-shares"))
}
if context.IsSet("linux-cpu-period") {
g.SetLinuxResourcesCPUPeriod(context.Uint64("linux-cpu-period"))
}
if context.IsSet("linux-cpu-quota") {
g.SetLinuxResourcesCPUQuota(context.Uint64("linux-cpu-quota"))
}
if context.IsSet("linux-realtime-runtime") {
g.SetLinuxResourcesCPURealtimeRuntime(context.Uint64("linux-realtime-runtime"))
}
if context.IsSet("linux-realtime-period") {
g.SetLinuxResourcesCPURealtimePeriod(context.Uint64("linux-realtime-period"))
}
if context.IsSet("linux-cpus") {
g.SetLinuxResourcesCPUCpus(context.String("linux-cpus"))
}
if context.IsSet("linux-mems") {
g.SetLinuxResourcesCPUMems(context.String("linux-mems"))
}
if context.IsSet("linux-mem-limit") {
g.SetLinuxResourcesMemoryLimit(context.Uint64("linux-mem-limit"))
}
if context.IsSet("linux-mem-reservation") {
g.SetLinuxResourcesMemoryReservation(context.Uint64("linux-mem-reservation"))
}
if context.IsSet("linux-mem-swap") {
g.SetLinuxResourcesMemorySwap(context.Uint64("linux-mem-swap"))
}
if context.IsSet("linux-mem-kernel-limit") {
g.SetLinuxResourcesMemoryKernel(context.Uint64("linux-mem-kernel-limit"))
}
if context.IsSet("linux-mem-kernel-tcp") {
g.SetLinuxResourcesMemoryKernelTCP(context.Uint64("linux-mem-kernel-tcp"))
}
if context.IsSet("linux-mem-swappiness") {
g.SetLinuxResourcesMemorySwappiness(context.Uint64("linux-mem-swappiness"))
}
if context.IsSet("linux-pids-limit") {
g.SetLinuxResourcesPidsLimit(context.Int64("linux-pids-limit"))
}
var sd string
var sa, ss []string
if context.IsSet("seccomp-default") {
sd = context.String("seccomp-default")
}
if context.IsSet("seccomp-arch") {
sa = context.StringSlice("seccomp-arch")
}
if context.IsSet("seccomp-syscalls") {
ss = context.StringSlice("seccomp-syscalls")
}
if sd == "" && len(sa) == 0 && len(ss) == 0 {
return nil
}
// Set the DefaultAction of seccomp
if context.IsSet("seccomp-default") {
if err := g.SetLinuxSeccompDefault(sd); err != nil {
return err
}
}
// Add the additional architectures permitted to be used for system calls
if context.IsSet("seccomp-arch") {
for _, arch := range sa {
if err := g.AddLinuxSeccompArch(arch); err != nil {
return err
}
}
}
// Set syscall restrict in Seccomp
if context.IsSet("seccomp-syscalls") {
for _, syscall := range ss {
if err := g.AddLinuxSeccompSyscall(syscall); err != nil {
return err
}
}
}
if context.IsSet("seccomp-allow") {
seccompAllows := context.StringSlice("seccomp-allow")
for _, s := range seccompAllows {
g.AddLinuxSeccompSyscallAllow(s)
}
}
if context.IsSet("seccomp-errno") {
seccompErrnos := context.StringSlice("seccomp-errno")
for _, s := range seccompErrnos {
g.AddLinuxSeccompSyscallErrno(s)
}
}
return nil
}
func trigger(c *cli.Context) error {
PrintBitriseHeaderASCIIArt(version.VERSION)
// Expand cli.Context
var prGlobalFlagPtr *bool
if c.GlobalIsSet(PRKey) {
prGlobalFlagPtr = pointers.NewBoolPtr(c.GlobalBool(PRKey))
}
var ciGlobalFlagPtr *bool
if c.GlobalIsSet(CIKey) {
ciGlobalFlagPtr = pointers.NewBoolPtr(c.GlobalBool(CIKey))
}
triggerPattern := c.String(PatternKey)
if triggerPattern == "" && len(c.Args()) > 0 {
triggerPattern = c.Args()[0]
}
pushBranch := c.String(PushBranchKey)
prSourceBranch := c.String(PRSourceBranchKey)
prTargetBranch := c.String(PRTargetBranchKey)
tag := c.String(TagKey)
bitriseConfigBase64Data := c.String(ConfigBase64Key)
bitriseConfigPath := c.String(ConfigKey)
deprecatedBitriseConfigPath := c.String(PathKey)
if bitriseConfigPath == "" && deprecatedBitriseConfigPath != "" {
log.Warn("'path' key is deprecated, use 'config' instead!")
bitriseConfigPath = deprecatedBitriseConfigPath
}
inventoryBase64Data := c.String(InventoryBase64Key)
inventoryPath := c.String(InventoryKey)
jsonParams := c.String(JSONParamsKey)
jsonParamsBase64 := c.String(JSONParamsBase64Key)
triggerParams, err := parseTriggerParams(
triggerPattern,
pushBranch, prSourceBranch, prTargetBranch, tag,
bitriseConfigPath, bitriseConfigBase64Data,
inventoryPath, inventoryBase64Data,
jsonParams, jsonParamsBase64)
if err != nil {
return fmt.Errorf("Failed to parse trigger command params, error: %s", err)
}
// Inventory validation
inventoryEnvironments, err := CreateInventoryFromCLIParams(triggerParams.InventoryBase64Data, triggerParams.InventoryPath)
if err != nil {
log.Fatalf("Failed to create inventory, error: %s", err)
}
// Config validation
bitriseConfig, warnings, err := CreateBitriseConfigFromCLIParams(triggerParams.BitriseConfigBase64Data, triggerParams.BitriseConfigPath)
for _, warning := range warnings {
log.Warnf("warning: %s", warning)
}
if err != nil {
log.Fatalf("Failed to create bitrise config, error: %s", err)
}
// Trigger filter validation
if triggerParams.TriggerPattern == "" &&
triggerParams.PushBranch == "" && triggerParams.PRSourceBranch == "" && triggerParams.PRTargetBranch == "" && triggerParams.Tag == "" {
log.Error("No trigger pattern nor trigger params specified")
printAvailableTriggerFilters(bitriseConfig.TriggerMap)
os.Exit(1)
}
//
// Main
isPRMode, err := isPRMode(prGlobalFlagPtr, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check PR mode, error: %s", err)
}
if err := registerPrMode(isPRMode); err != nil {
log.Fatalf("Failed to register PR mode, error: %s", err)
}
isCIMode, err := isCIMode(ciGlobalFlagPtr, inventoryEnvironments)
if err != nil {
log.Fatalf("Failed to check CI mode, error: %s", err)
}
if err := registerCIMode(isCIMode); err != nil {
log.Fatalf("Failed to register CI mode, error: %s", err)
}
workflowToRunID, err := getWorkflowIDByParamsInCompatibleMode(bitriseConfig.TriggerMap, triggerParams, isPRMode)
if err != nil {
log.Errorf("Failed to get workflow id by pattern, error: %s", err)
if strings.Contains(err.Error(), "no matching workflow found with trigger params:") {
printAvailableTriggerFilters(bitriseConfig.TriggerMap)
}
os.Exit(1)
}
if triggerParams.TriggerPattern != "" {
log.Infof("pattern (%s) triggered workflow (%s)", triggerParams.TriggerPattern, workflowToRunID)
} else {
if triggerParams.PushBranch != "" {
log.Infof("push-branch (%s) triggered workflow (%s)", triggerParams.PushBranch, workflowToRunID)
} else if triggerParams.PRSourceBranch != "" || triggerParams.PRTargetBranch != "" {
log.Infof("pr-source-branch (%s) and pr-target-branch (%s) triggered workflow (%s)", triggerParams.PRSourceBranch, triggerParams.PRTargetBranch, workflowToRunID)
} else if triggerParams.Tag != "" {
log.Infof("tag (%s) triggered workflow (%s)", triggerParams.Tag, workflowToRunID)
}
}
runAndExit(bitriseConfig, inventoryEnvironments, workflowToRunID)
//
return nil
}