cmd

Documentation

Index

• Variables

Variables

var AddCustomRuleCmd = &cobra.Command{
	Use:   "add",
	Short: "Add new rule custom rule",
	RunE: func(cmd *cobra.Command, args []string) error {
		src, err := parseSourceRuleType(cmd.Flags())
		if err != nil {
			return err
		}
		dst, err := parseRuleType(cmd.Flags())
		if err != nil {
			return err
		}
		owner, _ := cmd.Flags().GetString("owner")
		if owner == "" {
			return errors.New("--owner argument is mandatory")
		}

		serviceName, _ := serviceInstanceName(args, 1)
		data, err := json.Marshal(types.Rule{
			Source:      *src,
			Destination: *dst,
			Metadata: map[string]string{
				"owner": owner,
			},
		})
		if err != nil {
			return err
		}
		body := bytes.NewReader(data)

		rsp, err := doProxyAdminRequest(http.MethodPost, serviceName, "/rules", body)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()

		return nil
	},
}

var AddRuleCmd = &cobra.Command{
	Use:   "add [service name] [instance name]",
	Short: "Add new rule",
	Example: `
# Add ACL to a destination tsuru app
tsuru acl rules add <ACL SERVICE> --app <MY DESTINATION APP>

# Add ACL to a destination tsuru pool (prefer to use fine grained by each app)
tsuru acl rules add <ACL SERVICE> --app-pool <MY DESTINATION APP POOL>

# Add ACL to a destination RPASS
tsuru acl rules add <ACL SERVICE> --rpaas "<RPAAS SERVICE NAME>/<RPAAS SERVICE INSTANCE>"

# Add ACL to a destination service by DNS
tsuru acl rules add <ACL SERVICE> --dns mydomain.globoi.com --port tcp:443

# Add ACL to a destination service by IP (prefer by DNS over IP)
tsuru acl rules add <ACL SERVICE> --ip MYIP/32 --port tcp:443
	`,
	Args: cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		rt, err := parseRuleType(cmd.Flags())
		if err != nil {
			return err
		}
		serviceName, instanceName := serviceInstanceName(args, 1)
		data, err := json.Marshal(types.Rule{Destination: *rt})
		if err != nil {
			return err
		}
		body := bytes.NewReader(data)
		rsp, err := doProxyRequest(http.MethodPost, serviceName, instanceName, "/rule", body)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()
		fmt.Println("Rule successfully added.")
		return nil
	},
}

var ForceSyncCmd = &cobra.Command{
	Use:   "sync [app name]",
	Short: "Force sync rules (for debug/troubleshooting purpose)",
	Args:  cobra.ExactArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		appName := args[0]
		rsp, err := doProxyAdminRequest(http.MethodPost, defaultServiceName, "/apps/"+appName+"/sync", nil)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()

		var response forceResponse
		err = json.NewDecoder(rsp.Body).Decode(&response)
		if err != nil {
			return err
		}

		fmt.Printf("Sync request sent, %d rules synced\n", response.Count)
		return nil
	},
}

var ListAllRulesCmd = &cobra.Command{
	Use:   "list [service name]",
	Short: "List all rules",
	RunE: func(cmd *cobra.Command, args []string) error {
		serviceName, _ := serviceInstanceName(args, 1)
		rsp, err := doProxyAdminRequest(http.MethodGet, serviceName, "/rules", nil)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()
		data, err := ioutil.ReadAll(rsp.Body)
		if err != nil {
			return err
		}
		jsonOutput, _ := cmd.Flags().GetBool("json")
		if jsonOutput {
			var prettyJSON bytes.Buffer
			err := json.Indent(&prettyJSON, data, "", "  ")
			if err != nil {
				return errors.Wrap(err, "failed to prettify JSON")
			}
			fmt.Println(prettyJSON.String())
			return nil
		}
		var rules []types.Rule
		err = json.Unmarshal(data, &rules)
		if err != nil {
			return errors.Wrapf(err, "unable to unmarshal %q", string(data))
		}
		rsp, err = doProxyAdminRequest(http.MethodGet, serviceName, "/rules/sync", nil)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()
		data, err = ioutil.ReadAll(rsp.Body)
		if err != nil {
			return err
		}
		var rulesSync []types.RuleSyncInfo
		err = json.Unmarshal(data, &rulesSync)
		if err != nil {
			return errors.Wrapf(err, "unable to unmarshal %q", string(data))
		}
		rsp, err = doProxyAdminRequest(http.MethodGet, serviceName, "/services", nil)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()
		data, err = ioutil.ReadAll(rsp.Body)
		if err != nil {
			return err
		}
		var serviceInstances []types.ServiceInstance
		err = json.Unmarshal(data, &serviceInstances)
		if err != nil {
			return errors.Wrapf(err, "unable to unmarshal %q", string(data))
		}
		fmt.Println("Service Rules:")
		renderServiceRules(serviceInstances, true)
		fmt.Println("Expanded Rules:")
		renderExpandedRules(rules, rulesSync)
		renderSyncInfo(rulesSync)
		extraSync, _ := cmd.Flags().GetBool("show-extra-sync")
		if extraSync {
			renderExtraSyncInfo(rules, rulesSync)
		}
		return nil
	},
}

var ListRuleCmd = &cobra.Command{
	Use:   "list [service name] [instance name]",
	Short: "List rules",
	Args:  cobra.MinimumNArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		serviceName, instanceName := serviceInstanceName(args, 1)
		rsp, err := doProxyRequest(http.MethodGet, serviceName, instanceName, "/rule", nil)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()
		data, err := ioutil.ReadAll(rsp.Body)
		if err != nil {
			return err
		}
		jsonOutput, _ := cmd.Flags().GetBool("json")
		if jsonOutput {
			var prettyJSON bytes.Buffer
			err := json.Indent(&prettyJSON, data, "", "  ")
			if err != nil {
				return errors.Wrap(err, "failed to prettify JSON")
			}
			fmt.Println(prettyJSON.String())
			return nil
		}
		var ruleData serviceRuleData
		err = json.Unmarshal(data, &ruleData)
		if err != nil {
			return errors.Wrapf(err, "unable to unmarshal %q", string(data))
		}
		fmt.Println("Rules:")
		renderServiceRules([]types.ServiceInstance{ruleData.ServiceInstance}, false)
		fmt.Println("Expanded Rules (for each bound app):")
		renderExpandedRules(ruleData.ExpandedRules, ruleData.RulesSync)
		showSync, _ := cmd.Flags().GetBool("show-sync")
		extraSync, _ := cmd.Flags().GetBool("show-extra-sync")
		if showSync || extraSync {
			renderSyncInfo(ruleData.RulesSync)
		}
		if extraSync {
			renderExtraSyncInfo(ruleData.ExpandedRules, ruleData.RulesSync)
		}
		return nil
	},
}

var RemoveRuleCmd = &cobra.Command{
	Use:   "remove [service name] [instance name] [id]",
	Short: "Remove rule",
	Args:  cobra.MinimumNArgs(2),
	RunE: func(cmd *cobra.Command, args []string) error {
		serviceName, instanceName := serviceInstanceName(args, 2)
		ruleID := args[len(args)-1]
		rsp, err := doProxyRequest(http.MethodDelete, serviceName, instanceName, "/rule/"+ruleID, nil)
		if err != nil {
			return err
		}
		defer rsp.Body.Close()
		fmt.Println("Rule successfully removed.")
		return nil
	},
}

var SyncDNSCmd = &cobra.Command{
	Use:   "sync-dns [cname]",
	Short: "Force sync rules (for debug/troubleshooting purpose)",
	Args:  cobra.ExactArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		dns := args[0]

		ruleIDs, err := rulesIDFromDNS(dns)
		if err != nil {
			return err
		}

		for i, ruleID := range ruleIDs {
			fmt.Printf("%d/%d Syncing rule %s\n", i+1, len(ruleIDs), ruleID)
			err = forceSyncRuleID(ruleID)
			if err != nil {
				fmt.Printf("Error Syncing rule %s, error: %s", ruleID, err)
			}
		}

		return nil
	},
}