$ collins query -p DEVEL | collins query -S "~Maintenance"
400 Bad Request returned from collins: Invalid asset status specified. Valid values are Incomplete, New, Unallocated, Provisioning, Provisioned, Allocated, Cancelled, Decommissioned or Maintenance.

I think we can support this via raw CQL but I will need to look into it more.

collins power -t U007104 -p powerOff     

Works in the ruby client. When trying to run it in the go client it yields:

Unknown power action rebootx, expecting one of reboot,rebootsoft,reboothard,on,off,poweron,poweroff,identify,verify 

Can fix that here

By either adding "powerOff" as a possibility or making the whole switch statement case insensitive

I am creating man pages for each sub command but currently since you would have to manually install them they are of little to no use. We could embed the man pages in the binary on build and then install them on the users system. Not sure how good of an idea this is though...

$ go get github.com/michaeljs1990/collins-go-cli
package cgit.xrt0x.com/xrt0x/collins-go-cli/cmds: unrecognized import path "cgit.xrt0x.com/xrt0x/collins-go-cli/cmds" (https fetch: Get https://cgit.xrt0x.com/xrt0x/collins-go-cli/cmds?go-get=1: x509: certificate signed by unknown authority)

This should fail but the x509 error seems wrong as I have a valid cert. Will need to look into it more.

Ruby accepts both symbols and strings for the collins.yml file. We should add support for this just so it's easy to move from the ruby cli to the golang one.

It looks like when setting the -c flag I am outputting a ton of whitespace still for fields that aren't rendered.

For some queries you don't really care about the output looking pretty you just want to get some information. We should add in a flag that lets you turn on streaming for the table output format.

Historically, when we queried something like collins find -a attr:attr_value the output would include the attr column.

But, seems like we break this feature in this migration.

Collins query has some basic testing however an API level test is needed to ensure that outputting the fields works as you expect. For instance if you try and output information around hardware right now you will likely get empty results.

https://github.com/michaeljs1990/collins-go-cli/blob/master/format.go#L23 is where most of the work will need to be done.

Just a list of random formatting that currently might look a little off.

It would be nice to have the flags for hardware info, to spit results out in human readable format.

right now, when we run a query asking for hw info, like collins find <some param> -x disk_storage_total, the column for disk_storage_total is in bytes, it would be nice to have that in human readable format like, X-KB or X-Gb/GB.

along with that, it would be nice to know the what type of drive it is, say, a micron-ssd, samsung etc.
with a flag/attr call like disk_storage_type?

Not sure how this bug got introduced but it's pretty annoying. For whatever reason the first hostname is getting indented more than the rest. Dumping any debug information before this happens fixes the issue... :/

$ ./test query -p MESOS-PROD01 --limit 10
U0555      hostname    computeagentnode        Allocated       MESOS-PROD01    agent   
U0556 hostname    computeagentnode        Allocated       MESOS-PROD01    agent   

https://github.com/michaeljs1990/collins-go-cli/blob/master/collins/commands/format.go#L166 needs to be formatted. This should really be added to some ci job to ensure the code is formatted properly.

Let users dump password/username of IPMI device with the -x or -c flags.

Add debug mode environment variable so that you can have collins output things like the current CQL being sent to collins with the collins query command. Might be useful for outputting other things like the http endpoints being hit as well.

We should support outputting these assets by default for when the user may want to query on something like base_product.

https://github.com/michaeljs1990/go-collins/blob/master/collins/asset.go#L115

diff --git a/collins/commands/format.go b/collins/commands/format.go
index 1445ee7..e00a06a 100644
--- a/collins/commands/format.go
+++ b/collins/commands/format.go
@@ -48,6 +48,8 @@ func fieldToAssetStruct(field string, asset collins.Asset) string {
                return asset.Classification.Tag
        case "ipmi_address":
                return asset.IPMI.Address
+       case "base_product":
+               return asset.Hardware.Base.Product
        case "ip_address":
                return emptyOrValue(len(asset.Addresses), func() string {
                        ips := []string{}

Example patch that I added for quickly getting this today.

Often times when I am operating on a bunch of different pools or types of machine I end up with a directory full of different dumps of assets. It would be useful to support something like --save save-name and --load save-name for writing and reading those assets again. Additionally this lets you easily watch physical assets as they go through different states.

Similar functionality could be added by letting you pipe to collins query however this ends up getting back into having tons of asset dump files in a folder.

This will require a little work since the go-collins library will need to be updated for this. However currently you can't output information about GPUs.

To make the delete attribute function like all of the other query flags now we should allow users to specify multiple values to delete with -d values,i,hate instead of having to do -d values -d i -d hate which is needed right now.

This will take a little refactoring since the modify command turned into a little bit of a mess when I was throwing it together.

If a password is not provided in the collins.yml file we should ask the user to enter one on the command line before failing.

BMCs suck we should make the default to making 5 power requests at a time so that in the case that you have a bunch of flakey BMCs you don't need to wait for a large amount of time to make it through a list of 40 assets.

Allow for user to query about the number of GPUs installed on an asset. Possibly this is already available but need to verify and document it if so.

This doesn't work as one would expect. I likely botched something about reading from stdin that needs to be fixed. You can reproduce by catting any file with multiple tags in it to the command.

with the -a flag you are always doing an equality match. It is in some cases useful to be able to do not equal for getting hosts.

Not sure how I want to add this yet it could be key!:value however key! may be valid in collins in which case key!!:value would have to work properly as well.

Also we could use -na for not attribute (very clever). I am more a fan of !: support though and just making sure it handles the edge case above.

Made a dump mistake since range is a copy of the value not the value we want to modify.

diff --git a/src/query.go b/src/query.go
index 159f5b8..f5c220a 100644
--- a/src/query.go
+++ b/src/query.go
@@ -416,8 +416,8 @@ func queryRunCommand(c *cli.Context) error {
                size = c.Int("limit")
        }
 
-       for _, opt := range opts {
-               opt.PageOpts = collins.PageOpts{
+       for i, _ := range opts {
+               opts[i].PageOpts = collins.PageOpts{
                        Size: size,
                }
        }

Should add a unit test for this as well.

This is currently missing the IPAM subcommand from the main collins-cli repo. https://github.com/byxorna/collins-cli for reference contains all the features that will be ported over here.

Just realized when adding another custom column "asset_type" that in some very rare cases we could be stopping some values from being returned that has been set on the asset themselves.

The only way I can think to sanely solve this is by requiring that all columns that we compute client side to have an ~ or @ before them as both of these can't be used in a collins key. This would change the client to look like collins query -n aaanode -x @asset_type I like this as unlike ~ you don't need to quote it. I'm not going to fix this atm but if someone else sees this as a valid issue I'll add it.

The way we currently search for state and status using opts.Status and opts.State. We should see if we can just use raw CQL to find out this information which would allow you to not have to type out the full name "Allocated" and could instead do Allo or whatever if you are feeling lazy.

For whatever reason go get seems to be broken. It looks like it's not properly using my fork of go-collins.

$ go get -u cgit.xrt0x.com/xrt0x/collins-go-cli/cmd/collins

# cgit.xrt0x.com/xrt0x/collins-go-cli/collins/commands
../../gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli/collins/commands/ipam.go:202:31: client.IPAM.IPMIPools undefined (type *collins.IPAMService has no field or method IPMIPools, but does have IpmiPools)
../../gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli/collins/commands/profiles.go:33:50: undefined: collins.Profile
../../gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli/collins/commands/profiles.go:62:48: undefined: collins.Profile
../../gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli/collins/commands/profiles.go:131:37: client.Management.GetProvisioningProfiles undefined (type *collins.ManagementService has no field or method GetProvisioningProfiles)
../../gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli/collins/commands/query.go:452:20: opts[i].PageOpts.SortField undefined (type collins.PageOpts has no field or method SortField)

Broke bazel when I added some new files and forgot to include them in the library.

Make a function that allows you to return the profiles currently available in collins. Possibly some other information can be output around this number of those profiles in use or pools belonging to a given profile.

Generally being able to dump the current profiles though is helpful when determining what can be cleaned up.

we can query for the asset, based on the IP address, but sometimes we would also need to query for the IPMI IP, say something like collins find --ipmi_ip <ipmi ip>?

This currently takes the wrong action and tries to do a softoff which doesn't work in most cases. Re evaluate collins-cli to make sure we are mapping strings to the proper power actions.

Grab version output from git when building to ensure users know what they have installed locally.

The documentation can be about 80% stolen from the collins-cli repo however it would be good to document the differences between the client as well as all the additional fields that the collins query command supports as this will grow over time.

I followed the instructions in the README. I am unable to go get.

martin.velez@martin-velez-7510:~$ go version
go version go1.12.10 linux/amd64

martin.velez@martin-velez-7510:~$ go get -u cgit.xrt0x.com/xrt0x/collins-go-cli/cmd/collins
# cd .; git clone https://cgit.xrt0x.com/xrt0x/collins-go-cli /home/martin.velez/gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli
Cloning into '/home/martin.velez/gocode/src/cgit.xrt0x.com/xrt0x/collins-go-cli'...
fatal: early EOF
error: Unable to find 10e9d322f3c813fdb0122cef1aa3c2f869a82d7f under https://cgit.xrt0x.com/xrt0x/collins-go-cli
Cannot obtain needed blob 10e9d322f3c813fdb0122cef1aa3c2f869a82d7f
while processing commit 1691c4bcc5a2e8fb88f7f9ca54f9107706681ac4.
error: fetch failed.
package cgit.xrt0x.com/xrt0x/collins-go-cli/cmd/collins: exit status 128

Currently we support some metadata values in the output such as tag, asset_type, base_product and so on. All of the metadata fields should be support such as Created and Updated as well so it's easier to pull out.

diff --git a/collins/commands/format.go b/collins/commands/format.go
index 3cbe34b..c4f8cda 100644
--- a/collins/commands/format.go
+++ b/collins/commands/format.go
@@ -44,6 +44,8 @@ func fieldToAssetStruct(field string, asset collins.Asset) string {
 		return asset.Metadata.State.Name
 	case "asset_type":
 		return asset.Metadata.Type
+	case "created", "created_on":
+		return asset.Metadata.Created
 	case "classification":
 		return asset.Classification.Tag
 	case "base_product":

Right now you can do a negative match on attributes with key-:value however for flags such as -n devnode and -p DEV you can't currently. I'm not sure I like the above syntax since I am using for attributes. In practice no one is using - for keys but it is possible. I should likely find some character that is not valid CQL for matching on instead and let that be passed for the key such as %key:value or -n %devnode,something.

Need to verify that characters are illegal though.

collins query schuett | collins log -f

Currently this does not work but it should.

Currently in the collins ruby cli you can do this magic.

user@gentoo ~/code/collins-cli $ collins query dev -x addresses -H
tag             hostname                        nodeclass       status          pool            primary_role    secondary_role  addresses                                                                                                                                            
M0000002        dev-a7e8c3277b.pit1.terame.com  devnode         Provisioned     DEVELOPMENT     DEVELOPMENT                     Collins::Address(address = 10.0.0.102, gateway = 10.0.0.1, netmask = 255.255.255.0, is_private = true)                                               

I'm not sure that I want to add the exact same thing however something should be added that lets you get the same or similar information about the asset.

Look over docs for query and make sure it's up to date. I can already see that sort-field is missing.

I was thinking about adding symbol support to the golang collins client for reading from user, pass, and host when they are in the form of :user, :pass, and :host however go doesn't offer a nice way to do this. It might be easier to just verify the YAML config for users doesn't container them and if they do ask the user if they would like us to write out a file in the format we expect.

converting :user to user for instance will still work with collins-cli and collins-shell.