datasets

Documentation

Index

• Variables
• func CreateCmd() *cobra.Command
• func SaneLimit(format string, limit int) int
• type CreateDatasetConfig
• type ProxyDatasetConfig

Variables

var ChangesCmd = &cobra.Command{
	Use:   "changes",
	Short: "Shows the changes for a dataset",
	Long: `Lists the changes for a dataset. For example:
mim dataset changes --dataset=mim.Cows

`,
	Run: func(cmd *cobra.Command, args []string) {
		format := utils.ResolveFormat(cmd)
		if format != "term" {
			pterm.DisableOutput()
		}

		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		since, err := cmd.Flags().GetString("since")
		utils.HandleError(err)
		dataset, err := cmd.Flags().GetString("name")
		utils.HandleError(err)

		if dataset == "" && len(args) > 0 {
			dataset = args[0]
		}

		limit, err := cmd.Flags().GetInt("limit")
		utils.HandleError(err)

		reverse, err := cmd.Flags().GetBool("reverse")
		utils.HandleError(err)

		expanded, err := cmd.Flags().GetBool("expanded")
		utils.HandleError(err)

		pterm.DefaultSection.Println("Listing changes from " + server + fmt.Sprintf("/datasets/%s/changes", dataset))

		em := api.NewEntityManager(server, token, context.Background(), api.Changes)
		s := outputSink(format)
		if expanded {
			s = &api.SinkExpander{Sink: s}
		}
		err = em.Read(dataset, since, SaneLimit(format, limit), reverse, s)
		utils.HandleError(err)
	},
	TraverseChildren: true,
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) != 0 {
			return nil, cobra.ShellCompDirectiveNoFileComp
		}
		return api.GetDatasetsCompletion(toComplete), cobra.ShellCompDirectiveNoFileComp
	},
}

var DeleteCmd = &cobra.Command{
	Use:   "delete",
	Short: "Delete dataset with given id",
	Long: `Delete a dataset with given  id, For example:
mim datasets delete --id <id>
or
mim jobs delete -i <id>
`,
	Run: func(cmd *cobra.Command, args []string) {
		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		name, err := cmd.Flags().GetString("name")
		utils.HandleError(err)

		if len(args) > 0 {

			name = args[0]
		}

		if name == "" {
			pterm.Error.Println("You must provide a dataset name")
			os.Exit(1)
		}

		confirm, err := cmd.Flags().GetBool("confirm")
		utils.HandleError(err)

		pterm.EnableDebugMessages()

		pterm.DefaultSection.Println("Deleting dataset " + server + "/datasets/" + name)

		if confirm {
			pterm.DefaultSection.Printf("Delete dataset with name " + name + " on " + server + ", please type (y)es or (n)o and then press enter:")
			if utils.AskForConfirmation() {
				err = web.DeleteRequest(server, token, fmt.Sprintf("/datasets/%s", name))
				utils.HandleError(err)

				pterm.Success.Println("Deleted dataset")
				pterm.Println()
			} else {
				pterm.Println("Aborted!")
			}
		} else {
			err = web.DeleteRequest(server, token, fmt.Sprintf("/datasets/%s", name))
			utils.HandleError(err)

			pterm.Success.Println("Deleted dataset")
			pterm.Println()
		}
	},
	TraverseChildren: true,
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) != 0 {
			return nil, cobra.ShellCompDirectiveNoFileComp
		}
		return api.GetDatasetsCompletion(toComplete), cobra.ShellCompDirectiveNoFileComp
	},
}

deleteCmd represents the delete command

var EntitiesCmd = &cobra.Command{
	Use:   "entities",
	Short: "Shows the entities for a dataset",
	Long: `Lists the entities for a dataset. For example:
mim dataset entities --name=mim.Cows

`,
	Run: func(cmd *cobra.Command, args []string) {
		format := utils.ResolveFormat(cmd)
		if format != "term" {
			pterm.DisableOutput()
		}

		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		since, err := cmd.Flags().GetString("since")

		dataset, err := cmd.Flags().GetString("name")
		utils.HandleError(err)
		if dataset == "" && len(args) > 0 {
			dataset = args[0]
		}

		if dataset == "" {
			pterm.Warning.Println("You must provide a dataset name")
			pterm.Println()
			os.Exit(1)
		}

		limit, err := cmd.Flags().GetInt("limit")
		utils.HandleError(err)

		expanded, err := cmd.Flags().GetBool("expanded")
		utils.HandleError(err)

		pterm.DefaultSection.Println("Listing entities from " + server + fmt.Sprintf("/datasets/%s/entities", dataset))

		em := api.NewEntityManager(server, token, context.Background(), api.Entities)
		s := outputSink(format)
		if expanded {
			s = &api.SinkExpander{Sink: s}
		}
		err = em.Read(dataset, since, SaneLimit(format, limit), false, s)
		utils.HandleError(err)
	},
	TraverseChildren: true,
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) != 0 {
			return nil, cobra.ShellCompDirectiveNoFileComp
		}
		return api.GetDatasetsCompletion(toComplete), cobra.ShellCompDirectiveNoFileComp
	},
}

var GetCmd = &cobra.Command{
	Use:   "get",
	Short: "Get dataset with given name",
	Long: `Get a dataset with given name, For example:
mim dataset get --name <name>
or
mim dataset get <name>
`,
	Run: func(cmd *cobra.Command, args []string) {
		format := utils.ResolveFormat(cmd)
		if format == "json" {
			pterm.DisableOutput()
		}
		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		pterm.EnableDebugMessages()

		name, err := cmd.Flags().GetString("name")
		utils.HandleError(err)

		if len(args) > 0 {
			name = args[0]
		}

		dm := api.NewDatasetManager(server, token)

		e, err := dm.Get(name)
		utils.HandleError(err)
		printDataset(e, format)
		pterm.Println()

	},
	TraverseChildren: true,
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) != 0 {
			return nil, cobra.ShellCompDirectiveNoFileComp
		}
		return api.GetDatasetsCompletion(toComplete), cobra.ShellCompDirectiveNoFileComp
	},
}

deleteCmd represents the delete command

var ListCmd = &cobra.Command{
	Use:     "list",
	Aliases: []string{"ls"},
	Short:   "List all datasets",
	Long: `List all datasets. For example:
mim dataset list

`,
	Run: func(cmd *cobra.Command, args []string) {
		format := utils.ResolveFormat(cmd)
		if format == "json" {
			pterm.DisableOutput()
		}

		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		pterm.EnableDebugMessages()

		pterm.DefaultSection.Println("Listing datasets on " + server + "/datasets")

		dm := api.NewDatasetManager(server, token)

		sets, err := dm.List()
		utils.HandleError(err)

		resp, err := web.GetRequest(server, token, "/datasets/core.Dataset/entities")

		var coreDataset []api.Entity

		if err == nil {
			json.Unmarshal(resp, &coreDataset)
		}

		if coreDataset != nil {
			merged := mergeDatasetDetails(sets, coreDataset)
			renderDataSets(merged, format)
		} else {
			renderDataSets(sets, format)
		}
	},
	TraverseChildren: true,
}

var RenameCmd = &cobra.Command{
	Use:   "rename",
	Short: "Rename dataset with given id with a new name",
	Long: `Rename a dataset with given id with a new name, For example:
mim dataset rename --name <name> --new-name <newName>
`,
	Run: func(cmd *cobra.Command, args []string) {

		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		name, err := cmd.Flags().GetString("name")
		utils.HandleError(err)

		newName, err := cmd.Flags().GetString("newName")
		utils.HandleError(err)

		if name == "" || newName == "" {
			pterm.Error.Println("You must provide a dataset name and a new name")
			cmd.Usage()
			os.Exit(1)
		}

		confirm, err := cmd.Flags().GetBool("confirm")
		utils.HandleError(err)

		pterm.EnableDebugMessages()

		dm := api.NewDatasetManager(server, token)

		if confirm {
			pterm.DefaultSection.Printf("Rename dataset with name %s to %s on %s, please type (y)es or (n)o and then press enter:", name, newName, server)
			if utils.AskForConfirmation() {
				err = dm.Rename(name, newName)
				utils.HandleError(err)

				pterm.Success.Println("Renamed dataset")
				pterm.Println()
			} else {
				pterm.Println("Aborted!")
			}
		} else {
			pterm.DefaultSection.Printf("Renaming dataset %s to %s on %s", name, newName, server)
			err = dm.Rename(name, newName)
			utils.HandleError(err)

			pterm.Success.Println("Renamed dataset")
			pterm.Println()
		}
	},
	TraverseChildren: true,
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) != 0 {
			return nil, cobra.ShellCompDirectiveNoFileComp
		}
		return api.GetDatasetsCompletion(toComplete), cobra.ShellCompDirectiveNoFileComp
	},
}

RenameCmd represents the rename command

var StoreCmd = &cobra.Command{
	Use:   "store",
	Short: "Store entities in dataset with given name",
	Long: `Store entities in a dataset with given name, For example:
mim dataset store --name=<name> --file=entities.json
or
mim dataset create <name> entities.json
`,
	Run: func(cmd *cobra.Command, args []string) {
		server, token, err := login.ResolveCredentials()
		utils.HandleError(err)

		pterm.EnableDebugMessages()

		name, err := cmd.Flags().GetString("name")
		utils.HandleError(err)

		filename, err := cmd.Flags().GetString("filename")
		utils.HandleError(err)

		if len(args) == 1 {
			name = args[0]
		}
		if len(args) == 2 {
			name = args[0]
			filename = args[1]
		}

		err = storeEntities(server, token, name, filename)
		utils.HandleError(err)
		pterm.Success.Println("Entities Loaded")
		pterm.Println()

	},
	TraverseChildren: true,
	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
		if len(args) != 0 {
			return nil, cobra.ShellCompDirectiveNoFileComp
		}
		return api.GetDatasetsCompletion(toComplete), cobra.ShellCompDirectiveNoFileComp
	},
}

Functions

func CreateCmd

func CreateCmd() *cobra.Command

CreateCmd represents the delete command

func SaneLimit

func SaneLimit(format string, limit int) int

Types

type CreateDatasetConfig

type CreateDatasetConfig struct {
	ProxyDatasetConfig *ProxyDatasetConfig `json:"ProxyDatasetConfig"`
	PublicNamespaces   []string            `json:"publicNamespaces"`
}

type ProxyDatasetConfig

type ProxyDatasetConfig struct {
	RemoteUrl           string `json:"remoteUrl"`
	UpstreamTransform   string `json:"upstreamTransform"`
	DownstreamTransform string `json:"downstreamTransform"`
	AuthProviderName    string `json:"authProviderName"`
}