diff --git a/cmd/definitions/bindata/bindata.go b/cmd/definitions/bindata/bindata.go index d038fc97c..2b964a786 100644 --- a/cmd/definitions/bindata/bindata.go +++ b/cmd/definitions/bindata/bindata.go @@ -6,8 +6,8 @@ // definitions/info_storage_meta.toml (1.139kB) // definitions/operations.toml (9.297kB) // definitions/pairs.toml (1.566kB) -// cmd/definitions/tmpl/service.tmpl (13.034kB) +//go:build tools // +build tools package bindata @@ -197,26 +197,6 @@ func definitionsPairsToml() (*asset, error) { return a, nil } -var _cmdDefinitionsTmplServiceTmpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5a\xdf\x73\xdb\xb8\xf1\x7f\xd7\x5f\xb1\xc7\xf1\x7c\x47\xca\x28\xd4\xdd\xb7\x7d\xa9\x3b\x7e\x68\x9d\x34\xf5\xdc\xe5\xe2\x39\xa7\xed\x43\xee\xc6\x03\x93\x4b\x09\x15\x09\x30\x00\x24\x47\xa3\xf2\x7f\xef\xe0\x07\x7f\x0a\xa0\x29\x27\x77\xd7\x87\xf8\xc5\x14\xb0\xd8\x5d\xec\x8f\x0f\x77\x09\xac\x56\x70\xcd\x53\x84\x35\x32\x14\x44\x61\x0a\x0f\x07\x58\xf3\xe6\x37\xec\x29\x81\xa4\x48\x57\x29\x66\x94\x51\x45\x39\x93\x7f\x86\x57\xef\xe0\xc7\x77\xef\xe1\xf5\xab\x9b\xf7\xf1\xac\x24\xc9\x96\xac\x11\x8e\x47\x88\x7f\x24\x05\x42\x55\xcd\x66\xb4\x28\xb9\x50\x30\x9f\x01\x00\x44\x09\x67\x0a\x3f\xa9\xc8\xfe\xa2\xdc\x3d\x30\x54\xab\x8d\x52\xa5\xfb\xa9\x68\x81\xd1\xcc\x3c\xc7\x10\xad\xa9\xda\xec\x1e\xe2\x84\x17\xab\x07\x3c\x70\x96\x4a\xc5\x05\x59\xe3\x6a\xcd\x5f\xd6\x8f\xfb\x3f\xae\x4a\x42\x85\x74\x0c\xa6\x2e\xd9\xae\x8d\xd8\x24\xa7\xc8\xd4\x79\x6b\x25\x8a\x3d\x4d\xd0\x49\x9c\xae\xa6\x3a\x94\x7a\xd1\x62\x36\xdb\x13\x01\xf7\x70\x67\xa7\x84\xfb\x59\xb3\x8d\xef\xec\xc3\x6b\x21\x78\x3d\xd7\xaa\x1a\xbf\x2b\x8d\x03\xdc\x84\xb6\x57\xfc\x6a\x27\x88\x1e\xec\x10\xc7\x3f\xe1\xc7\x1d\x4a\xe5\x86\x2c\xaf\xd9\x6a\x05\xef\x0f\x25\x02\x95\xa0\x36\x08\x5a\x21\xc8\xb8\xe8\xb9\x2d\xe1\x4c\x2a\x4b\x76\x05\x51\x67\x26\x32\xeb\xdf\x3d\xfc\x1b\x13\x75\x77\x90\x0a\x8b\xb7\xa8\x48\x4a\x14\x01\xbd\x49\x94\x20\xcd\x28\x14\xf5\xb0\x66\xcd\x0d\x7d\x3c\x33\xb2\x02\x8b\xc5\x2e\x51\x70\x9c\x1d\x8f\x2f\x41\x10\xb6\x46\xb8\xb8\x5f\xc2\xc5\x1e\x2e\xaf\x20\xbe\x61\x19\x97\x5a\x2f\x6d\x6b\x4d\x41\x33\xc0\x8f\x70\xb1\x8f\xef\x12\x5e\x22\x44\x56\x40\x34\x20\x61\x5c\x69\x9a\x37\x39\x7f\x20\x79\x77\xee\xa2\x64\x7a\x3b\x97\x57\x7a\xda\xec\xec\x3f\xa0\xf8\x2d\x91\x49\x9f\x8e\x66\x9a\xe0\x15\x95\x65\x4e\x0e\xb5\x6d\xc0\xfd\x75\x18\x5d\x05\xc8\x34\x09\xb2\xb4\xfd\x69\xe8\x50\x26\x82\x1a\x07\x76\x27\x2c\xa7\xaa\x72\x54\xc6\xf6\x21\x36\xcd\xcf\xce\x63\x65\x3c\xf3\x06\x95\xd7\xbe\x8f\x34\xcf\x61\x8d\xca\x6f\xfd\x4c\xf0\xc2\xcd\xc4\xb3\xd5\x4a\x33\x7a\x09\xef\x37\x54\x42\xb6\x63\x89\xd1\x54\x6e\xf8\x2e\x4f\x8d\x49\x1f\x10\x12\x92\xe7\x16\x22\x5c\xc0\x02\x2d\xca\x1c\x0b\x64\x0a\x45\x5c\xaf\x47\x10\xa8\x76\x82\x51\xb6\xae\xe5\x5a\xea\x46\x30\x95\x20\x90\xa4\xc0\x59\x7e\x00\xc2\xd2\x81\x98\x82\xa7\x34\xa3\x98\xc6\x33\xad\x47\x68\x73\x73\x0e\x2f\xec\xf8\xc2\xbf\xbd\xa3\x31\x9b\x2c\x96\xc0\xb7\xda\xe9\x3c\x7e\x83\x43\x1e\x0b\x43\x43\x33\x4d\x72\x6c\x7c\x6c\xf5\x07\x59\xc4\x73\x1f\x67\xbb\xc8\x7a\xc5\x91\xfa\xc8\x8e\xb5\x77\xe4\x98\x77\x64\xc8\x3b\x94\x29\x3e\xcd\x3b\xc6\x8c\xad\x7b\x38\x4b\x70\x09\x65\x8e\x44\x22\x14\x64\x8b\x20\x77\x02\x81\xe4\x39\x18\xc6\x1b\x22\xe1\x01\x91\xc1\xa3\xa0\x4a\x21\x83\x07\xcc\xb8\x40\xad\x89\xb3\x78\x40\xe1\xd6\xe2\x4b\x90\x85\x57\xeb\x85\xb3\x22\x8f\xef\x4e\x6c\x2d\x8b\x85\x33\x88\x43\xbf\xe9\x48\xe2\x90\xd4\x0c\x3a\x3c\x09\xf1\xf8\x2c\x40\x71\x72\xa2\x61\xc2\x87\x50\xc5\x03\x0a\xa3\xe8\x32\xe0\x19\x46\x99\x33\xd0\xa6\x4b\xda\x81\x8b\x76\x38\x80\x3e\x5d\x82\x11\x14\x3a\x1f\x89\xfc\x9e\x69\xa0\xc8\x07\x42\x6e\xc9\x5b\xe3\xde\x36\xd6\xbb\x48\xe2\xe7\x7a\x36\x92\x78\xd9\xcc\x25\xbc\xe8\xa8\xb0\x08\x08\x1b\x02\x8a\x7c\x0e\xa0\x78\x59\x7b\x10\xc5\x4b\xd7\x85\x94\x11\x33\xcb\x53\x33\x1b\x34\x09\x98\xf9\x37\x82\x94\x29\xa6\x37\xc0\xe2\x37\x51\x6d\xfe\x30\xb2\x78\x73\xfe\x56\x17\x88\x75\xa8\xfa\xf2\x78\x4a\xee\xae\x56\xf0\x2f\xaa\x36\xbd\x54\x31\x96\x26\x65\x99\x1f\x5c\xd6\xb8\xa4\x84\x3d\xc9\x77\x08\x1a\xbc\x6d\xb9\x66\x4c\xed\x4d\xc3\x1e\x04\x99\xa4\x8b\x1e\x38\xcf\x0d\xfc\x18\xab\x0d\x85\xce\x17\xa0\xf7\x73\x1a\x59\x7a\xb4\x1d\xfc\x1e\x0f\x97\xa6\x7e\x6b\xb5\x8a\x96\xcd\xec\x3f\xb5\x7e\x97\xa0\xc4\x0e\x97\x2e\xee\x5c\x22\xe7\x12\xc3\xa2\xf7\x7d\x70\xf8\x82\x9a\xec\x07\x6a\x9c\x40\x4b\xe7\xd1\x14\xb5\xba\xe8\x7f\x4b\x4a\xb8\x82\x82\x94\x1f\xa4\x12\x94\xad\x7f\xb1\xff\x9c\x42\xe3\xa1\x70\x0e\x64\x0f\x94\x6f\x76\xe3\xcc\xe0\x76\xd3\xc7\x41\xaf\x74\xcd\x41\x96\x24\xc1\x9e\x0a\x0a\x8b\x32\xd7\x8d\x56\x44\x75\x11\x95\xe9\xf9\xc8\xa4\xd8\x5d\xae\x0b\xac\x5a\xf4\xc5\x3e\xbe\x69\x08\xfc\x0c\x32\x24\x6a\x27\x82\xcb\xff\xb6\x63\x89\x34\x0f\x8e\xce\xcf\x45\xdb\xf6\x9e\xe1\x63\x97\xcb\xdc\x67\x9f\x85\x19\xc4\xc7\x1e\x4b\x13\xe3\x19\xd9\xe5\x8a\x3c\xe4\x18\x96\x30\x50\xb2\xd5\xcf\xbf\x33\x87\x4e\xe3\x5b\x1b\x04\x8a\x7e\x36\x5d\xeb\xc0\xb6\x6d\xca\x6b\xb7\x50\x96\xe2\x27\x88\xe1\xdb\x66\xdc\xd0\xca\xee\xdc\x77\x7a\x4e\xc7\xdd\x3c\x18\x5b\xf5\x2a\xa7\xfe\x7d\x17\x12\x7a\x31\x05\x57\xf0\x7f\x36\xad\xfa\xe3\xc7\x93\x57\xeb\x22\xb8\x9b\xd6\xd1\xa1\xbd\xf4\xc3\xd8\x90\x64\xec\x74\x4f\x76\xa2\x37\xfe\xff\x46\x9a\xa9\xb0\x9c\x9a\x55\xd5\x78\xb7\xa9\xae\x82\x66\xc8\xe4\xa4\xae\xc7\x6b\x19\x0d\x7d\xa7\xc9\x14\x32\x42\x1b\xa7\x4f\x39\x34\x63\x81\x8d\x67\x27\x1b\x37\xe3\x69\xd9\x1d\xff\x43\x23\xf9\x22\x63\x5b\xbb\x49\xe6\x03\x0b\xfd\x92\xd0\x4a\x35\x66\xd3\x0f\x7a\x49\x55\xd5\x4d\x77\x49\x84\xc4\xd4\x99\xd1\x1a\x79\xb0\x42\x2f\xa8\xaa\xbe\xa1\x4d\xbe\xc0\x87\x5f\x34\x7c\xd9\xcf\x23\xab\x15\xe8\x1e\x9f\x0a\x4c\xed\xac\xcf\x21\x7a\xa2\x56\xb7\xa1\x76\x3e\xf8\x3b\x91\x46\x28\xa1\xc2\xe7\x09\xe8\xfa\x62\x8c\xac\x9d\x1e\x69\x5c\x57\x2b\xf7\x26\x24\xf9\x34\x6d\x1b\xea\x2f\xad\xed\x64\x7d\x5f\x33\x03\x5f\x75\xa2\x8d\x2b\x9c\xd5\x0b\x37\x44\xda\x85\x63\x6a\x34\xba\x3e\x4d\xda\xdf\xd9\x50\x47\x87\xb3\x23\x26\x35\xf1\xad\xc3\xb9\xd5\xcf\x2d\x32\x52\x33\xf3\x42\x1c\xd5\x71\x1a\x79\x6d\x57\x47\x11\x30\x6d\x9d\x21\x42\xe2\x6d\x20\x4d\x4c\x49\x65\x28\x6c\x71\x21\x0d\xd0\x9b\xd2\xf5\x45\x20\xb5\x6c\xb1\x32\xc6\x75\xce\x4b\x55\xa7\xcf\x02\xe6\x01\x3e\x4b\x40\x21\xb8\xa8\xab\x4c\x81\x52\xdb\xf6\xf2\x2a\x94\xd2\x6d\x89\x63\xec\x7f\x09\x5a\x4a\x5d\xc7\x98\x7f\xba\x6f\xbd\x5f\x82\xc1\x45\xeb\x15\xa3\x48\xbb\x50\x3e\x52\x95\x6c\x60\x1f\x7f\x8f\x87\xce\xb0\x3f\xb9\xcf\x4c\x70\xfd\x97\xe8\x62\x3d\xea\x07\x98\xae\x60\x7a\xdd\x1f\xcd\xdc\x5e\xe3\x27\xb2\xec\x78\xd2\x9b\x26\x9c\x29\xca\x76\xd8\x9b\xe8\xf7\x96\xd3\x58\x5f\x99\x5a\xd4\xb7\x70\x7c\xd5\x3e\x36\x05\x64\x3c\x1f\x66\xf5\x22\xd4\xb9\x86\xe1\xe8\x4c\x48\xfa\x6a\xdf\x31\xfb\xfa\xe0\x73\xd4\xc0\xd9\xa9\x5d\xd1\xf0\xb8\x9f\x6c\xde\x49\xe0\xfb\x39\x46\x9e\x24\x20\x6c\xea\xb3\xd7\xfa\x4d\x7b\x8a\xfa\x3e\xc3\x0e\x91\xbf\x35\x6b\x6a\xd7\xdf\x9f\x40\xfa\xb8\x69\xa7\xbd\x08\x3e\xd3\xbc\xd3\x84\x84\x4d\x3c\x75\x7d\x3f\xae\xfb\x6f\xad\xd1\xd0\xae\xba\xf8\xfe\xec\x32\xe1\xd9\x31\x3b\xc8\xf6\x5e\x69\x3e\xb0\x4a\x37\xbf\xbb\x74\x4f\x64\x7c\xc3\xe3\xe4\xed\xfd\xfc\xaa\xe3\xb3\xe2\xa8\xdd\x72\x77\xa5\xde\x91\x6d\xe6\x3d\x39\xd3\xd1\x85\x9b\x4a\x5e\x4b\xea\x35\x97\x81\x90\x69\xb8\x1a\x23\xf1\xf2\xc4\x3a\xa4\x2c\x91\xa5\xf3\xb3\x97\x2e\xdb\x8f\x29\xc1\x3d\xfb\xb8\x06\x89\x17\xc1\x28\xf5\xfb\xed\x78\x9c\x5a\x37\xd0\x0c\xbe\x39\xf7\x7d\xe5\x3e\xfc\x84\x0a\xa5\x6a\xd9\x1e\x6f\xea\xfd\xd4\x22\xcd\xb9\xe4\x11\xbe\xc7\x83\xbc\xfc\xe0\xbe\xde\x1c\x3d\xef\x53\xa8\x60\x6c\x6f\x4e\xba\x55\x7a\x09\x8c\xe6\x4f\x34\x8d\x13\x3e\x01\x98\x6f\x9a\xc3\x9e\xb1\x5e\x62\x7b\xc0\x32\xd8\x03\xf6\xe2\x62\xdb\x44\x2a\x95\x90\x76\x73\xc7\x9e\x6b\x94\x98\xd0\x8c\x26\x40\xcc\xf7\x0d\xdb\x12\x06\x18\x8c\x1e\x6d\x58\x95\x9f\xea\xb0\x5d\x0f\xd9\x2f\xca\x3d\x79\x73\xca\x12\xbc\x5f\x71\x7a\x9f\x63\x4a\x06\x17\xfb\xd1\x13\x82\x13\x57\x3c\xab\x77\x9f\xe2\x87\xb3\xdb\xf5\xed\xf9\xfd\xfa\x60\xc9\x13\x2d\xfb\xef\xd1\x9c\x4f\x6b\x77\xff\x37\x1b\x71\x6f\xb7\xb8\x7d\x4e\xbb\xb8\xf5\xf4\x8b\x73\x09\x2f\xda\xd9\xc5\xa8\x98\x60\xff\xb8\x3d\xb7\x81\xdc\xfe\x46\x1d\xe4\xd7\x3e\xf1\xec\x3e\xc6\xab\xa7\xa7\x02\xfc\xda\x22\xfe\x6a\xa6\x75\x6f\xc7\xbe\x6d\xea\x83\xf2\x92\xe9\x1d\xb8\x2a\xf6\x07\xce\x6d\xba\x0e\x8f\xb2\x57\x2b\xc8\xf5\xdc\xbd\xf1\x8b\x2b\xcb\x35\x20\x08\x9e\xee\x12\x4c\x81\x32\x78\x73\x77\xfb\xf2\xbb\x6f\xff\x14\x0f\x17\xde\x64\xb0\x93\x28\xc0\xf6\x9d\xa0\xcc\xa9\xa8\xe5\xd0\x14\x30\xf5\xe9\x28\x5d\x33\x2e\xd0\x1c\x25\xca\x5d\x69\x6e\xba\x19\x89\x06\x01\xe2\xa1\x73\x65\x5c\x37\x08\x71\xab\xf9\xb3\x7c\x19\x38\xe2\x3f\x29\xc0\xb6\xe3\x15\xd8\x3f\x98\xd3\xba\x2e\xc2\xf4\xe0\xe5\x3e\xdc\xe7\x5c\x6f\x30\xd9\x82\xe8\x7d\x95\x8a\xcf\x7d\xad\x7d\x91\xd2\xf2\x89\x9d\xfd\x9e\xb5\x65\xe7\x90\xaa\x7f\xc4\x38\x76\x34\xd3\x90\xf9\x4b\x4e\x8f\x89\xc3\xb5\x99\xbd\x50\xf2\x03\x1f\xdc\x37\xe9\x97\x6d\xb9\x9e\xbe\xaf\x75\x0d\x16\x70\x8d\x35\xdc\x91\xb0\x9f\xd9\x74\x36\x4f\x5d\x1e\xf1\x5a\xf2\xb9\xe5\xe1\x94\xd2\xaf\x53\x46\xd8\xc7\xe1\x51\x95\xbd\x1e\xd1\xbf\x1c\x61\x0a\x8e\x44\xa0\xde\x3c\x01\x77\xab\x15\x1e\x0e\x35\x76\xc5\xdd\xea\xe2\xa2\x64\x55\xb5\xe8\x08\x9a\x9b\xe3\x9d\xf8\x96\x08\x52\xc8\xf8\xce\x04\xa5\xa6\x70\xe3\x3f\x99\x28\xeb\x4e\xd8\x3c\x48\xd4\x27\xbd\x17\x27\x2d\xfe\x2b\x49\xb6\x6b\xc1\x77\x2c\x75\x77\x4d\xea\xbb\x25\x71\x2b\x49\xb7\x9b\xd7\x96\x7e\x9e\xa8\x4f\x4b\xe8\x49\xbe\x26\x79\x8e\x42\x43\xf4\xd0\x14\x9d\x75\x01\xab\x8c\xed\x6f\x20\xb5\xd1\xd8\x8d\x0d\xb4\x98\xbc\xff\x14\x33\x14\xc6\x07\xf3\x45\xbf\xc6\xb9\x28\x89\xda\xd4\x7e\x76\x6c\x6f\x89\xda\xd8\x0d\x7a\xd2\x83\xb0\x14\xe6\xf8\xd1\x2d\x8c\xa2\x85\xfb\xc5\x20\x72\x57\x14\xa3\x85\xf7\x7a\x94\x26\xbf\x82\x68\xf9\x73\xf4\x73\x74\x72\x39\x6c\x80\xc8\x28\x04\x5c\x69\xd0\xe7\xa2\x20\xca\x20\xd1\x3c\xb2\x5b\xd4\xb1\x58\x55\x91\x29\x15\x5b\xc6\x55\x05\xee\xfe\xcf\x7c\xd1\xa6\x3c\xcd\x80\xa1\x2d\x2c\xcc\x3d\xbb\xb7\x3c\x45\x88\xfa\xd8\x52\xe8\xb1\xba\xfc\x68\xa9\x4e\x21\x46\x63\x2f\x8f\xf5\x64\x7c\x63\xa0\xd7\xac\x34\xf7\x49\x8e\x43\xc5\x6b\x3c\x6d\x19\xde\xb0\x3d\xc9\xa9\x03\xd5\xd7\x9f\x4a\x4c\x14\xa6\x97\xa0\xa7\x3a\xbc\x96\xf0\x97\x44\xed\x48\x7e\x09\x56\x52\x35\x40\xf1\x11\x9c\x2d\xdd\xb7\x1c\xf7\x81\xc5\xfc\x5c\x82\x8c\x5d\x5a\xb5\x5f\x56\x6c\xa0\xc5\x71\x6c\x0d\xb6\x27\x42\x97\xc4\xa1\x4f\x0f\x96\x39\x2f\xd5\xb2\x71\xca\xe8\x41\x91\x91\xdb\x5c\xe0\xd2\x4b\xbe\xb9\xd2\xa0\x7f\xf2\x42\xea\xbe\x1e\x07\xe9\xd7\xe2\xcd\x35\x29\xd0\x7c\xd9\x39\xcd\xc0\xf7\x82\x16\x3f\x10\xa9\x5c\x2a\xbe\x66\xa9\xae\xe4\x37\xd7\xbc\x28\x48\x55\x69\x8d\x17\x23\x2f\x9a\x21\x84\x8f\xbd\x6d\xba\x73\x3e\xb0\xac\x23\xfc\x09\xc0\x74\x75\xc0\x93\xa0\x69\xe9\x6a\xf2\x73\xc1\x53\x2f\xfb\x15\x00\xf4\x73\x22\x6c\x72\x94\xb9\x2d\xdf\xd8\xca\xd0\x14\x82\xf0\xb8\xa1\x39\xc2\x86\xb0\x34\xa7\x6c\x0d\xc6\x6f\x7a\x83\xee\x56\x58\xbd\xcc\x04\xe8\xfd\xe4\xf0\x1c\x16\x47\x46\xef\x40\xe8\x9d\x1d\x75\x36\xb0\xbb\x91\x67\x1c\x42\x19\x55\x0d\x56\x4c\xbc\xdd\xa4\xff\x1a\x30\xf9\x09\xd7\x54\x2a\x14\xa1\x4f\x53\x62\xae\xfb\x86\x25\xfc\x88\x8f\x41\x92\x85\xef\xeb\xc5\x89\x84\xbb\x64\x83\x05\x71\xec\xdc\x45\x31\x9d\x4d\xff\x0d\x00\x00\xff\xff\xf9\xfa\xc3\x3f\xea\x32\x00\x00") - -func cmdDefinitionsTmplServiceTmplBytes() ([]byte, error) { - return bindataRead( - _cmdDefinitionsTmplServiceTmpl, - "cmd/definitions/tmpl/service.tmpl", - ) -} - -func cmdDefinitionsTmplServiceTmpl() (*asset, error) { - bytes, err := cmdDefinitionsTmplServiceTmplBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "cmd/definitions/tmpl/service.tmpl", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf9, 0x38, 0x7, 0x48, 0xc1, 0x89, 0x2, 0x17, 0x3b, 0xe2, 0x4f, 0x8a, 0xb7, 0xb6, 0x40, 0x21, 0xac, 0x6, 0xa7, 0xc9, 0xe8, 0xee, 0x99, 0x5b, 0xe8, 0x17, 0x17, 0x19, 0x7, 0x66, 0x42, 0xed}} - return a, nil -} - // Asset loads and returns the asset for the given name. // It returns an error if the asset could not be found or // could not be loaded. @@ -314,7 +294,6 @@ var _bindata = map[string]func() (*asset, error){ "definitions/info_storage_meta.toml": definitionsInfo_storage_metaToml, "definitions/operations.toml": definitionsOperationsToml, "definitions/pairs.toml": definitionsPairsToml, - "cmd/definitions/tmpl/service.tmpl": cmdDefinitionsTmplServiceTmpl, } // AssetDebug is true if the assets were built with the debug flag enabled. @@ -361,13 +340,6 @@ type bintree struct { } var _bintree = &bintree{nil, map[string]*bintree{ - "cmd": {nil, map[string]*bintree{ - "definitions": {nil, map[string]*bintree{ - "tmpl": {nil, map[string]*bintree{ - "service.tmpl": {cmdDefinitionsTmplServiceTmpl, map[string]*bintree{}}, - }}, - }}, - }}, "definitions": {nil, map[string]*bintree{ "features.toml": {definitionsFeaturesToml, map[string]*bintree{}}, "fields.toml": {definitionsFieldsToml, map[string]*bintree{}}, diff --git a/cmd/definitions/gen_func.go b/cmd/definitions/gen_func.go index 936a1d569..01c86474f 100644 --- a/cmd/definitions/gen_func.go +++ b/cmd/definitions/gen_func.go @@ -10,7 +10,7 @@ import ( ) func generateFunc(ns *Namespace, path string) { - f := gg.Group() + f := gg.NewGroup() nsNameP := templateutils.ToPascal(ns.Name) @@ -23,38 +23,38 @@ func generateFunc(ns *Namespace, path string) { fnNameP := templateutils.ToPascal(fn.Name) if fn.Local { - gfn := f.Function(fnNameC). - Receiver("s", "*"+nsNameP) + gfn := f.NewFunction(fnNameC). + WithReceiver("s", "*"+nsNameP) for _, v := range fn.Params { // We need to remove pair from generated functions. if v.Type() == "...Pair" { continue } - gfn.Parameter(v.Name, v.Type()) + gfn.AddParameter(v.Name, v.Type()) } - gfn.Parameter("opt", "pair"+nsNameP+fnNameP) + gfn.AddParameter("opt", "pair"+nsNameP+fnNameP) for _, v := range fn.Results { - gfn.Result(v.Name, v.Type()) + gfn.AddResult(v.Name, v.Type()) } - gfn.Body(gg.String(`panic("not implemented")`)) + gfn.AddBody(gg.S(`panic("not implemented")`)) continue } - gfn := f.Function(fnNameC). - Receiver("s", "*"+nsNameP) - gfn.Parameter("ctx", "context.Context") + gfn := f.NewFunction(fnNameC). + WithReceiver("s", "*"+nsNameP) + gfn.AddParameter("ctx", "context.Context") for _, v := range fn.Params { // We need to remove pair from generated functions. if v.Type() == "...Pair" { continue } - gfn.Parameter(v.Name, v.Type()) + gfn.AddParameter(v.Name, v.Type()) } - gfn.Parameter("opt", "pair"+nsNameP+fnNameP) + gfn.AddParameter("opt", "pair"+nsNameP+fnNameP) for _, v := range fn.Results { - gfn.Result(v.Name, v.Type()) + gfn.AddResult(v.Name, v.Type()) } - gfn.Body(gg.String(`panic("not implemented")`)) + gfn.AddBody(`panic("not implemented")`) continue } diff --git a/cmd/definitions/gen_info.go b/cmd/definitions/gen_info.go index e2469e8b4..211fb4121 100644 --- a/cmd/definitions/gen_info.go +++ b/cmd/definitions/gen_info.go @@ -4,18 +4,16 @@ package main import ( - "fmt" - "github.com/Xuanwo/gg" "github.com/Xuanwo/templateutils" log "github.com/sirupsen/logrus" ) func generateInfo(data *Data, path string) { - f := gg.Group() - f.LineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") - f.Package("types") - f.Imports().Path("fmt") + f := gg.NewGroup() + f.AddLineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") + f.AddPackage("types") + f.NewImport().AddPath("fmt") for serviceName, infos := range data.InfosMap { serviceNameC := templateutils.ToCamel(serviceName) @@ -23,75 +21,72 @@ func generateInfo(data *Data, path string) { serviceNameK := templateutils.ToKebab(serviceName) // Generate field bits - f.LineComment("Field index in %s bit", serviceNameC) - consts := f.Const() + f.AddLineComment("Field index in %s bit", serviceNameC) + consts := f.NewConst() for k, v := range infos { - consts.Field( - fmt.Sprintf("%sIndex%s", + consts.AddField( + gg.S("%sIndex%s", serviceNameC, templateutils.ToPascal(v.Name)), - fmt.Sprintf("1<<%d", k), + gg.S("1<<%d", k), ) } // Generate struct - st := f.Struct(serviceNameP) + st := f.NewStruct(serviceNameP) for _, v := range infos { - st.Field(v.TypeName(), v.Type()) + st.AddField(v.TypeName(), v.Type()) } - st.Line() - st.LineComment("bit used as a bitmap for object value, 0 means not set, 1 means set") - st.Field("bit", "uint64") - st.Field("m", "map[string]interface{}") + st.AddLine() + st.AddLineComment("bit used as a bitmap for object value, 0 means not set, 1 means set") + st.AddField("bit", "uint64") + st.AddField("m", "map[string]interface{}") // Generate Get/Set functions. for _, v := range infos { // If the value is export, we don't need to generate MustGetXxxx if v.Export { - f.Function("Get"+v.DisplayName()). - Receiver("m", "*"+serviceNameP). - Result("", v.Type()). - Body(gg.Return().Id("m." + v.TypeName())) - f.Function("Set"+v.DisplayName()). - Receiver("m", "*"+serviceNameP). - Parameter("v", v.Type()). - Result("", "*"+serviceNameP). - Body( - gg.String("m.%s = v", v.TypeName()), - gg.Return().Id("m"), + f.NewFunction("Get"+v.DisplayName()). + WithReceiver("m", "*"+serviceNameP). + AddResult("", v.Type()). + AddBody(gg.Return("m." + v.TypeName())) + f.NewFunction("Set"+v.DisplayName()). + WithReceiver("m", "*"+serviceNameP). + AddParameter("v", v.Type()). + AddResult("", "*"+serviceNameP). + AddBody( + gg.S("m.%s = v", v.TypeName()), + gg.Return("m"), ) continue } - f.Function("Get"+v.DisplayName()). - Receiver("m", "*"+serviceNameP). - Result("", v.Type()). - Result("", "bool"). - Body( - gg.If(gg.String("m.bit & %sIndex%s != 0", + f.NewFunction("Get"+v.DisplayName()). + WithReceiver("m", "*"+serviceNameP). + AddResult("", v.Type()). + AddResult("", "bool"). + AddBody( + gg.If(gg.S("m.bit & %sIndex%s != 0", serviceNameC, templateutils.ToPascal(v.Name))). - Body( - gg.Return().Id("m."+v.TypeName()).Lit(true)), - gg.Return().Id(templateutils.ZeroValue(v.Type())).Lit(false), + AddBody(gg.Return("m."+v.TypeName(), gg.Lit(true))), + gg.Return(templateutils.ZeroValue(v.Type()), gg.Lit(false)), ) - f.Function("MustGet"+v.DisplayName()). - Receiver("m", "*"+serviceNameP). - Result("", v.Type()). - Body( - gg.If(gg.String("m.bit & %sIndex%s == 0", + f.NewFunction("MustGet"+v.DisplayName()). + WithReceiver("m", "*"+serviceNameP). + AddResult("", v.Type()). + AddBody( + gg.If(gg.S("m.bit & %sIndex%s == 0", serviceNameC, templateutils.ToPascal(v.Name))). - Body(gg.String( + AddBody(gg.S( `panic(fmt.Sprintf("%s %s is not set"))`, serviceNameK, v.Name)), - gg.Return().Id("m."+v.TypeName()), - ) - f.Function("Set"+v.DisplayName()). - Receiver("m", "*"+serviceNameP). - Parameter("v", v.Type()). - Result("", "*"+serviceNameP). - Body( - gg.String("m.%s = v", v.TypeName()), - gg.String("m.bit |= %sIndex%s", - serviceNameC, templateutils.ToPascal(v.Name)), - gg.Return().Id("m"), + gg.Return("m."+v.TypeName())) + f.NewFunction("Set"+v.DisplayName()). + WithReceiver("m", "*"+serviceNameP). + AddParameter("v", v.Type()). + AddResult("", "*"+serviceNameP). + AddBody( + gg.S("m.%s = v", v.TypeName()), + gg.S("m.bit |= %sIndex%s", serviceNameC, templateutils.ToPascal(v.Name)), + gg.Return("m"), ) } } diff --git a/cmd/definitions/gen_object.go b/cmd/definitions/gen_object.go index 7fcaf70c4..d6c3fc3ab 100644 --- a/cmd/definitions/gen_object.go +++ b/cmd/definitions/gen_object.go @@ -4,32 +4,29 @@ package main import ( - "fmt" - "github.com/Xuanwo/gg" "github.com/Xuanwo/templateutils" log "github.com/sirupsen/logrus" ) func generateObject(data *Data, path string) { - f := gg.Group() - f.LineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") - f.Package("types") - f.Imports(). - Path("fmt"). - Path("time"). - Path("sync") - - f.LineComment("Field index in object bit") - cons := f.Const() + f := gg.NewGroup() + f.AddLineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") + f.AddPackage("types") + f.NewImport(). + AddPath("fmt"). + AddPath("time"). + AddPath("sync") + + f.AddLineComment("Field index in object bit") + cons := f.NewConst() for k, v := range data.ObjectMeta { pname := templateutils.ToPascal(v.Name) - cons.Field( - fmt.Sprintf("objectIndex%s uint64", pname), - fmt.Sprintf("1<<%d", k)) + cons.AddTypedField( + "objectIndex"+pname, "uint64", gg.S("1<<%d", k)) } - f.LineComment(` + f.AddLineComment(` Object is the smallest unit in go-storage. NOTES: @@ -39,94 +36,97 @@ NOTES: - Only ID, Path, Mode are required during list operations, other fields could be fetched via lazy stat logic: https://beyondstorage.io/docs/go-storage/internal/object-lazy-stat `) - ob := f.Struct("Object") + ob := f.NewStruct("Object") for _, v := range data.ObjectMeta { - if v.originalDescription != "" { - ob.LineComment(v.originalDescription) + if v.Description != "" { + ob.AddLineComment(v.Description) } - ob.Field(v.TypeName(), v.Type()) + ob.AddField(v.TypeName(), v.Type()) } - ob.LineComment("client is the client in which Object is alive.") - ob.Field("client", "Storager") + ob.AddLineComment("client is the client in which Object is alive.") + ob.AddField("client", "Storager") - ob.LineComment("bit used as a bitmap for object value, 0 means not set, 1 means set") - ob.Field("bit", "uint64") - ob.Field("done", "uint32") - ob.Field("m", "sync.Mutex") + ob.AddLineComment("bit used as a bitmap for object value, 0 means not set, 1 means set") + ob.AddField("bit", "uint64") + ob.AddField("done", "uint32") + ob.AddField("m", "sync.Mutex") for _, v := range data.ObjectMeta { pname := templateutils.ToPascal(v.Name) if v.Export { - f.Function("Get"+v.DisplayName()). - Receiver("o", "*Object"). - Result("", v.Type()). - Body(gg.Return().Id("o." + v.TypeName())) - f.Function("Set"+v.DisplayName()). - Receiver("o", "*Object"). - Parameter("v", v.Type()). - Result("", "*Object"). - Body( - gg.String("o.%s = v", v.TypeName()), - gg.Return().Id("o"), + f.NewFunction("Get"+v.DisplayName()). + WithReceiver("o", "*Object"). + AddResult("", v.Type()). + AddBody(gg.Return(gg.S("o.%s", v.TypeName()))) + f.NewFunction("Set"+v.DisplayName()). + WithReceiver("o", "*Object"). + AddParameter("v", v.Type()). + AddResult("", "*Object"). + AddBody( + gg.S("o.%s = v", v.TypeName()), + gg.Return("o"), ) continue } - f.Function("Get"+v.DisplayName()). - Receiver("o", "*Object"). - NamedLineComment(`will get %s from Object. + + f.AddLineComment(`Get%s will get %s from Object. %s -`, v.DisplayName(), v.Description). - Result("", v.Type()). - Result("", "bool"). - Body( - gg.String("o.stat()"), +`, v.DisplayName(), v.DisplayName(), v.Description) + f.NewFunction("Get"+v.DisplayName()). + WithReceiver("o", "*Object"). + AddResult("", v.Type()). + AddResult("", "bool"). + AddBody( + gg.S("o.stat()"), gg.Line(), - gg.If(gg.String("o.bit & objectIndex%s != 0", pname)). - Body( - gg.Return().Id("o."+v.TypeName()).Lit(true), + gg.If(gg.S("o.bit & objectIndex%s != 0", pname)). + AddBody( + gg.Return("o."+v.TypeName(), gg.Lit(true)), ), - gg.Return().Id(templateutils.ZeroValue(v.Type())).Lit(false), + gg.Return(templateutils.ZeroValue(v.Type()), gg.Lit(false)), ) - f.Function("MustGet"+v.DisplayName()). - Receiver("o", "*Object"). - NamedLineComment(`will get %s from Object. + + f.AddLineComment(`MustGet%s will get %s from Object. %s -`, v.DisplayName(), v.originalDescription). - Result("", v.Type()). - Body( - gg.String("o.stat()"), +`, v.DisplayName(), v.DisplayName(), v.Description) + f.NewFunction("MustGet"+v.DisplayName()). + WithReceiver("o", "*Object"). + AddResult("", v.Type()). + AddBody( + gg.S("o.stat()"), gg.Line(), - gg.If(gg.String("o.bit & objectIndex%s == 0", pname)). - Body( - gg.String(`panic(fmt.Sprintf("object %s is not set"))`, v.Name), + gg.If(gg.S("o.bit & objectIndex%s == 0", pname)). + AddBody( + gg.S(`panic(fmt.Sprintf("object %s is not set"))`, v.Name), ), - gg.Return().Id("o."+v.TypeName()), + gg.Return("o."+v.TypeName()), ) - f.Function("Set"+v.DisplayName()). - Receiver("o", "*Object"). - NamedLineComment(`will set %s into Object. + + f.AddLineComment(`Set%s will get %s into Object. %s -`, v.DisplayName(), v.originalDescription). - Parameter("v", v.Type()). - Result("", "*Object"). - Body( - gg.String("o.%s = v", v.TypeName()), - gg.String("o.bit |= objectIndex%s", pname), - gg.Return().Id("o"), +`, v.DisplayName(), v.DisplayName(), v.Description) + f.NewFunction("Set"+v.DisplayName()). + WithReceiver("o", "*Object"). + AddParameter("v", v.Type()). + AddResult("", "*Object"). + AddBody( + gg.S("o.%s = v", v.TypeName()), + gg.S("o.bit |= objectIndex%s", pname), + gg.Return("o"), ) } - fn := f.Function("clone"). - Receiver("o", "*Object"). - Parameter("xo", "*Object") + fn := f.NewFunction("clone"). + WithReceiver("o", "*Object"). + AddParameter("xo", "*Object") for _, v := range data.ObjectMeta { - fn.Body(gg.String("o.%s = xo.%s", v.TypeName(), v.TypeName())) + fn.AddBody(gg.S("o.%s = xo.%s", v.TypeName(), v.TypeName())) } - fn.Body(gg.String("o.bit = xo.bit")) + fn.AddBody(gg.S("o.bit = xo.bit")) err := f.WriteFile(path) if err != nil { diff --git a/cmd/definitions/gen_op.go b/cmd/definitions/gen_op.go index 3d8807251..9e23a30a5 100644 --- a/cmd/definitions/gen_op.go +++ b/cmd/definitions/gen_op.go @@ -10,99 +10,100 @@ import ( ) func generateOperation(data *Data, path string) { - f := gg.Group() - f.LineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") - f.Package("types") - f.Imports(). - Path("context"). - Path("io"). - Path("net/http"). - Path("time") + f := gg.NewGroup() + f.AddLineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") + f.AddPackage("types") + f.NewImport(). + AddPath("context"). + AddPath("io"). + AddPath("net/http"). + AddPath("time") for _, in := range data.Interfaces { - f.LineComment("%s %s", in.DisplayName(), in.originalDescription) + f.AddLineComment("%s %s", in.DisplayName(), in.Description) - inter := f.Interface(in.DisplayName()) + inter := f.NewInterface(in.DisplayName()) if in.Name == "servicer" || in.Name == "storager" { - inter.Function("String").Result("", "string") + inter.NewFunction("String").AddResult("", "string") } for _, op := range in.SortedOps() { pname := templateutils.ToPascal(op.Name) - gop := inter.Function(pname). - NamedLineComment(op.originalDescription) + inter.AddLineComment("%s %s", pname, op.Description) + gop := inter.NewFunction(pname) for _, p := range op.Params { - gop.Parameter(p.Name, p.Type()) + gop.AddParameter(p.Name, p.Type()) } for _, r := range op.Results { - gop.Result(r.Name, r.Type()) + gop.AddResult(r.Name, r.Type()) } // We need to generate XxxWithContext functions if not local. if !op.Local { - gop := inter.Function(pname + "WithContext"). - NamedLineComment(op.originalDescription) + inter.AddLineComment("%sWithContext %s", pname, op.Description) + gop := inter.NewFunction(pname + "WithContext") + // Insert context param. - gop.Parameter("ctx", "context.Context") + gop.AddParameter("ctx", "context.Context") for _, p := range op.Params { - gop.Parameter(p.Name, p.Type()) + gop.AddParameter(p.Name, p.Type()) } for _, r := range op.Results { - gop.Result(r.Name, r.Type()) + gop.AddResult(r.Name, r.Type()) } } // Insert an empty for different functions. - inter.Line() + inter.AddLine() } - inter.Function("mustEmbedUnimplemented" + in.DisplayName()) + inter.NewFunction("mustEmbedUnimplemented" + in.DisplayName()) stubName := "Unimplemented" + in.DisplayName() - f.LineComment("%s must be embedded to have forward compatible implementations.", stubName) - f.Struct(stubName) + f.AddLineComment("%s must be embedded to have forward compatible implementations.", stubName) + f.NewStruct(stubName) - f.Function("mustEmbedUnimplemented"+in.DisplayName()). - Receiver("s", stubName) - f.Function("String"). - Receiver("s", stubName). - Result("", "string"). - Body( - gg.Return().Lit(stubName)) + f.NewFunction("mustEmbedUnimplemented"+in.DisplayName()). + WithReceiver("s", stubName) + f.NewFunction("String"). + WithReceiver("s", stubName). + AddResult("", "string"). + AddBody( + gg.Return(gg.Lit(stubName))) for _, op := range in.SortedOps() { pname := templateutils.ToPascal(op.Name) - gop := f.Function(pname). - Receiver("s", stubName) + gop := f.NewFunction(pname). + WithReceiver("s", stubName) for _, p := range op.Params { - gop.Parameter(p.Name, p.Type()) + gop.AddParameter(p.Name, p.Type()) } for _, r := range op.Results { - gop.Result(r.Name, r.Type()) + gop.AddResult(r.Name, r.Type()) } // If not local, we need to set error if !op.Local { - gop.Body(gg.String(`err = NewOperationNotImplementedError("%s")`, op.Name)) + gop.AddBody(gg.S(`err = NewOperationNotImplementedError("%s")`, op.Name)) } - gop.Body(gg.Return()) + gop.AddBody(gg.Return()) // We need to generate XxxWithContext functions if not local. if !op.Local { - gop := f.Function(pname+"WithContext"). - Receiver("s", stubName) + gop := f.NewFunction(pname+"WithContext"). + WithReceiver("s", stubName) // Insert context param. - gop.Parameter("ctx", "context.Context") + gop.AddParameter("ctx", "context.Context") for _, p := range op.Params { - gop.Parameter(p.Name, p.Type()) + gop.AddParameter(p.Name, p.Type()) } for _, r := range op.Results { - gop.Result(r.Name, r.Type()) + gop.AddResult(r.Name, r.Type()) } - gop.Body( - gg.String(`err = NewOperationNotImplementedError("%s")`, op.Name), + gop.AddBody( + gg.S(`err = NewOperationNotImplementedError("%s")`, op.Name), gg.Return(), ) } diff --git a/cmd/definitions/gen_pair.go b/cmd/definitions/gen_pair.go index e094d6cca..1684d5e07 100644 --- a/cmd/definitions/gen_pair.go +++ b/cmd/definitions/gen_pair.go @@ -12,15 +12,15 @@ import ( ) func generatePair(data *Data, path string) { - f := gg.Group() - f.LineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") - f.Package("pairs") - f.Imports(). - Path("context"). - Path("time"). - Line(). - Path("github.com/beyondstorage/go-storage/v4/pkg/httpclient"). - Dot("github.com/beyondstorage/go-storage/v4/types") + f := gg.NewGroup() + f.AddLineComment("Code generated by go generate cmd/definitions; DO NOT EDIT.") + f.AddPackage("pairs") + f.NewImport(). + AddPath("context"). + AddPath("time"). + AddLine(). + AddPath("github.com/beyondstorage/go-storage/v4/pkg/httpclient"). + AddDot("github.com/beyondstorage/go-storage/v4/types") ps := make([]*Pair, 0, len(data.Pairs)) for _, v := range data.Pairs { @@ -34,42 +34,31 @@ func generatePair(data *Data, path string) { for _, v := range ps { pname := templateutils.ToPascal(v.Name) - xfn := f.Function("With" + pname) + f.AddLineComment(`With%s will apply %s value to Options. - xfn.NamedLineComment(`will apply %s value to Options. - -%s %s`, v.Name, pname, v.originalDescription) - xfn.Parameter("v", v.Type()) - xfn.Result("p", "Pair") - xfn.Body( - gg.Embed(func() gg.Node { - r := gg.Return() - r.Value("Pair"). - Field("Key", gg.Lit(v.Name).String()). - Field("Value", "v") - return r - }), - ) +%s %s`, pname, v.Name, pname, v.Description) + xfn := f.NewFunction("With" + pname) + xfn.AddParameter("v", v.Type()) + xfn.AddResult("p", "Pair") + xfn.AddBody( + gg.Return( + gg.Value("Pair"). + AddField("Key", gg.Lit(v.Name)). + AddField("Value", "v"))) if v.Defaultable { name := "default_" + v.Name pname := templateutils.ToPascal(name) - xfn := f.Function("With" + pname) + f.AddLineComment(`With%s will apply %s value to Options. - xfn.NamedLineComment(`will apply %s value to Options. +%s %s`, pname, name, pname, v.Description) -%s %s`, name, pname, v.originalDescription) - xfn.Parameter("v", v.Type()) - xfn.Result("p", "Pair") - xfn.Body( - gg.Embed(func() gg.Node { - r := gg.Return() - r.Value("Pair"). - Field("Key", gg.Lit(name).String()). - Field("Value", "v") - return r - }), - ) + xfn := f.NewFunction("With" + pname) + xfn.AddParameter("v", v.Type()) + xfn.AddResult("p", "Pair") + xfn.AddBody( + gg.Return( + gg.Value("Pair").AddField("Key", gg.Lit("default_"+v.Name)).AddField("Value", "v"))) } } diff --git a/cmd/definitions/gen_service.go b/cmd/definitions/gen_service.go new file mode 100644 index 000000000..74e99a304 --- /dev/null +++ b/cmd/definitions/gen_service.go @@ -0,0 +1,561 @@ +//go:build tools +// +build tools + +package main + +import ( + "fmt" + "github.com/Xuanwo/gg" + "github.com/Xuanwo/templateutils" + log "github.com/sirupsen/logrus" +) + +func generateSrv(data *Service, path string) { + f := gg.NewGroup() + f.AddLineComment("Code generated by go generate via cmd/definitions; DO NOT EDIT.") + f.AddPackage(data.Name) + f.NewImport(). + AddPath("context"). + AddPath("io"). + AddPath("net/http"). + AddPath("time"). + AddLine(). + AddDot("github.com/beyondstorage/go-storage/v4/pairs"). + AddPath("github.com/beyondstorage/go-storage/v4/pkg/httpclient"). + AddPath("github.com/beyondstorage/go-storage/v4/services"). + AddDot("github.com/beyondstorage/go-storage/v4/types") + + f.NewVar(). + AddDecl("_", "Storager"). + AddDecl("_", "services.ServiceError"). + AddDecl("_", "httpclient.Options"). + AddDecl("_", "time.Duration"). + AddDecl("_", "http.Request"). + AddDecl("_", "Error") + + f.AddLineComment("Type is the type for %s", data.Name) + f.NewConst().AddField("Type", gg.Lit(data.Name).String()) + + // Generate object system metadata. + f.AddLineComment("ObjectSystemMetadata stores system metadata for object.") + osm := f.NewStruct("ObjectSystemMetadata") + for _, info := range data.Infos { + if info.Scope != "object" { + continue + } + if info.Global { + continue + } + pname := templateutils.ToPascal(info.Name) + if info.DisplayName() != "" { + pname = info.DisplayName() + } + // FIXME: we will support comment on field later. + osm.AddField(pname, info.Type()) + } + + f.AddLineComment(` +GetObjectSystemMetadata will get ObjectSystemMetadata from Object. + +- This function should not be called by service implementer. +- The returning ObjectServiceMetadata is read only and should not be modified. +`) + + gosmfn := f.NewFunction("GetObjectSystemMetadata") + gosmfn.AddParameter("o", "*Object"). + AddResult("", "ObjectSystemMetadata") + gosmfn.AddBody( + gg.S("sm, ok := o.GetSystemMetadata()"), + gg.If(gg.S("ok")). + AddBody(gg.Return("sm.(ObjectSystemMetadata)")), + gg.Return(gg.Value("ObjectSystemMetadata")), + ) + + f.AddLineComment(` +setObjectSystemMetadata will set ObjectSystemMetadata into Object. + +- This function should only be called once, please make sure all data has been written before set. +`) + + sosmfn := f.NewFunction("setObjectSystemMetadata") + sosmfn.AddParameter("o", "*Object"). + AddParameter("sm", "ObjectSystemMetadata") + sosmfn.AddBody( + gg.S("o.SetSystemMetadata(sm)"), + ) + + // Generate storage system metadata. + f.AddLineComment("StorageSystemMetadata stores system metadata for object.") + ssm := f.NewStruct("StorageSystemMetadata") + for _, info := range data.Infos { + if info.Scope != "object" { + continue + } + if info.Global { + continue + } + pname := templateutils.ToPascal(info.Name) + if info.DisplayName() != "" { + pname = info.DisplayName() + } + // FIXME: we will support comment on field later. + ssm.AddField(pname, info.Type()) + } + + f.AddLineComment(` +GetStorageSystemMetadata will get StorageSystemMetadata from Storage. + +- This function should not be called by service implementer. +- The returning StorageServiceMetadata is read only and should not be modified. +`) + + gssmfn := f.NewFunction("GetStorageSystemMetadata") + gssmfn.AddParameter("s", "*StorageMeta"). + AddResult("", "StorageSystemMetadata") + gssmfn.AddBody( + gg.S("sm, ok := s.GetSystemMetadata()"), + gg.If(gg.S("ok")). + AddBody(gg.Return("sm.(StorageSystemMetadata)")), + gg.Return(gg.Value("StorageSystemMetadata")), + ) + + f.AddLineComment(`setStorageSystemMetadata will set StorageSystemMetadata into Storage. + +- This function should only be called once, please make sure all data has been written before set.`) + sssmfn := f.NewFunction("setStorageSystemMetadata") + sssmfn.AddParameter("s", "*StorageMeta"). + AddParameter("sm", "StorageSystemMetadata") + sssmfn.AddBody( + gg.S("s.SetSystemMetadata(sm)"), + ) + + // Generate service pairs. + for _, pair := range data.Pairs() { + // We don't need to generate global pairs here. + if pair.Global { + continue + } + + pname := templateutils.ToPascal(pair.Name) + + f.AddLineComment(`With%s will apply %s value to Options. + +%s`, pname, pair.Name, pair.Description) + fn := f.NewFunction("With" + pname) + + // Set to true as default. + value := "true" + // bool type pairs don't need input. + if pair.Type() != "bool" { + fn.AddParameter("v", pair.Type()) + value = "v" + } + fn.AddResult("", "Pair") + fn.AddBody(gg.Return( + gg.Value("Pair"). + AddField("Key", gg.Lit(pair.Name)). + AddField("Value", value))) + } + + // Generate pair map + f.NewVar().AddField("pairMap", gg.Embed(func() gg.Node { + i := gg.Value("map[string]string") + for _, pair := range data.Pairs() { + i.AddField(gg.Lit(pair.Name), gg.Lit(pair.Type())) + } + return i + })) + + // Generate every namespace. + for _, ns := range data.Namespaces { + nsNameP := templateutils.ToPascal(ns.Name) + + // Generate interface assert. + inters := f.NewVar() + for _, inter := range ns.Interfaces { + interNameP := templateutils.ToPascal(inter.Name) + inters.AddTypedField( + "_", interNameP, gg.S("&%s{}", nsNameP)) + } + + // Generate feature struct. + features := f.NewStruct(nsNameP + "Features") + for _, fs := range ns.Features { + features.AddLineComment(fs.Description) + features.AddField(templateutils.ToPascal(fs.Name), "bool") + } + + // Generate pair new. + fnNewNameP := templateutils.ToPascal(ns.New.Name) + partStructName := fmt.Sprintf("pair%s%s", nsNameP, fnNewNameP) + f.AddLineComment("%s is the parsed struct", partStructName) + pairStruct := f.NewStruct(partStructName). + AddField("pairs", "[]Pair"). + AddLine() + + // Generate required pairs. + pairStruct.AddLineComment("Required pairs") + for _, pair := range ns.New.Required { + pairNameP := templateutils.ToPascal(pair.Name) + pairStruct.AddField("Has"+pairNameP, "bool") + pairStruct.AddField(pairNameP, pair.Type()) + } + + // Generate optional pairs. + pairStruct.AddLineComment("Optional pairs") + for _, pair := range ns.New.Optional { + pairNameP := templateutils.ToPascal(pair.Name) + pairStruct.AddField("Has"+pairNameP, "bool") + pairStruct.AddField(pairNameP, pair.Type()) + } + + // Generate feature handle logic. + pairStruct.AddLineComment("Enable features") + for _, feature := range ns.Features { + featureNameP := templateutils.ToPascal(feature.Name) + pairStruct.AddField("hasEnable"+featureNameP, "bool") + pairStruct.AddField("Enable"+featureNameP, "bool") + } + + // Generate default pairs. + pairStruct.AddLineComment("Default pairs") + for _, dp := range ns.Defaultable() { + dpNameP := templateutils.ToPascal(dp.Pair.Name) + pairStruct.AddField("hasDefault"+dpNameP, "bool") + pairStruct.AddField("Default"+dpNameP, dp.Pair.Type()) + } + + // Generate parse newPair. + pairParseName := fmt.Sprintf("parsePair%s%s", nsNameP, fnNewNameP) + f.AddLineComment("%s will parse Pair slice into *%s", pairParseName, partStructName) + pairParse := f.NewFunction(pairParseName). + AddParameter("opts", "[]Pair"). + AddResult("", partStructName). + AddResult("", "error") + pairParse.AddBody( + gg.S("result :="), + gg.Value(partStructName).AddField("pairs", "opts"), + gg.Line(), + gg.For(gg.S("_, v := range opts")). + AddBody(gg.Embed(func() gg.Node { + is := gg.Switch(gg.S("v.Key")) + + for _, pair := range ns.New.Required { + pairNameP := templateutils.ToPascal(pair.Name) + is.NewCase(gg.Lit(pair.Name)).AddBody( + gg.If(gg.S("result.Has%s", pairNameP)). + AddBody(gg.Continue()), + gg.S("result.Has%s = true", pairNameP), + gg.S("result.%s = v.Value.(%s)", pairNameP, pair.Type()), + ) + } + for _, pair := range ns.New.Optional { + pairNameP := templateutils.ToPascal(pair.Name) + is.NewCase(gg.Lit(pair.Name)).AddBody( + gg.If(gg.S("result.Has%s", pairNameP)). + AddBody(gg.Continue()), + gg.S("result.Has%s = true", pairNameP), + gg.S("result.%s = v.Value.(%s)", pairNameP, pair.Type()), + ) + } + for _, feature := range ns.Features { + featureNameP := templateutils.ToPascal(feature.Name) + is.NewCase(gg.Lit("enable_"+feature.Name)).AddBody( + gg.If(gg.S("result.hasEnable%s", featureNameP)). + AddBody(gg.Continue()), + gg.S("result.hasEnable%s = true", featureNameP), + gg.S("result.Enable%s = true", featureNameP), + ) + } + for _, dp := range ns.Defaultable() { + dpNameP := templateutils.ToPascal(dp.Pair.Name) + is.NewCase(gg.Lit("default_"+dp.Pair.Name)).AddBody( + gg.If(gg.S("result.hasDefault%s", dpNameP)). + AddBody(gg.Continue()), + gg.S("result.hasDefault%s = true", dpNameP), + gg.S("result.Default%s = v.Value.(%s)", dpNameP, dp.Pair.Type()), + ) + } + return is + })), + gg.LineComment("Enable features"), + gg.Embed(func() gg.Node { + // Generate features enable here. + group := gg.NewGroup() + for _, feature := range ns.Features { + featureNameP := templateutils.ToPascal(feature.Name) + + gg.If(gg.S("result.hasEnable%s", featureNameP)). + AddBody( + gg.S("result.Has%sFeatures = true", nsNameP), + gg.S("result.%sFeatures.%s = true", nsNameP, featureNameP), + ) + } + return group + }), + gg.Embed(func() gg.Node { + // Generate default pari handle logic here. + group := gg.NewGroup() + for _, dp := range ns.Defaultable() { + pairNameP := templateutils.ToPascal(dp.Pair.Name) + + xif := group. + NewIf(gg.S("result.hasDefault%s", pairNameP)). + AddBody(gg.S("result.HasDefault%sPairs = true", nsNameP)) + for _, op := range dp.Funcs { + opN := templateutils.ToPascal(op) + + xif.AddBody(gg.S( + "result.Default%sPairs.%s = append(result.Default%sPairs.%s, With%s(result.Default%s))", + nsNameP, opN, nsNameP, opN, pairNameP, pairNameP)) + } + } + return group + }), + gg.Embed(func() gg.Node { + // Generate required validate logic here. + group := gg.NewGroup() + + for _, pair := range ns.New.Required { + pairNameP := templateutils.ToPascal(pair.Name) + group.NewIf(gg.S("!result.Has%s", pairNameP)). + AddBody(gg.S( + `return pair%s%s{}, services.PairRequiredError{ Keys:[]string{ "%s" } }`, + nsNameP, fnNewNameP, pair.Name)) + } + return group + }), + gg.Return("result", "nil"), + ) + + // Generate default pairs. + f.AddLineComment("Default%sPairs is default pairs for specific action", nsNameP) + dps := f.NewStruct(fmt.Sprintf("Default%sPairs", nsNameP)) + for _, fn := range ns.Funcs { + fnNameP := templateutils.ToPascal(fn.Name) + dps.AddField(fnNameP, "[]Pair") + } + + // Generate pair. + for _, fn := range ns.Funcs { + fnNameP := templateutils.ToPascal(fn.Name) + pairStructName := fmt.Sprintf("pair%s%s", nsNameP, fnNameP) + + // Generate pair struct + pairStruct := f.NewStruct(pairStructName). + AddField("pairs", "[]Pair") + + // Generate required pairs. + pairStruct.AddLineComment("Required pairs") + for _, pair := range fn.Required { + pairNameP := templateutils.ToPascal(pair.Name) + pairStruct.AddField("Has"+pairNameP, "bool") + pairStruct.AddField(pairNameP, pair.Type()) + } + + // Generate optional pairs. + pairStruct.AddLineComment("Optional pairs") + for _, pair := range fn.Optional { + pairNameP := templateutils.ToPascal(pair.Name) + pairStruct.AddField("Has"+pairNameP, "bool") + pairStruct.AddField(pairNameP, pair.Type()) + } + + pairParseName := fmt.Sprintf("parsePair%s%s", nsNameP, fnNameP) + pairParse := f.NewFunction(pairParseName). + WithReceiver("s", "*"+nsNameP). + AddParameter("opts", "[]Pair"). + AddResult("", pairStructName). + AddResult("", "error") + pairParse.AddBody( + gg.S("result :="), + gg.Value(pairStructName).AddField("pairs", "opts"), + gg.Line(), + gg.For(gg.S("_, v := range opts")). + AddBody(gg.Embed(func() gg.Node { + is := gg.Switch(gg.S("v.Key")) + + for _, pair := range fn.Required { + pairNameP := templateutils.ToPascal(pair.Name) + is.NewCase(gg.Lit(pair.Name)).AddBody( + gg.If(gg.S("result.Has%s", pairNameP)). + AddBody(gg.Continue()), + gg.S("result.Has%s = true", pairNameP), + gg.S("result.%s = v.Value.(%s)", pairNameP, pair.Type()), + ) + } + for _, pair := range fn.Optional { + pairNameP := templateutils.ToPascal(pair.Name) + is.NewCase(gg.Lit(pair.Name)).AddBody( + gg.If(gg.S("result.Has%s", pairNameP)). + AddBody(gg.Continue()), + gg.S("result.Has%s = true", pairNameP), + gg.S("result.%s = v.Value.(%s)", pairNameP, pair.Type()), + ) + } + dcas := is.NewDefault() + if ns.HasFeatureLoosePair { + dcas.AddBody( + gg.LineComment(` +loose_pair feature introduced in GSP-109. +If user enable this feature, service should ignore not support pair error.`), + gg.If(gg.S("s.features.LoosePair")). + AddBody(gg.Continue()), + ) + } + dcas.AddBody(gg.S("return pair%s%s{}, services.PairUnsupportedError{Pair:v}", nsNameP, fnNameP)) + return is + })), + + gg.Embed(func() gg.Node { + // Generate required validate logic here. + group := gg.NewGroup() + + for _, pair := range fn.Required { + pairNameP := templateutils.ToPascal(pair.Name) + group.NewIf(gg.S("!result.Has%s", pairNameP)). + AddBody(gg.S( + `return pair%s%s{}, services.PairRequiredError{ Keys:[]string{ "%s" } }`, + nsNameP, fnNameP, pair.Name)) + } + return group + }), + gg.Return("result", "nil"), + ) + } + + // Generate public functions. + for _, fn := range ns.Funcs { + fnNameP := templateutils.ToPascal(fn.Name) + if fn.Local { + // Generate a local function. + xfn := f.NewFunction(fnNameP).WithReceiver("s", "*"+nsNameP) + for _, field := range fn.Params { + xfn.AddParameter(field.Name, field.Type()) + } + for _, field := range fn.Results { + xfn.AddResult(field.Name, field.Type()) + } + xfn.AddBody( + gg.S("pairs = append(pairs, s.defaultPairs.%s...)", fnNameP), + gg.S("var opt pair%s%s", nsNameP, fnNameP), + gg.Line(), + gg.LineComment("Ignore error while handling local functions."), + gg.S("opt, _ = s.parsePair%s%s(pairs)", nsNameP, fnNameP), + gg.Return( + gg.Embed(func() gg.Node { + ic := gg.Call(templateutils.ToCamel(fn.Name)). + WithOwner("s") + for _, v := range fn.Params { + // We don't need to call pair again. + if v.Type() == "...Pair" { + continue + } + ic.AddParameter(v.Name) + } + ic.AddParameter("opt") + return ic + }))) + continue + } + // Generate a non-local function. + // TODO: generate comment here. + xfn := f.NewFunction(fnNameP). + WithReceiver("s", "*"+nsNameP) + for _, field := range fn.Params { + xfn.AddParameter(field.Name, field.Type()) + } + for _, field := range fn.Results { + xfn.AddResult(field.Name, field.Type()) + } + xfn.AddBody( + "ctx := context.Background()", + gg.Return( + gg.Embed(func() gg.Node { + ic := gg.Call(fnNameP + "WithContext"). + WithOwner("s") + ic.AddParameter("ctx") + for _, v := range fn.Params { + if v.Type() == "...Pair" { + ic.AddParameter("pairs...") + continue + } + ic.AddParameter(v.Name) + } + return ic + }))) + + xfn = f.NewFunction(fnNameP+"WithContext"). + WithReceiver("s", "*"+nsNameP) + xfn.AddParameter("ctx", "context.Context") + for _, field := range fn.Params { + xfn.AddParameter(field.Name, field.Type()) + } + for _, field := range fn.Results { + xfn.AddResult(field.Name, field.Type()) + } + xfn.AddBody( + gg.Defer(gg.Embed(func() gg.Node { + caller := gg.Call("formatError").WithOwner("s") + caller.AddParameter(gg.Lit(fn.Name)).AddParameter("err") + for _, v := range fn.Params { + // formatError only accept string as input. + if v.Type() != "string" { + continue + } + caller.AddParameter(v.Name) + } + + fn := gg.Function(""). + AddBody(gg.S("err = "), caller).WithCall() + return fn + })), + gg.Embed(func() gg.Node { + if fn.ObjectMode == "" { + return gg.Line() + } + mode := templateutils.ToPascal(fn.ObjectMode) + return gg.If(gg.S("!o.Mode.Is%s()", mode)).AddBody( + gg.S("err = services.ObjectModeInvalidError{Expected: Mode%s, Actual: o.Mode}", mode), + gg.Return(), + ) + }), + gg.S("pairs = append(pairs, s.defaultPairs.%s...)", fnNameP), + gg.S("var opt pair%s%s", nsNameP, fnNameP), + gg.Line(), + gg.S("opt, err = s.parsePair%s%s(pairs)", nsNameP, fnNameP), + gg.If(gg.S("err != nil")).AddBody(gg.Return()), + gg.Return( + gg.Embed(func() gg.Node { + ic := gg.Call(templateutils.ToCamel(fn.Name)). + WithOwner("s") + ic.AddParameter("ctx") + for _, v := range fn.Params { + // We don't need to call pair again. + if v.Type() == "...Pair" { + continue + } + ic.AddParameter(v.Name) + } + ic.AddParameter("opt") + return ic + }))) + } + } + + // Generate init function + initFn := f.NewFunction("init") + for _, ns := range data.Namespaces { + nsNameP := templateutils.ToPascal(ns.Name) + initFn.AddBody(gg.Call("Register" + nsNameP + "r"). + WithOwner("services"). + AddParameter("Type"). + AddParameter("New" + nsNameP + "r")) + } + initFn.AddBody("services.RegisterSchema(Type, pairMap)") + + err := f.WriteFile(path) + if err != nil { + log.Fatalf("generate to %s: %v", path, err) + } +} diff --git a/cmd/definitions/generate.go b/cmd/definitions/generate.go index 96bccf0a2..0042570d5 100644 --- a/cmd/definitions/generate.go +++ b/cmd/definitions/generate.go @@ -19,8 +19,6 @@ import ( "github.com/beyondstorage/go-storage/v4/cmd/definitions/bindata" ) -var serviceT = newTmpl("cmd/definitions/tmpl/service") - func generateGlobal(data *Data) { // Metas generate generateInfo(data, "types/info.generated.go") @@ -36,7 +34,7 @@ func generateGlobal(data *Data) { } func generateService(data *Data) { - generateT(serviceT, "generated.go", data.Service) + generateSrv(data.Service, "generated.go") for _, v := range data.Service.Namespaces { generateFunc(v, v.Name+".go") formatService(v.Name + ".go") diff --git a/cmd/definitions/tmpl/service.tmpl b/cmd/definitions/tmpl/service.tmpl deleted file mode 100644 index c38bab09a..000000000 --- a/cmd/definitions/tmpl/service.tmpl +++ /dev/null @@ -1,436 +0,0 @@ -// Code generated by go generate via cmd/definitions; DO NOT EDIT. -package {{ .Name }} - -import ( - "context" - "io" - "net/http" - "time" - - . "github.com/beyondstorage/go-storage/v4/pairs" - "github.com/beyondstorage/go-storage/v4/pkg/httpclient" - "github.com/beyondstorage/go-storage/v4/services" - . "github.com/beyondstorage/go-storage/v4/types" -) - -var _ Storager -var _ services.ServiceError -var _ httpclient.Options -var _ time.Duration -var _ http.Request -var _ Error - -// Type is the type for {{ .Name }} -const Type = "{{ .Name }}" - -// ObjectSystemMetadata stores system metadata for object. -type ObjectSystemMetadata struct { -{{- range $_, $v := .Infos }} - {{- if eq $v.Scope "object" }} - {{- if not $v.Global }} - {{- $pname := $v.Name | toPascal }} - {{- if $v.DisplayName }} - {{- $pname = $v.DisplayName }} - {{- end }} - {{ $v.Description }} - {{ $pname }} {{ $v.Type }} - {{- end }} - {{- end }} -{{- end }} -} - -// GetObjectSystemMetadata will get ObjectSystemMetadata from Object. -// -// - This function should not be called by service implementer. -// - The returning ObjectServiceMetadata is read only and should not be modified. -func GetObjectSystemMetadata(o *Object) ObjectSystemMetadata { - sm, ok := o.GetSystemMetadata() - if ok { - return sm.(ObjectSystemMetadata) - } - return ObjectSystemMetadata{} -} - -// setObjectSystemMetadata will set ObjectSystemMetadata into Object. -// -// - This function should only be called once, please make sure all data has been written before set. -func setObjectSystemMetadata(o *Object, sm ObjectSystemMetadata) { - o.SetSystemMetadata(sm) -} - -// StorageSystemMetadata stores system metadata for storage meta. -type StorageSystemMetadata struct { -{{- range $_, $v := .Infos }} - {{- if eq $v.Scope "storage" }} - {{- if not $v.Global }} - {{- $pname := $v.Name | toPascal }} - {{- if $v.DisplayName }} - {{- $pname = $v.DisplayName }} - {{- end }} - {{ $v.Description }} - {{ $pname }} {{ $v.Type }} - {{- end }} - {{- end }} -{{- end }} -} - -// GetStorageSystemMetadata will get SystemMetadata from StorageMeta. -// -// - The returning StorageSystemMetadata is read only and should not be modified. -func GetStorageSystemMetadata(s *StorageMeta) StorageSystemMetadata { - sm, ok := s.GetSystemMetadata() - if ok { - return sm.(StorageSystemMetadata) - } - return StorageSystemMetadata{} -} - -// setStorageSystemMetadata will set SystemMetadata into StorageMeta. -// -// - This function should only be called once, please make sure all data has been written before set. -func setStorageSystemMetadata(s *StorageMeta, sm StorageSystemMetadata) { - s.SetSystemMetadata(sm) -} - -{{- range $_, $v := .Pairs }} -{{- if not $v.Global }} -{{- $pname := $v.Name | toPascal }} -// With{{ $pname }} will apply {{ $v.Name }} value to Options. -// -{{ $v.Description }} -{{- if eq $v.Type "bool" }} -func With{{ $pname }}() Pair { - return Pair{ - Key: "{{ $v.Name }}", - Value: true, - } -} -{{- else }} -func With{{ $pname }}(v {{ $v.Type }}) Pair { - return Pair{ - Key: "{{ $v.Name }}", - Value: v, - } -} -{{- end }} -{{- end }} -{{- end }} - -var pairMap = map[string]string { - {{- range $_, $v := .Pairs }} - {{- $pname := $v.Name | toPascal }} - "{{ $v.Name }}": "{{ $v.Type }}", - {{- end }} -} - -{{- range $_, $v := .Namespaces }} - {{- template "interfaces" makeSlice $v.Name $v.Interfaces }} - {{- template "features" makeSlice $v.Name $v.Funcs $v.Features }} - {{- template "pair_new" makeSlice ( $v.Name | toPascal ) $v.New $v.Features $v.Defaultable }} - {{- template "pairs" makeSlice $v $v.Funcs }} - {{- template "functions" makeSlice $v.Name $v.Funcs }} -{{- end }} - -{{- define "interfaces" }} -{{- $pn := index . 0 }} -{{- $inters := index . 1 }} -var ( - {{- range $_, $v := $inters }} - _ {{ $v.Name | toPascal }} = &{{ $pn | toPascal }}{} - {{- end }} -) -{{- end }} - -{{- define "features" }} -{{- $pn := index . 0 | toPascal }} -{{- $fns := index . 1 }} -{{- $fs := index . 2 }} - -type {{ $pn }}Features struct { - {{- range $_, $v := $fs }} - {{ $v.Description }} - {{ $v.Name | toPascal }} bool - {{- end }} -} -{{- end }} - -{{- define "pair_new" }} -{{- $pn := index . 0 }} -{{- $fn := index . 1 }} -{{- $ff := index . 2 }} -{{- $dp := index . 3 }} - -{{- $fnk := $fn.Name | toPascal }} - -// pair{{ $pn }}{{ $fnk }} is the parsed struct -type pair{{ $pn }}{{$fnk}} struct { - pairs []Pair - - // Required pairs - {{- range $_, $pair := $fn.Required }} - Has{{ $pair.Name | toPascal }} bool - {{ $pair.Name | toPascal }} {{ $pair.Type }} - {{- end }} - // Optional pairs - {{- range $_, $pair := $fn.Optional }} - Has{{ $pair.Name | toPascal }} bool - {{ $pair.Name | toPascal }} {{ $pair.Type }} - {{- end }} - // Enable features - {{- range $_, $pair := $ff }} - hasEnable{{ $pair.Name | toPascal }} bool - Enable{{ $pair.Name | toPascal }} bool - {{- end }} - // Default pairs - {{- range $_, $pf := $dp }} - hasDefault{{ $pf.Pair.Name | toPascal }} bool - Default{{ $pf.Pair.Name | toPascal }} {{ $pf.Pair.Type }} - {{- end }} -} - -// parsePair{{ $pn }}{{ $fnk }} will parse Pair slice into *pair{{ $pn }}{{ $fnk }} -func parsePair{{ $pn }}{{ $fnk }}(opts []Pair) (pair{{ $pn }}{{ $fnk }}, error) { - result := pair{{ $pn }}{{ $fnk }}{ - pairs: opts, - } - - for _, v := range opts { - switch v.Key { - // Required pairs - {{- range $_, $pair := $fn.Required }} - case "{{ $pair.Name }}": - if result.Has{{ $pair.Name | toPascal }} { - continue - } - result.Has{{ $pair.Name | toPascal }} = true - result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }}) - {{- end }} - // Optional pairs - {{- range $_, $pair := $fn.Optional }} - case "{{ $pair.Name }}": - if result.Has{{ $pair.Name | toPascal }} { - continue - } - result.Has{{ $pair.Name | toPascal }} = true - result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }}) - {{- end }} - // Enable features - {{- range $_, $pair := $ff }} - case "enable_{{ $pair.Name }}": - if result.hasEnable{{ $pair.Name | toPascal }} { - continue - } - result.hasEnable{{ $pair.Name | toPascal }} = true - result.Enable{{ $pair.Name | toPascal }} = true - {{- end }} - // Default pairs - {{- range $_, $pf := $dp }} - case "default_{{ $pf.Pair.Name }}": - if result.hasDefault{{ $pf.Pair.Name | toPascal }} { - continue - } - result.hasDefault{{ $pf.Pair.Name | toPascal }} = true - result.Default{{ $pf.Pair.Name | toPascal }} = v.Value.({{ $pf.Pair.Type }}) - {{- end }} - } - } - - // Enable features - {{- range $_, $pair := $ff }} - if result.hasEnable{{ $pair.Name | toPascal }} { - result.Has{{ $pn }}Features = true - result.{{ $pn }}Features.{{ $pair.Name | toPascal }} = true - } - {{- end }} - - // Default pairs - {{- range $_, $pf := $dp }} - if result.hasDefault{{ $pf.Pair.Name | toPascal }} { - result.HasDefault{{ $pn }}Pairs = true - {{- range $_, $op := $pf.Funcs }} - result.Default{{ $pn }}Pairs.{{ $op | toPascal }} = append(result.Default{{ $pn }}Pairs.{{ $op | toPascal }}, With{{ $pf.Pair.Name | toPascal }}(result.Default{{ $pf.Pair.Name | toPascal }})) - {{- end }} - } - {{- end }} - - {{ range $_, $pair := $fn.Required }} - if !result.Has{{ $pair.Name | toPascal }} { - return pair{{ $pn }}{{ $fnk }}{}, services.PairRequiredError{ Keys:[]string{ "{{ $pair.Name }}" } } - } - {{- end }} - - return result, nil -} -{{- end }} - -{{- define "pairs" }} -{{- $pn := index . 0 }} -{{- $data := index . 1 }} - -{{- $pnk := $pn.Name | toPascal }} - -// Default{{ $pnk }}Pairs is default pairs for specific action -type Default{{ $pnk }}Pairs struct { -{{- range $_, $v := $data }} - {{ $v.Name | toPascal }} []Pair -{{- end }} -} - - {{- range $_, $v := $data }} - {{- template "pair" makeSlice $pn $v}} - {{- end }} -{{- end }} - -{{- define "pair" }} -{{- $pn := index . 0 }} -{{- $fn := index . 1 }} - -{{- $pnk := $pn.Name | toPascal }} -{{- $fnk := $fn.Name | toPascal }} - -// pair{{ $pnk }}{{ $fnk }} is the parsed struct -type pair{{ $pnk }}{{ $fnk }} struct { - pairs []Pair - - {{- range $_, $pair := $fn.Required }} - Has{{ $pair.Name | toPascal }} bool - {{ $pair.Name | toPascal }} {{ $pair.Type }} - {{- end }} - {{- range $_, $pair := $fn.Optional }} - Has{{ $pair.Name | toPascal }} bool - {{ $pair.Name | toPascal }} {{ $pair.Type }} - {{- end }} -} - -// parsePair{{ $pnk }}{{ $fnk }} will parse Pair slice into *pair{{ $pnk }}{{ $fnk }} -func (s *{{ $pnk }})parsePair{{ $pnk }}{{ $fnk }}(opts []Pair) (pair{{ $pnk }}{{ $fnk }}, error) { - result := pair{{ $pnk }}{{ $fnk }}{ - pairs: opts, - } - - for _, v := range opts { - switch v.Key { - {{- range $_, $pair := $fn.Required }} - case "{{ $pair.Name }}": - if result.Has{{ $pair.Name | toPascal }} { - continue - } - result.Has{{ $pair.Name | toPascal }} = true - result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }}) - continue - {{- end }} - {{- range $_, $pair := $fn.Optional }} - case "{{ $pair.Name }}": - if result.Has{{ $pair.Name | toPascal }} { - continue - } - result.Has{{ $pair.Name | toPascal }} = true - result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }}) - continue - {{- end }} - default: - {{- if $pn.HasFeatureLoosePair }} - // loose_pair feature introduced in GSP-109. - // If user enable this feature, service should ignore not support pair error. - if s.features.LoosePair { - continue - } - {{- end }} - return pair{{ $pnk }}{{ $fnk }}{}, services.PairUnsupportedError{Pair:v} - } - } - - // Check required pairs. - {{- range $_, $pair := $fn.Required }} - if !result.Has{{ $pair.Name | toPascal }} { - return pair{{ $pnk }}{{ $fnk }}{}, services.PairRequiredError{ Keys:[]string{ "{{ $pair.Name }}" } } - } - {{- end }} - - return result, nil -} -{{- end }} - -{{- define "functions" }} - {{- $pn := index . 0 | toPascal }} - {{- $data := index . 1 }} - - {{- range $_, $v := $data }} - {{- if $v.Local }} - {{- template "local_function" makeSlice $pn $v}} - {{- else }} - {{- template "function" makeSlice $pn $v}} - {{- end }} - {{- end }} -{{- end }} - -{{- define "function" }} -{{- $pn := index . 0 }} -{{- $fn := index . 1 }} - -{{ $fnk := $fn.Name | toPascal }} - -// {{ $fnk }} {{ $fn.Description }} -// -// This function will create a context by default. -func (s *{{$pn}}) {{ $fnk }}({{$fn.Params.String}}) ({{$fn.Results.String}}) { - ctx := context.Background() - return s.{{ $fnk }}WithContext(ctx, {{$fn.Params.Caller}}) -} - -// {{ $fnk }}WithContext {{ $fn.Description }} -func (s *{{$pn}}) {{ $fnk }}WithContext(ctx context.Context, {{$fn.Params.String}}) ({{$fn.Results.String}}) { - defer func(){ - {{- $path := $fn.Params.PathCaller }} - {{- if and (eq $path "") (eq $pn "Service") }} - {{ $path = ",\"\"" }} - {{- end }} - err = s.formatError("{{$fn.Name}}", err {{ $path }} ) - }() - - {{- if ne $fn.ObjectMode "" }} - {{- $mode := $fn.ObjectMode | toPascal }} - if !o.Mode.Is{{ $mode }}() { - err = services.ObjectModeInvalidError{Expected: Mode{{ $mode }}, Actual: o.Mode} - return - } - {{- end }} - - pairs = append(pairs, s.defaultPairs.{{ $fnk }}...) - var opt pair{{ $pn }}{{ $fnk }} - - opt, err = s.parsePair{{ $pn }}{{ $fnk }}(pairs) - if err != nil { - return - } - - return s.{{ $fn.Name | toCamel }}(ctx, {{$fn.Params.TrimLast.CallerEndswithComma}} opt) -} -{{- end }} - -{{- define "local_function" }} - {{- $pn := index . 0 }} - {{- $fn := index . 1 }} - - {{ $fnk := $fn.Name | toPascal }} - - // {{ $fnk }} {{ $fn.Description }} - // - // This function will create a context by default. - func (s *{{$pn}}) {{ $fnk }}({{$fn.Params.String}}) ({{$fn.Results.String}}) { - pairs = append(pairs, s.defaultPairs.{{ $fnk }}...) - var opt pair{{ $pn }}{{ $fnk }} - - // Ignore error while handling local funtions. - opt, _ = s.parsePair{{ $pn }}{{ $fnk }}(pairs) - - return s.{{ $fn.Name | toCamel }}({{$fn.Params.TrimLast.CallerEndswithComma}} opt) - } -{{- end }} - -func init() { - {{- range $_, $v := .Namespaces }} - services.Register{{ $v.Name | toPascal }}r(Type, New{{ $v.Name | toPascal }}r) - {{- end }} - services.RegisterSchema(Type, pairMap) -} diff --git a/cmd/definitions/type.go b/cmd/definitions/type.go index e31ff900e..b26b220c3 100644 --- a/cmd/definitions/type.go +++ b/cmd/definitions/type.go @@ -139,15 +139,14 @@ type Feature struct { func (f *Feature) Format(s specs.Feature) { f.Name = s.Name - f.Description = formatDescription(templateutils.ToPascal(f.Name), s.Description) + f.Description = s.Description } // Pair is the pair definition. type Pair struct { Name string - ptype string - originalDescription string + ptype string Defaultable bool @@ -166,9 +165,7 @@ func (p *Pair) Format(s specs.Pair, global bool) { p.ptype = s.Type p.Global = global p.Defaultable = s.Defaultable - - p.originalDescription = s.Description - p.Description = formatDescription(templateutils.ToPascal(p.Name), s.Description) + p.Description = s.Description } // Info is the metadata definition. @@ -179,8 +176,6 @@ type Info struct { Export bool Description string - originalDescription string - itype string Global bool @@ -193,9 +188,8 @@ func (i *Info) Format(s specs.Info, global bool) { i.Name = s.Name i.itype = s.Type i.Export = s.Export - i.Description = formatDescription(templateutils.ToPascal(s.Name), s.Description) + i.Description = s.Description - i.originalDescription = s.Description i.Global = global } @@ -216,19 +210,17 @@ func (i *Info) DisplayName() string { // Interface represents an interface type Interface struct { - Name string - Description string - originalDescription string - Ops map[string]*Operation + Name string + Description string + Ops map[string]*Operation } // NewInterface will create a new interface from spec. func NewInterface(in specs.Interface, fields map[string]*Field) *Interface { inter := &Interface{ - Name: in.Name, - originalDescription: in.Description, - Description: formatDescription(templateutils.ToPascal(in.Name), in.Description), - Ops: make(map[string]*Operation), + Name: in.Name, + Description: in.Description, + Ops: make(map[string]*Operation), } for _, v := range in.Ops { // Update op maps @@ -259,24 +251,22 @@ func (i *Interface) DisplayName() string { // Operation represents an operation. type Operation struct { - Name string - originalDescription string - Description string - Pairs []string - Params Fields - Results Fields - ObjectMode string - Local bool + Name string + Description string + Pairs []string + Params Fields + Results Fields + ObjectMode string + Local bool } // NewOperation will create an new operation from operation spec. func NewOperation(v specs.Operation, fields map[string]*Field) *Operation { op := &Operation{ - Name: v.Name, - Local: v.Local, - ObjectMode: v.ObjectMode, - originalDescription: v.Description, - Description: formatDescription("", v.Description), + Name: v.Name, + Local: v.Local, + ObjectMode: v.ObjectMode, + Description: v.Description, } for _, f := range v.Params { op.Params = append(op.Params, fields[f]) @@ -359,47 +349,6 @@ func (f Fields) String() string { return strings.Join(x, ",") } -// Caller will print caller foramt. -func (f Fields) Caller() string { - x := make([]string, 0) - for _, v := range f { - x = append(x, v.Caller()) - } - return strings.Join(x, ",") -} - -// CallerEndswithComma will print caller with comma aware. -func (f Fields) CallerEndswithComma() string { - content := f.Caller() - if content == "" { - return "" - } - return content + "," -} - -// TrimLast will trim the last fields. -func (f Fields) TrimLast() Fields { - return f[:len(f)-1] -} - -// PathCaller will print caller with path aware. -func (f Fields) PathCaller() string { - x := make([]string, 0) - for _, v := range f { - if v.ftype != "string" { - break - } - - x = append(x, v.Caller()) - } - - content := strings.Join(x, ",") - if content == "" { - return "" - } - return "," + content -} - // Field represent a field. type Field struct { Name string @@ -418,14 +367,6 @@ func (f *Field) Type() string { return f.ftype } -// Caller will print the caller formatGlobal of field. -func (f *Field) Caller() string { - if strings.HasPrefix(f.Type(), "...") { - return f.Name + "..." - } - return f.Name -} - // Format will create a new field. func (f *Field) Format(s specs.Field) { f.ftype = s.Type @@ -711,11 +652,3 @@ func mergeInfos(a, b []*Info) []*Info { return fn(a, b) } - -func formatDescription(name, desc string) string { - desc = strings.Trim(desc, "\n") - if name == "" { - return strings.ReplaceAll(desc, "\n", "\n// ") - } - return fmt.Sprintf("// %s %s", name, strings.ReplaceAll(desc, "\n", "\n// ")) -} diff --git a/doc.go b/doc.go index 7fbc49323..db0acfc65 100644 --- a/doc.go +++ b/doc.go @@ -32,6 +32,6 @@ The most common case to use a Storager service could be following: */ package storage -//go:generate go run github.com/kevinburke/go-bindata/go-bindata -nometadata -o ./cmd/definitions/bindata/bindata.go -pkg bindata -tags tools ./definitions ./cmd/definitions/tmpl +//go:generate go run github.com/kevinburke/go-bindata/go-bindata -nometadata -o ./cmd/definitions/bindata/bindata.go -pkg bindata -tags tools ./definitions //go:generate go run -tags tools ./cmd/definitions //go:generate go run -tags tools ./internal/cmd/iterator diff --git a/go.mod b/go.mod index 4786a2d79..b08169b1d 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,7 @@ module github.com/beyondstorage/go-storage/v4 go 1.15 require ( - github.com/Xuanwo/gg v0.0.2-0.20210903091849-3af6d4d4e878 + github.com/Xuanwo/gg v0.1.0 github.com/Xuanwo/templateutils v0.1.0 github.com/dave/dst v0.26.2 github.com/golang/mock v1.6.0 diff --git a/go.sum b/go.sum index 16a1b1804..ca473e70d 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,5 @@ -github.com/Xuanwo/gg v0.0.2-0.20210903091849-3af6d4d4e878 h1:PVsU9SYgGUO1/0Oz8ETuyUDPTPkjPiOLXlzOCU72q7A= -github.com/Xuanwo/gg v0.0.2-0.20210903091849-3af6d4d4e878/go.mod h1:TjGrC5F6B9H//RFhXGxv/znfrz0uRq46gZdZ0f0bvVQ= +github.com/Xuanwo/gg v0.1.0 h1:VGP9kLM71YCZUU73YN9XVQjd1K4hO6Ka3pR6r4zjYOg= +github.com/Xuanwo/gg v0.1.0/go.mod h1:0fLiiSxR87u2UA0ZNZiKZXuz3jnJdbDHWtU2xpdcH3s= github.com/Xuanwo/go-bufferpool v0.2.0 h1:DXzqJD9lJufXbT/03GrcEvYOs4gXYUj9/g5yi6Q9rUw= github.com/Xuanwo/go-bufferpool v0.2.0/go.mod h1:Mle++9GGouhOwGj52i9PJLNAPmW2nb8PWBP7JJzNCzk= github.com/Xuanwo/templateutils v0.1.0 h1:WpkWOqQtIQ2vAIpJLa727DdN8WtxhUkkbDGa6UhntJY= diff --git a/tests/generated.go b/tests/generated.go index 41e2ecb1e..f556a4ed2 100644 --- a/tests/generated.go +++ b/tests/generated.go @@ -13,19 +13,20 @@ import ( . "github.com/beyondstorage/go-storage/v4/types" ) -var _ Storager -var _ services.ServiceError -var _ httpclient.Options -var _ time.Duration -var _ http.Request -var _ Error +var ( + _ Storager + _ services.ServiceError + _ httpclient.Options + _ time.Duration + _ http.Request + _ Error +) // Type is the type for tests const Type = "tests" // ObjectSystemMetadata stores system metadata for object. type ObjectSystemMetadata struct { - // StorageClass is the storage class for this object StorageClass string } @@ -48,15 +49,15 @@ func setObjectSystemMetadata(o *Object, sm ObjectSystemMetadata) { o.SetSystemMetadata(sm) } -// StorageSystemMetadata stores system metadata for storage meta. +// StorageSystemMetadata stores system metadata for object. type StorageSystemMetadata struct { - // QueriesPerSecond tests storage system metadata - QueriesPerSecond int64 + StorageClass string } -// GetStorageSystemMetadata will get SystemMetadata from StorageMeta. +// GetStorageSystemMetadata will get StorageSystemMetadata from Storage. // -// - The returning StorageSystemMetadata is read only and should not be modified. +// - This function should not be called by service implementer. +// - The returning StorageServiceMetadata is read only and should not be modified. func GetStorageSystemMetadata(s *StorageMeta) StorageSystemMetadata { sm, ok := s.GetSystemMetadata() if ok { @@ -65,7 +66,7 @@ func GetStorageSystemMetadata(s *StorageMeta) StorageSystemMetadata { return StorageSystemMetadata{} } -// setStorageSystemMetadata will set SystemMetadata into StorageMeta. +// setStorageSystemMetadata will set StorageSystemMetadata into Storage. // // - This function should only be called once, please make sure all data has been written before set. func setStorageSystemMetadata(s *StorageMeta, sm StorageSystemMetadata) { @@ -74,148 +75,82 @@ func setStorageSystemMetadata(s *StorageMeta, sm StorageSystemMetadata) { // WithDefaultServicePairs will apply default_service_pairs value to Options. // -// DefaultServicePairs set default pairs for service actions +// set default pairs for service actions func WithDefaultServicePairs(v DefaultServicePairs) Pair { - return Pair{ - Key: "default_service_pairs", - Value: v, - } + return Pair{Key: "default_service_pairs", Value: v} } // WithDefaultStorageClass will apply default_storage_class value to Options. -// -// StorageClass func WithDefaultStorageClass(v string) Pair { - return Pair{ - Key: "default_storage_class", - Value: v, - } + return Pair{Key: "default_storage_class", Value: v} } // WithDefaultStoragePairs will apply default_storage_pairs value to Options. // -// DefaultStoragePairs set default pairs for storager actions +// set default pairs for storager actions func WithDefaultStoragePairs(v DefaultStoragePairs) Pair { - return Pair{ - Key: "default_storage_pairs", - Value: v, - } + return Pair{Key: "default_storage_pairs", Value: v} } // WithDisableURICleaning will apply disable_uri_cleaning value to Options. -// -// DisableURICleaning func WithDisableURICleaning() Pair { - return Pair{ - Key: "disable_uri_cleaning", - Value: true, - } + return Pair{Key: "disable_uri_cleaning", Value: true} } // WithEnableLoosePair will apply enable_loose_pair value to Options. // -// LoosePair loose_pair feature is designed for users who don't want strict pair checks. +// loose_pair feature is designed for users who don't want strict pair checks. // // If this feature is enabled, the service will not return an error for not support pairs. // // This feature was introduced in GSP-109. func WithEnableLoosePair() Pair { - return Pair{ - Key: "enable_loose_pair", - Value: true, - } + return Pair{Key: "enable_loose_pair", Value: true} } // WithEnableVirtualDir will apply enable_virtual_dir value to Options. // -// VirtualDir virtual_dir feature is designed for a service that doesn't have native dir support but wants to provide simulated operations. +// virtual_dir feature is designed for a service that doesn't have native dir support but wants to +// provide simulated operations. // -// - If this feature is disabled (the default behavior), the service will behave like it doesn't have any dir support. -// - If this feature is enabled, the service will support simulated dir behavior in create_dir, create, list, delete, and so on. +// - If this feature is disabled (the default behavior), the service will behave like it doesn't have +// any dir support. +// - If this feature is enabled, the service will support simulated dir behavior in create_dir, create, +// list, delete, and so on. // // This feature was introduced in GSP-109. func WithEnableVirtualDir() Pair { - return Pair{ - Key: "enable_virtual_dir", - Value: true, - } + return Pair{Key: "enable_virtual_dir", Value: true} } // WithServiceFeatures will apply service_features value to Options. // -// ServiceFeatures set service features +// set service features func WithServiceFeatures(v ServiceFeatures) Pair { - return Pair{ - Key: "service_features", - Value: v, - } + return Pair{Key: "service_features", Value: v} } // WithStorageClass will apply storage_class value to Options. -// -// StorageClass func WithStorageClass(v string) Pair { - return Pair{ - Key: "storage_class", - Value: v, - } + return Pair{Key: "storage_class", Value: v} } // WithStorageFeatures will apply storage_features value to Options. // -// StorageFeatures set storage features +// set storage features func WithStorageFeatures(v StorageFeatures) Pair { - return Pair{ - Key: "storage_features", - Value: v, - } + return Pair{Key: "storage_features", Value: v} } // WithStringPair will apply string_pair value to Options. // -// StringPair tests connection string +// tests connection string func WithStringPair(v string) Pair { - return Pair{ - Key: "string_pair", - Value: v, - } + return Pair{Key: "string_pair", Value: v} } -var pairMap = map[string]string{ - "content_md5": "string", - "content_type": "string", - "context": "context.Context", - "continuation_token": "string", - "credential": "string", - "default_content_type": "string", - "default_io_callback": "func([]byte)", - "default_service_pairs": "DefaultServicePairs", - "default_storage_class": "string", - "default_storage_pairs": "DefaultStoragePairs", - "disable_uri_cleaning": "bool", - "enable_loose_pair": "bool", - "enable_virtual_dir": "bool", - "endpoint": "string", - "expire": "time.Duration", - "http_client_options": "*httpclient.Options", - "interceptor": "Interceptor", - "io_callback": "func([]byte)", - "list_mode": "ListMode", - "location": "string", - "multipart_id": "string", - "name": "string", - "object_mode": "ObjectMode", - "offset": "int64", - "service_features": "ServiceFeatures", - "size": "int64", - "storage_class": "string", - "storage_features": "StorageFeatures", - "string_pair": "string", - "work_dir": "string", -} -var ( - _ Servicer = &Service{} -) +var pairMap = map[string]string{"content_md5": "string", "content_type": "string", "context": "context.Context", "continuation_token": "string", "credential": "string", "default_content_type": "string", "default_io_callback": "func([]byte)", "default_service_pairs": "DefaultServicePairs", "default_storage_class": "string", "default_storage_pairs": "DefaultStoragePairs", "disable_uri_cleaning": "bool", "enable_loose_pair": "bool", "enable_virtual_dir": "bool", "endpoint": "string", "expire": "time.Duration", "http_client_options": "*httpclient.Options", "interceptor": "Interceptor", "io_callback": "func([]byte)", "list_mode": "ListMode", "location": "string", "multipart_id": "string", "name": "string", "object_mode": "ObjectMode", "offset": "int64", "service_features": "ServiceFeatures", "size": "int64", "storage_class": "string", "storage_features": "StorageFeatures", "string_pair": "string", "work_dir": "string"} +var _ Servicer = &Service{} type ServiceFeatures struct { } @@ -242,20 +177,17 @@ type pairServiceNew struct { // parsePairServiceNew will parse Pair slice into *pairServiceNew func parsePairServiceNew(opts []Pair) (pairServiceNew, error) { - result := pairServiceNew{ - pairs: opts, - } + result := + pairServiceNew{pairs: opts} for _, v := range opts { switch v.Key { - // Required pairs case "credential": if result.HasCredential { continue } result.HasCredential = true result.Credential = v.Value.(string) - // Optional pairs case "default_service_pairs": if result.HasDefaultServicePairs { continue @@ -280,19 +212,13 @@ func parsePairServiceNew(opts []Pair) (pairServiceNew, error) { } result.HasServiceFeatures = true result.ServiceFeatures = v.Value.(ServiceFeatures) - // Enable features - // Default pairs } } - // Enable features - // Default pairs - if !result.HasCredential { return pairServiceNew{}, services.PairRequiredError{Keys: []string{"credential"}} } - return result, nil } @@ -303,19 +229,17 @@ type DefaultServicePairs struct { Get []Pair List []Pair } - -// pairServiceCreate is the parsed struct type pairServiceCreate struct { - pairs []Pair + pairs []Pair + // Required pairs HasLocation bool Location string + // Optional pairs } -// parsePairServiceCreate will parse Pair slice into *pairServiceCreate func (s *Service) parsePairServiceCreate(opts []Pair) (pairServiceCreate, error) { - result := pairServiceCreate{ - pairs: opts, - } + result := + pairServiceCreate{pairs: opts} for _, v := range opts { switch v.Key { @@ -325,32 +249,27 @@ func (s *Service) parsePairServiceCreate(opts []Pair) (pairServiceCreate, error) } result.HasLocation = true result.Location = v.Value.(string) - continue default: return pairServiceCreate{}, services.PairUnsupportedError{Pair: v} } } - - // Check required pairs. if !result.HasLocation { return pairServiceCreate{}, services.PairRequiredError{Keys: []string{"location"}} } - return result, nil } -// pairServiceDelete is the parsed struct type pairServiceDelete struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasLocation bool Location string } -// parsePairServiceDelete will parse Pair slice into *pairServiceDelete func (s *Service) parsePairServiceDelete(opts []Pair) (pairServiceDelete, error) { - result := pairServiceDelete{ - pairs: opts, - } + result := + pairServiceDelete{pairs: opts} for _, v := range opts { switch v.Key { @@ -360,29 +279,25 @@ func (s *Service) parsePairServiceDelete(opts []Pair) (pairServiceDelete, error) } result.HasLocation = true result.Location = v.Value.(string) - continue default: return pairServiceDelete{}, services.PairUnsupportedError{Pair: v} } } - // Check required pairs. - return result, nil } -// pairServiceGet is the parsed struct type pairServiceGet struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasLocation bool Location string } -// parsePairServiceGet will parse Pair slice into *pairServiceGet func (s *Service) parsePairServiceGet(opts []Pair) (pairServiceGet, error) { - result := pairServiceGet{ - pairs: opts, - } + result := + pairServiceGet{pairs: opts} for _, v := range opts { switch v.Key { @@ -392,29 +307,25 @@ func (s *Service) parsePairServiceGet(opts []Pair) (pairServiceGet, error) { } result.HasLocation = true result.Location = v.Value.(string) - continue default: return pairServiceGet{}, services.PairUnsupportedError{Pair: v} } } - // Check required pairs. - return result, nil } -// pairServiceList is the parsed struct type pairServiceList struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasLocation bool Location string } -// parsePairServiceList will parse Pair slice into *pairServiceList func (s *Service) parsePairServiceList(opts []Pair) (pairServiceList, error) { - result := pairServiceList{ - pairs: opts, - } + result := + pairServiceList{pairs: opts} for _, v := range opts { switch v.Key { @@ -424,29 +335,21 @@ func (s *Service) parsePairServiceList(opts []Pair) (pairServiceList, error) { } result.HasLocation = true result.Location = v.Value.(string) - continue default: return pairServiceList{}, services.PairUnsupportedError{Pair: v} } } - // Check required pairs. - return result, nil } - -// Create will create a new storager instance. -// -// This function will create a context by default. func (s *Service) Create(name string, pairs ...Pair) (store Storager, err error) { ctx := context.Background() return s.CreateWithContext(ctx, name, pairs...) } - -// CreateWithContext will create a new storager instance. func (s *Service) CreateWithContext(ctx context.Context, name string, pairs ...Pair) (store Storager, err error) { defer func() { - err = s.formatError("create", err, name) + err = + s.formatError("create", err, name) }() pairs = append(pairs, s.defaultPairs.Create...) @@ -456,22 +359,16 @@ func (s *Service) CreateWithContext(ctx context.Context, name string, pairs ...P if err != nil { return } - return s.create(ctx, name, opt) } - -// Delete will delete a storager instance. -// -// This function will create a context by default. func (s *Service) Delete(name string, pairs ...Pair) (err error) { ctx := context.Background() return s.DeleteWithContext(ctx, name, pairs...) } - -// DeleteWithContext will delete a storager instance. func (s *Service) DeleteWithContext(ctx context.Context, name string, pairs ...Pair) (err error) { defer func() { - err = s.formatError("delete", err, name) + err = + s.formatError("delete", err, name) }() pairs = append(pairs, s.defaultPairs.Delete...) @@ -481,22 +378,16 @@ func (s *Service) DeleteWithContext(ctx context.Context, name string, pairs ...P if err != nil { return } - return s.delete(ctx, name, opt) } - -// Get will get a valid storager instance for service. -// -// This function will create a context by default. func (s *Service) Get(name string, pairs ...Pair) (store Storager, err error) { ctx := context.Background() return s.GetWithContext(ctx, name, pairs...) } - -// GetWithContext will get a valid storager instance for service. func (s *Service) GetWithContext(ctx context.Context, name string, pairs ...Pair) (store Storager, err error) { defer func() { - err = s.formatError("get", err, name) + err = + s.formatError("get", err, name) }() pairs = append(pairs, s.defaultPairs.Get...) @@ -506,23 +397,16 @@ func (s *Service) GetWithContext(ctx context.Context, name string, pairs ...Pair if err != nil { return } - return s.get(ctx, name, opt) } - -// List will list all storager instances under this service. -// -// This function will create a context by default. func (s *Service) List(pairs ...Pair) (sti *StoragerIterator, err error) { ctx := context.Background() return s.ListWithContext(ctx, pairs...) } - -// ListWithContext will list all storager instances under this service. func (s *Service) ListWithContext(ctx context.Context, pairs ...Pair) (sti *StoragerIterator, err error) { defer func() { - - err = s.formatError("list", err, "") + err = + s.formatError("list", err) }() pairs = append(pairs, s.defaultPairs.List...) @@ -532,7 +416,6 @@ func (s *Service) ListWithContext(ctx context.Context, pairs ...Pair) (sti *Stor if err != nil { return } - return s.list(ctx, opt) } @@ -546,17 +429,19 @@ var ( _ Storager = &Storage{} ) -type StorageFeatures struct { - // LoosePair loose_pair feature is designed for users who don't want strict pair checks. +type StorageFeatures struct { // loose_pair feature is designed for users who don't want strict pair checks. // // If this feature is enabled, the service will not return an error for not support pairs. // // This feature was introduced in GSP-109. LoosePair bool - // VirtualDir virtual_dir feature is designed for a service that doesn't have native dir support but wants to provide simulated operations. + // virtual_dir feature is designed for a service that doesn't have native dir support but wants to + // provide simulated operations. // - // - If this feature is disabled (the default behavior), the service will behave like it doesn't have any dir support. - // - If this feature is enabled, the service will support simulated dir behavior in create_dir, create, list, delete, and so on. + // - If this feature is disabled (the default behavior), the service will behave like it doesn't have + // any dir support. + // - If this feature is enabled, the service will support simulated dir behavior in create_dir, create, + // list, delete, and so on. // // This feature was introduced in GSP-109. VirtualDir bool @@ -598,20 +483,17 @@ type pairStorageNew struct { // parsePairStorageNew will parse Pair slice into *pairStorageNew func parsePairStorageNew(opts []Pair) (pairStorageNew, error) { - result := pairStorageNew{ - pairs: opts, - } + result := + pairStorageNew{pairs: opts} for _, v := range opts { switch v.Key { - // Required pairs case "name": if result.HasName { continue } result.HasName = true result.Name = v.Value.(string) - // Optional pairs case "default_storage_pairs": if result.HasDefaultStoragePairs { continue @@ -648,7 +530,6 @@ func parsePairStorageNew(opts []Pair) (pairStorageNew, error) { } result.HasWorkDir = true result.WorkDir = v.Value.(string) - // Enable features case "enable_loose_pair": if result.hasEnableLoosePair { continue @@ -661,7 +542,6 @@ func parsePairStorageNew(opts []Pair) (pairStorageNew, error) { } result.hasEnableVirtualDir = true result.EnableVirtualDir = true - // Default pairs case "default_content_type": if result.hasDefaultContentType { continue @@ -682,18 +562,8 @@ func parsePairStorageNew(opts []Pair) (pairStorageNew, error) { result.DefaultStorageClass = v.Value.(string) } } - // Enable features - if result.hasEnableLoosePair { - result.HasStorageFeatures = true - result.StorageFeatures.LoosePair = true - } - if result.hasEnableVirtualDir { - result.HasStorageFeatures = true - result.StorageFeatures.VirtualDir = true - } - // Default pairs if result.hasDefaultContentType { result.HasDefaultStoragePairs = true result.DefaultStoragePairs.Write = append(result.DefaultStoragePairs.Write, WithContentType(result.DefaultContentType)) @@ -707,11 +577,9 @@ func parsePairStorageNew(opts []Pair) (pairStorageNew, error) { result.HasDefaultStoragePairs = true result.DefaultStoragePairs.Write = append(result.DefaultStoragePairs.Write, WithStorageClass(result.DefaultStorageClass)) } - if !result.HasName { return pairStorageNew{}, services.PairRequiredError{Keys: []string{"name"}} } - return result, nil } @@ -736,17 +604,15 @@ type DefaultStoragePairs struct { WriteAppend []Pair WriteMultipart []Pair } - -// pairStorageCommitAppend is the parsed struct type pairStorageCommitAppend struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageCommitAppend will parse Pair slice into *pairStorageCommitAppend func (s *Storage) parsePairStorageCommitAppend(opts []Pair) (pairStorageCommitAppend, error) { - result := pairStorageCommitAppend{ - pairs: opts, - } + result := + pairStorageCommitAppend{pairs: opts} for _, v := range opts { switch v.Key { @@ -760,21 +626,18 @@ func (s *Storage) parsePairStorageCommitAppend(opts []Pair) (pairStorageCommitAp } } - // Check required pairs. - return result, nil } -// pairStorageCompleteMultipart is the parsed struct type pairStorageCompleteMultipart struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageCompleteMultipart will parse Pair slice into *pairStorageCompleteMultipart func (s *Storage) parsePairStorageCompleteMultipart(opts []Pair) (pairStorageCompleteMultipart, error) { - result := pairStorageCompleteMultipart{ - pairs: opts, - } + result := + pairStorageCompleteMultipart{pairs: opts} for _, v := range opts { switch v.Key { @@ -788,21 +651,18 @@ func (s *Storage) parsePairStorageCompleteMultipart(opts []Pair) (pairStorageCom } } - // Check required pairs. - return result, nil } -// pairStorageCopy is the parsed struct type pairStorageCopy struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageCopy will parse Pair slice into *pairStorageCopy func (s *Storage) parsePairStorageCopy(opts []Pair) (pairStorageCopy, error) { - result := pairStorageCopy{ - pairs: opts, - } + result := + pairStorageCopy{pairs: opts} for _, v := range opts { switch v.Key { @@ -816,23 +676,20 @@ func (s *Storage) parsePairStorageCopy(opts []Pair) (pairStorageCopy, error) { } } - // Check required pairs. - return result, nil } -// pairStorageCreate is the parsed struct type pairStorageCreate struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasObjectMode bool ObjectMode ObjectMode } -// parsePairStorageCreate will parse Pair slice into *pairStorageCreate func (s *Storage) parsePairStorageCreate(opts []Pair) (pairStorageCreate, error) { - result := pairStorageCreate{ - pairs: opts, - } + result := + pairStorageCreate{pairs: opts} for _, v := range opts { switch v.Key { @@ -842,7 +699,6 @@ func (s *Storage) parsePairStorageCreate(opts []Pair) (pairStorageCreate, error) } result.HasObjectMode = true result.ObjectMode = v.Value.(ObjectMode) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -853,21 +709,18 @@ func (s *Storage) parsePairStorageCreate(opts []Pair) (pairStorageCreate, error) } } - // Check required pairs. - return result, nil } -// pairStorageCreateAppend is the parsed struct type pairStorageCreateAppend struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageCreateAppend will parse Pair slice into *pairStorageCreateAppend func (s *Storage) parsePairStorageCreateAppend(opts []Pair) (pairStorageCreateAppend, error) { - result := pairStorageCreateAppend{ - pairs: opts, - } + result := + pairStorageCreateAppend{pairs: opts} for _, v := range opts { switch v.Key { @@ -881,21 +734,18 @@ func (s *Storage) parsePairStorageCreateAppend(opts []Pair) (pairStorageCreateAp } } - // Check required pairs. - return result, nil } -// pairStorageCreateMultipart is the parsed struct type pairStorageCreateMultipart struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageCreateMultipart will parse Pair slice into *pairStorageCreateMultipart func (s *Storage) parsePairStorageCreateMultipart(opts []Pair) (pairStorageCreateMultipart, error) { - result := pairStorageCreateMultipart{ - pairs: opts, - } + result := + pairStorageCreateMultipart{pairs: opts} for _, v := range opts { switch v.Key { @@ -909,25 +759,22 @@ func (s *Storage) parsePairStorageCreateMultipart(opts []Pair) (pairStorageCreat } } - // Check required pairs. - return result, nil } -// pairStorageDelete is the parsed struct type pairStorageDelete struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasMultipartID bool MultipartID string HasObjectMode bool ObjectMode ObjectMode } -// parsePairStorageDelete will parse Pair slice into *pairStorageDelete func (s *Storage) parsePairStorageDelete(opts []Pair) (pairStorageDelete, error) { - result := pairStorageDelete{ - pairs: opts, - } + result := + pairStorageDelete{pairs: opts} for _, v := range opts { switch v.Key { @@ -937,14 +784,12 @@ func (s *Storage) parsePairStorageDelete(opts []Pair) (pairStorageDelete, error) } result.HasMultipartID = true result.MultipartID = v.Value.(string) - continue case "object_mode": if result.HasObjectMode { continue } result.HasObjectMode = true result.ObjectMode = v.Value.(ObjectMode) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -955,21 +800,18 @@ func (s *Storage) parsePairStorageDelete(opts []Pair) (pairStorageDelete, error) } } - // Check required pairs. - return result, nil } -// pairStorageFetch is the parsed struct type pairStorageFetch struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageFetch will parse Pair slice into *pairStorageFetch func (s *Storage) parsePairStorageFetch(opts []Pair) (pairStorageFetch, error) { - result := pairStorageFetch{ - pairs: opts, - } + result := + pairStorageFetch{pairs: opts} for _, v := range opts { switch v.Key { @@ -983,23 +825,20 @@ func (s *Storage) parsePairStorageFetch(opts []Pair) (pairStorageFetch, error) { } } - // Check required pairs. - return result, nil } -// pairStorageList is the parsed struct type pairStorageList struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasListMode bool ListMode ListMode } -// parsePairStorageList will parse Pair slice into *pairStorageList func (s *Storage) parsePairStorageList(opts []Pair) (pairStorageList, error) { - result := pairStorageList{ - pairs: opts, - } + result := + pairStorageList{pairs: opts} for _, v := range opts { switch v.Key { @@ -1009,7 +848,6 @@ func (s *Storage) parsePairStorageList(opts []Pair) (pairStorageList, error) { } result.HasListMode = true result.ListMode = v.Value.(ListMode) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -1020,21 +858,18 @@ func (s *Storage) parsePairStorageList(opts []Pair) (pairStorageList, error) { } } - // Check required pairs. - return result, nil } -// pairStorageListMultipart is the parsed struct type pairStorageListMultipart struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageListMultipart will parse Pair slice into *pairStorageListMultipart func (s *Storage) parsePairStorageListMultipart(opts []Pair) (pairStorageListMultipart, error) { - result := pairStorageListMultipart{ - pairs: opts, - } + result := + pairStorageListMultipart{pairs: opts} for _, v := range opts { switch v.Key { @@ -1048,21 +883,18 @@ func (s *Storage) parsePairStorageListMultipart(opts []Pair) (pairStorageListMul } } - // Check required pairs. - return result, nil } -// pairStorageMetadata is the parsed struct type pairStorageMetadata struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageMetadata will parse Pair slice into *pairStorageMetadata func (s *Storage) parsePairStorageMetadata(opts []Pair) (pairStorageMetadata, error) { - result := pairStorageMetadata{ - pairs: opts, - } + result := + pairStorageMetadata{pairs: opts} for _, v := range opts { switch v.Key { @@ -1076,21 +908,18 @@ func (s *Storage) parsePairStorageMetadata(opts []Pair) (pairStorageMetadata, er } } - // Check required pairs. - return result, nil } -// pairStorageMove is the parsed struct type pairStorageMove struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageMove will parse Pair slice into *pairStorageMove func (s *Storage) parsePairStorageMove(opts []Pair) (pairStorageMove, error) { - result := pairStorageMove{ - pairs: opts, - } + result := + pairStorageMove{pairs: opts} for _, v := range opts { switch v.Key { @@ -1104,23 +933,20 @@ func (s *Storage) parsePairStorageMove(opts []Pair) (pairStorageMove, error) { } } - // Check required pairs. - return result, nil } -// pairStorageReach is the parsed struct type pairStorageReach struct { - pairs []Pair + pairs []Pair + // Required pairs HasExpire bool Expire time.Duration + // Optional pairs } -// parsePairStorageReach will parse Pair slice into *pairStorageReach func (s *Storage) parsePairStorageReach(opts []Pair) (pairStorageReach, error) { - result := pairStorageReach{ - pairs: opts, - } + result := + pairStorageReach{pairs: opts} for _, v := range opts { switch v.Key { @@ -1130,7 +956,6 @@ func (s *Storage) parsePairStorageReach(opts []Pair) (pairStorageReach, error) { } result.HasExpire = true result.Expire = v.Value.(time.Duration) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -1140,18 +965,16 @@ func (s *Storage) parsePairStorageReach(opts []Pair) (pairStorageReach, error) { return pairStorageReach{}, services.PairUnsupportedError{Pair: v} } } - - // Check required pairs. if !result.HasExpire { return pairStorageReach{}, services.PairRequiredError{Keys: []string{"expire"}} } - return result, nil } -// pairStorageRead is the parsed struct type pairStorageRead struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasIoCallback bool IoCallback func([]byte) HasOffset bool @@ -1160,11 +983,9 @@ type pairStorageRead struct { Size int64 } -// parsePairStorageRead will parse Pair slice into *pairStorageRead func (s *Storage) parsePairStorageRead(opts []Pair) (pairStorageRead, error) { - result := pairStorageRead{ - pairs: opts, - } + result := + pairStorageRead{pairs: opts} for _, v := range opts { switch v.Key { @@ -1174,21 +995,18 @@ func (s *Storage) parsePairStorageRead(opts []Pair) (pairStorageRead, error) { } result.HasIoCallback = true result.IoCallback = v.Value.(func([]byte)) - continue case "offset": if result.HasOffset { continue } result.HasOffset = true result.Offset = v.Value.(int64) - continue case "size": if result.HasSize { continue } result.HasSize = true result.Size = v.Value.(int64) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -1199,23 +1017,20 @@ func (s *Storage) parsePairStorageRead(opts []Pair) (pairStorageRead, error) { } } - // Check required pairs. - return result, nil } -// pairStorageStat is the parsed struct type pairStorageStat struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasObjectMode bool ObjectMode ObjectMode } -// parsePairStorageStat will parse Pair slice into *pairStorageStat func (s *Storage) parsePairStorageStat(opts []Pair) (pairStorageStat, error) { - result := pairStorageStat{ - pairs: opts, - } + result := + pairStorageStat{pairs: opts} for _, v := range opts { switch v.Key { @@ -1225,7 +1040,6 @@ func (s *Storage) parsePairStorageStat(opts []Pair) (pairStorageStat, error) { } result.HasObjectMode = true result.ObjectMode = v.Value.(ObjectMode) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -1236,14 +1050,13 @@ func (s *Storage) parsePairStorageStat(opts []Pair) (pairStorageStat, error) { } } - // Check required pairs. - return result, nil } -// pairStorageWrite is the parsed struct type pairStorageWrite struct { - pairs []Pair + pairs []Pair + // Required pairs + // Optional pairs HasContentMd5 bool ContentMd5 string HasContentType bool @@ -1254,11 +1067,9 @@ type pairStorageWrite struct { StorageClass string } -// parsePairStorageWrite will parse Pair slice into *pairStorageWrite func (s *Storage) parsePairStorageWrite(opts []Pair) (pairStorageWrite, error) { - result := pairStorageWrite{ - pairs: opts, - } + result := + pairStorageWrite{pairs: opts} for _, v := range opts { switch v.Key { @@ -1268,28 +1079,24 @@ func (s *Storage) parsePairStorageWrite(opts []Pair) (pairStorageWrite, error) { } result.HasContentMd5 = true result.ContentMd5 = v.Value.(string) - continue case "content_type": if result.HasContentType { continue } result.HasContentType = true result.ContentType = v.Value.(string) - continue case "io_callback": if result.HasIoCallback { continue } result.HasIoCallback = true result.IoCallback = v.Value.(func([]byte)) - continue case "storage_class": if result.HasStorageClass { continue } result.HasStorageClass = true result.StorageClass = v.Value.(string) - continue default: // loose_pair feature introduced in GSP-109. // If user enable this feature, service should ignore not support pair error. @@ -1300,21 +1107,18 @@ func (s *Storage) parsePairStorageWrite(opts []Pair) (pairStorageWrite, error) { } } - // Check required pairs. - return result, nil } -// pairStorageWriteAppend is the parsed struct type pairStorageWriteAppend struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageWriteAppend will parse Pair slice into *pairStorageWriteAppend func (s *Storage) parsePairStorageWriteAppend(opts []Pair) (pairStorageWriteAppend, error) { - result := pairStorageWriteAppend{ - pairs: opts, - } + result := + pairStorageWriteAppend{pairs: opts} for _, v := range opts { switch v.Key { @@ -1328,21 +1132,18 @@ func (s *Storage) parsePairStorageWriteAppend(opts []Pair) (pairStorageWriteAppe } } - // Check required pairs. - return result, nil } -// pairStorageWriteMultipart is the parsed struct type pairStorageWriteMultipart struct { pairs []Pair + // Required pairs + // Optional pairs } -// parsePairStorageWriteMultipart will parse Pair slice into *pairStorageWriteMultipart func (s *Storage) parsePairStorageWriteMultipart(opts []Pair) (pairStorageWriteMultipart, error) { - result := pairStorageWriteMultipart{ - pairs: opts, - } + result := + pairStorageWriteMultipart{pairs: opts} for _, v := range opts { switch v.Key { @@ -1356,29 +1157,21 @@ func (s *Storage) parsePairStorageWriteMultipart(opts []Pair) (pairStorageWriteM } } - // Check required pairs. - return result, nil } - -// CommitAppend will commit and finish an append process. -// -// This function will create a context by default. func (s *Storage) CommitAppend(o *Object, pairs ...Pair) (err error) { ctx := context.Background() return s.CommitAppendWithContext(ctx, o, pairs...) } - -// CommitAppendWithContext will commit and finish an append process. func (s *Storage) CommitAppendWithContext(ctx context.Context, o *Object, pairs ...Pair) (err error) { defer func() { - err = s.formatError("commit_append", err) + err = + s.formatError("commit_append", err) }() if !o.Mode.IsAppend() { err = services.ObjectModeInvalidError{Expected: ModeAppend, Actual: o.Mode} return } - pairs = append(pairs, s.defaultPairs.CommitAppend...) var opt pairStorageCommitAppend @@ -1386,28 +1179,21 @@ func (s *Storage) CommitAppendWithContext(ctx context.Context, o *Object, pairs if err != nil { return } - return s.commitAppend(ctx, o, opt) } - -// CompleteMultipart will complete a multipart upload and construct an Object. -// -// This function will create a context by default. func (s *Storage) CompleteMultipart(o *Object, parts []*Part, pairs ...Pair) (err error) { ctx := context.Background() return s.CompleteMultipartWithContext(ctx, o, parts, pairs...) } - -// CompleteMultipartWithContext will complete a multipart upload and construct an Object. func (s *Storage) CompleteMultipartWithContext(ctx context.Context, o *Object, parts []*Part, pairs ...Pair) (err error) { defer func() { - err = s.formatError("complete_multipart", err) + err = + s.formatError("complete_multipart", err) }() if !o.Mode.IsPart() { err = services.ObjectModeInvalidError{Expected: ModePart, Actual: o.Mode} return } - pairs = append(pairs, s.defaultPairs.CompleteMultipart...) var opt pairStorageCompleteMultipart @@ -1415,44 +1201,16 @@ func (s *Storage) CompleteMultipartWithContext(ctx context.Context, o *Object, p if err != nil { return } - return s.completeMultipart(ctx, o, parts, opt) } - -// Copy will copy an Object or multiple object in the service. -// -// ## Behavior -// -// - Copy only copy one and only one object. -// - Service DON'T NEED to support copy a non-empty directory or copy files recursively. -// - User NEED to implement copy a non-empty directory and copy recursively by themself. -// - Copy a file to a directory SHOULD return `ErrObjectModeInvalid`. -// - Copy SHOULD NOT return an error as dst object exists. -// - Service that has native support for `overwrite` doesn't NEED to check the dst object exists or not. -// - Service that doesn't have native support for `overwrite` SHOULD check and delete the dst object if exists. -// - A successful copy opration should be complete, which means the dst object's content and metadata should be the same as src object. -// -// This function will create a context by default. func (s *Storage) Copy(src string, dst string, pairs ...Pair) (err error) { ctx := context.Background() return s.CopyWithContext(ctx, src, dst, pairs...) } - -// CopyWithContext will copy an Object or multiple object in the service. -// -// ## Behavior -// -// - Copy only copy one and only one object. -// - Service DON'T NEED to support copy a non-empty directory or copy files recursively. -// - User NEED to implement copy a non-empty directory and copy recursively by themself. -// - Copy a file to a directory SHOULD return `ErrObjectModeInvalid`. -// - Copy SHOULD NOT return an error as dst object exists. -// - Service that has native support for `overwrite` doesn't NEED to check the dst object exists or not. -// - Service that doesn't have native support for `overwrite` SHOULD check and delete the dst object if exists. -// - A successful copy opration should be complete, which means the dst object's content and metadata should be the same as src object. func (s *Storage) CopyWithContext(ctx context.Context, src string, dst string, pairs ...Pair) (err error) { defer func() { - err = s.formatError("copy", err, src, dst) + err = + s.formatError("copy", err, src, dst) }() pairs = append(pairs, s.defaultPairs.Copy...) @@ -1462,52 +1220,24 @@ func (s *Storage) CopyWithContext(ctx context.Context, src string, dst string, p if err != nil { return } - return s.copy(ctx, src, dst, opt) } - -// Create will create a new object without any api call. -// -// ## Behavior -// -// - Create SHOULD NOT send any API call. -// - Create SHOULD accept ObjectMode pair as object mode. -// -// This function will create a context by default. func (s *Storage) Create(path string, pairs ...Pair) (o *Object) { pairs = append(pairs, s.defaultPairs.Create...) var opt pairStorageCreate - // Ignore error while handling local funtions. + // Ignore error while handling local functions. opt, _ = s.parsePairStorageCreate(pairs) - return s.create(path, opt) } - -// CreateAppend will create an append object. -// -// ## Behavior -// -// - CreateAppend SHOULD create an appendable object with position 0 and size 0. -// - CreateAppend SHOULD NOT return an error as the object exist. -// - Service SHOULD check and delete the object if exists. -// -// This function will create a context by default. func (s *Storage) CreateAppend(path string, pairs ...Pair) (o *Object, err error) { ctx := context.Background() return s.CreateAppendWithContext(ctx, path, pairs...) } - -// CreateAppendWithContext will create an append object. -// -// ## Behavior -// -// - CreateAppend SHOULD create an appendable object with position 0 and size 0. -// - CreateAppend SHOULD NOT return an error as the object exist. -// - Service SHOULD check and delete the object if exists. func (s *Storage) CreateAppendWithContext(ctx context.Context, path string, pairs ...Pair) (o *Object, err error) { defer func() { - err = s.formatError("create_append", err, path) + err = + s.formatError("create_append", err, path) }() pairs = append(pairs, s.defaultPairs.CreateAppend...) @@ -1517,30 +1247,16 @@ func (s *Storage) CreateAppendWithContext(ctx context.Context, path string, pair if err != nil { return } - return s.createAppend(ctx, path, opt) } - -// CreateMultipart will create a new multipart. -// -// ## Behavior -// -// - CreateMultipart SHOULD NOT return an error as the object exists. -// -// This function will create a context by default. func (s *Storage) CreateMultipart(path string, pairs ...Pair) (o *Object, err error) { ctx := context.Background() return s.CreateMultipartWithContext(ctx, path, pairs...) } - -// CreateMultipartWithContext will create a new multipart. -// -// ## Behavior -// -// - CreateMultipart SHOULD NOT return an error as the object exists. func (s *Storage) CreateMultipartWithContext(ctx context.Context, path string, pairs ...Pair) (o *Object, err error) { defer func() { - err = s.formatError("create_multipart", err, path) + err = + s.formatError("create_multipart", err, path) }() pairs = append(pairs, s.defaultPairs.CreateMultipart...) @@ -1550,42 +1266,16 @@ func (s *Storage) CreateMultipartWithContext(ctx context.Context, path string, p if err != nil { return } - return s.createMultipart(ctx, path, opt) } - -// Delete will delete an object from service. -// -// ## Behavior -// -// - Delete only delete one and only one object. -// - Service DON'T NEED to support remove all. -// - User NEED to implement remove_all by themself. -// - Delete is idempotent. -// - Successful delete always return nil error. -// - Delete SHOULD never return `ObjectNotExist` -// - Delete DON'T NEED to check the object exist or not. -// -// This function will create a context by default. func (s *Storage) Delete(path string, pairs ...Pair) (err error) { ctx := context.Background() return s.DeleteWithContext(ctx, path, pairs...) } - -// DeleteWithContext will delete an object from service. -// -// ## Behavior -// -// - Delete only delete one and only one object. -// - Service DON'T NEED to support remove all. -// - User NEED to implement remove_all by themself. -// - Delete is idempotent. -// - Successful delete always return nil error. -// - Delete SHOULD never return `ObjectNotExist` -// - Delete DON'T NEED to check the object exist or not. func (s *Storage) DeleteWithContext(ctx context.Context, path string, pairs ...Pair) (err error) { defer func() { - err = s.formatError("delete", err, path) + err = + s.formatError("delete", err, path) }() pairs = append(pairs, s.defaultPairs.Delete...) @@ -1595,32 +1285,16 @@ func (s *Storage) DeleteWithContext(ctx context.Context, path string, pairs ...P if err != nil { return } - return s.delete(ctx, path, opt) } - -// Fetch will fetch from a given url to path. -// -// ## Behavior -// -// - Fetch SHOULD NOT return an error as the object exists. -// - A successful fetch operation should be complete, which means the object's content and metadata should be the same as requiring from the url. -// -// This function will create a context by default. func (s *Storage) Fetch(path string, url string, pairs ...Pair) (err error) { ctx := context.Background() return s.FetchWithContext(ctx, path, url, pairs...) } - -// FetchWithContext will fetch from a given url to path. -// -// ## Behavior -// -// - Fetch SHOULD NOT return an error as the object exists. -// - A successful fetch operation should be complete, which means the object's content and metadata should be the same as requiring from the url. func (s *Storage) FetchWithContext(ctx context.Context, path string, url string, pairs ...Pair) (err error) { defer func() { - err = s.formatError("fetch", err, path, url) + err = + s.formatError("fetch", err, path, url) }() pairs = append(pairs, s.defaultPairs.Fetch...) @@ -1630,34 +1304,16 @@ func (s *Storage) FetchWithContext(ctx context.Context, path string, url string, if err != nil { return } - return s.fetch(ctx, path, url, opt) } - -// List will return list a specific path. -// -// ## Behavior -// -// - Service SHOULD support default `ListMode`. -// - Service SHOULD implement `ListModeDir` without the check for `VirtualDir`. -// - Service DON'T NEED to `Stat` while in `List`. -// -// This function will create a context by default. func (s *Storage) List(path string, pairs ...Pair) (oi *ObjectIterator, err error) { ctx := context.Background() return s.ListWithContext(ctx, path, pairs...) } - -// ListWithContext will return list a specific path. -// -// ## Behavior -// -// - Service SHOULD support default `ListMode`. -// - Service SHOULD implement `ListModeDir` without the check for `VirtualDir`. -// - Service DON'T NEED to `Stat` while in `List`. func (s *Storage) ListWithContext(ctx context.Context, path string, pairs ...Pair) (oi *ObjectIterator, err error) { defer func() { - err = s.formatError("list", err, path) + err = + s.formatError("list", err, path) }() pairs = append(pairs, s.defaultPairs.List...) @@ -1667,28 +1323,21 @@ func (s *Storage) ListWithContext(ctx context.Context, path string, pairs ...Pai if err != nil { return } - return s.list(ctx, path, opt) } - -// ListMultipart will list parts belong to this multipart. -// -// This function will create a context by default. func (s *Storage) ListMultipart(o *Object, pairs ...Pair) (pi *PartIterator, err error) { ctx := context.Background() return s.ListMultipartWithContext(ctx, o, pairs...) } - -// ListMultipartWithContext will list parts belong to this multipart. func (s *Storage) ListMultipartWithContext(ctx context.Context, o *Object, pairs ...Pair) (pi *PartIterator, err error) { defer func() { - err = s.formatError("list_multipart", err) + err = + s.formatError("list_multipart", err) }() if !o.Mode.IsPart() { err = services.ObjectModeInvalidError{Expected: ModePart, Actual: o.Mode} return } - pairs = append(pairs, s.defaultPairs.ListMultipart...) var opt pairStorageListMultipart @@ -1696,57 +1345,24 @@ func (s *Storage) ListMultipartWithContext(ctx context.Context, o *Object, pairs if err != nil { return } - return s.listMultipart(ctx, o, opt) } - -// Metadata will return current storager metadata. -// -// This function will create a context by default. func (s *Storage) Metadata(pairs ...Pair) (meta *StorageMeta) { pairs = append(pairs, s.defaultPairs.Metadata...) var opt pairStorageMetadata - // Ignore error while handling local funtions. + // Ignore error while handling local functions. opt, _ = s.parsePairStorageMetadata(pairs) - return s.metadata(opt) } - -// Move will move an object in the service. -// -// ## Behavior -// -// - Move only move one and only one object. -// - Service DON'T NEED to support move a non-empty directory. -// - User NEED to implement move a non-empty directory by themself. -// - Move a file to a directory SHOULD return `ErrObjectModeInvalid`. -// - Move SHOULD NOT return an error as dst object exists. -// - Service that has native support for `overwrite` doesn't NEED to check the dst object exists or not. -// - Service that doesn't have native support for `overwrite` SHOULD check and delete the dst object if exists. -// - A successful move operation SHOULD be complete, which means the dst object's content and metadata should be the same as src object. -// -// This function will create a context by default. func (s *Storage) Move(src string, dst string, pairs ...Pair) (err error) { ctx := context.Background() return s.MoveWithContext(ctx, src, dst, pairs...) } - -// MoveWithContext will move an object in the service. -// -// ## Behavior -// -// - Move only move one and only one object. -// - Service DON'T NEED to support move a non-empty directory. -// - User NEED to implement move a non-empty directory by themself. -// - Move a file to a directory SHOULD return `ErrObjectModeInvalid`. -// - Move SHOULD NOT return an error as dst object exists. -// - Service that has native support for `overwrite` doesn't NEED to check the dst object exists or not. -// - Service that doesn't have native support for `overwrite` SHOULD check and delete the dst object if exists. -// - A successful move operation SHOULD be complete, which means the dst object's content and metadata should be the same as src object. func (s *Storage) MoveWithContext(ctx context.Context, src string, dst string, pairs ...Pair) (err error) { defer func() { - err = s.formatError("move", err, src, dst) + err = + s.formatError("move", err, src, dst) }() pairs = append(pairs, s.defaultPairs.Move...) @@ -1756,26 +1372,16 @@ func (s *Storage) MoveWithContext(ctx context.Context, src string, dst string, p if err != nil { return } - return s.move(ctx, src, dst, opt) } - -// Reach will provide a way, which can reach the object. -// -// Deprecated: Use QuerySignHTTPRead instead. -// -// This function will create a context by default. func (s *Storage) Reach(path string, pairs ...Pair) (url string, err error) { ctx := context.Background() return s.ReachWithContext(ctx, path, pairs...) } - -// ReachWithContext will provide a way, which can reach the object. -// -// Deprecated: Use QuerySignHTTPRead instead. func (s *Storage) ReachWithContext(ctx context.Context, path string, pairs ...Pair) (url string, err error) { defer func() { - err = s.formatError("reach", err, path) + err = + s.formatError("reach", err, path) }() pairs = append(pairs, s.defaultPairs.Reach...) @@ -1785,22 +1391,16 @@ func (s *Storage) ReachWithContext(ctx context.Context, path string, pairs ...Pa if err != nil { return } - return s.reach(ctx, path, opt) } - -// Read will read the file's data. -// -// This function will create a context by default. func (s *Storage) Read(path string, w io.Writer, pairs ...Pair) (n int64, err error) { ctx := context.Background() return s.ReadWithContext(ctx, path, w, pairs...) } - -// ReadWithContext will read the file's data. func (s *Storage) ReadWithContext(ctx context.Context, path string, w io.Writer, pairs ...Pair) (n int64, err error) { defer func() { - err = s.formatError("read", err, path) + err = + s.formatError("read", err, path) }() pairs = append(pairs, s.defaultPairs.Read...) @@ -1810,34 +1410,16 @@ func (s *Storage) ReadWithContext(ctx context.Context, path string, w io.Writer, if err != nil { return } - return s.read(ctx, path, w, opt) } - -// Stat will stat a path to get info of an object. -// -// ## Behavior -// -// - Stat SHOULD accept ObjectMode pair as hints. -// - Service COULD have different implementations for different object mode. -// - Service SHOULD check if returning ObjectMode is match -// -// This function will create a context by default. func (s *Storage) Stat(path string, pairs ...Pair) (o *Object, err error) { ctx := context.Background() return s.StatWithContext(ctx, path, pairs...) } - -// StatWithContext will stat a path to get info of an object. -// -// ## Behavior -// -// - Stat SHOULD accept ObjectMode pair as hints. -// - Service COULD have different implementations for different object mode. -// - Service SHOULD check if returning ObjectMode is match func (s *Storage) StatWithContext(ctx context.Context, path string, pairs ...Pair) (o *Object, err error) { defer func() { - err = s.formatError("stat", err, path) + err = + s.formatError("stat", err, path) }() pairs = append(pairs, s.defaultPairs.Stat...) @@ -1847,36 +1429,16 @@ func (s *Storage) StatWithContext(ctx context.Context, path string, pairs ...Pai if err != nil { return } - return s.stat(ctx, path, opt) } - -// Write will write data into a file. -// -// ## Behavior -// -// - Write SHOULD NOT return an error as the object exist. -// - Service that has native support for `overwrite` doesn't NEED to check the object exists or not. -// - Service that doesn't have native support for `overwrite` SHOULD check and delete the object if exists. -// - A successful write operation SHOULD be complete, which means the object's content and metadata should be the same as specified in write request. -// -// This function will create a context by default. func (s *Storage) Write(path string, r io.Reader, size int64, pairs ...Pair) (n int64, err error) { ctx := context.Background() return s.WriteWithContext(ctx, path, r, size, pairs...) } - -// WriteWithContext will write data into a file. -// -// ## Behavior -// -// - Write SHOULD NOT return an error as the object exist. -// - Service that has native support for `overwrite` doesn't NEED to check the object exists or not. -// - Service that doesn't have native support for `overwrite` SHOULD check and delete the object if exists. -// - A successful write operation SHOULD be complete, which means the object's content and metadata should be the same as specified in write request. func (s *Storage) WriteWithContext(ctx context.Context, path string, r io.Reader, size int64, pairs ...Pair) (n int64, err error) { defer func() { - err = s.formatError("write", err, path) + err = + s.formatError("write", err, path) }() pairs = append(pairs, s.defaultPairs.Write...) @@ -1886,28 +1448,21 @@ func (s *Storage) WriteWithContext(ctx context.Context, path string, r io.Reader if err != nil { return } - return s.write(ctx, path, r, size, opt) } - -// WriteAppend will append content to an append object. -// -// This function will create a context by default. func (s *Storage) WriteAppend(o *Object, r io.Reader, size int64, pairs ...Pair) (n int64, err error) { ctx := context.Background() return s.WriteAppendWithContext(ctx, o, r, size, pairs...) } - -// WriteAppendWithContext will append content to an append object. func (s *Storage) WriteAppendWithContext(ctx context.Context, o *Object, r io.Reader, size int64, pairs ...Pair) (n int64, err error) { defer func() { - err = s.formatError("write_append", err) + err = + s.formatError("write_append", err) }() if !o.Mode.IsAppend() { err = services.ObjectModeInvalidError{Expected: ModeAppend, Actual: o.Mode} return } - pairs = append(pairs, s.defaultPairs.WriteAppend...) var opt pairStorageWriteAppend @@ -1915,28 +1470,21 @@ func (s *Storage) WriteAppendWithContext(ctx context.Context, o *Object, r io.Re if err != nil { return } - return s.writeAppend(ctx, o, r, size, opt) } - -// WriteMultipart will write content to a multipart. -// -// This function will create a context by default. func (s *Storage) WriteMultipart(o *Object, r io.Reader, size int64, index int, pairs ...Pair) (n int64, part *Part, err error) { ctx := context.Background() return s.WriteMultipartWithContext(ctx, o, r, size, index, pairs...) } - -// WriteMultipartWithContext will write content to a multipart. func (s *Storage) WriteMultipartWithContext(ctx context.Context, o *Object, r io.Reader, size int64, index int, pairs ...Pair) (n int64, part *Part, err error) { defer func() { - err = s.formatError("write_multipart", err) + err = + s.formatError("write_multipart", err) }() if !o.Mode.IsPart() { err = services.ObjectModeInvalidError{Expected: ModePart, Actual: o.Mode} return } - pairs = append(pairs, s.defaultPairs.WriteMultipart...) var opt pairStorageWriteMultipart @@ -1944,10 +1492,8 @@ func (s *Storage) WriteMultipartWithContext(ctx context.Context, o *Object, r io if err != nil { return } - return s.writeMultipart(ctx, o, r, size, index, opt) } - func init() { services.RegisterServicer(Type, NewServicer) services.RegisterStorager(Type, NewStorager) diff --git a/types/object.generated.go b/types/object.generated.go index ed9b9da0a..ddf160b9b 100644 --- a/types/object.generated.go +++ b/types/object.generated.go @@ -63,7 +63,7 @@ type Object struct { // AppendOffset is the offset of the append object. // GetAppendOffset will get AppendOffset from Object. // -// // AppendOffset AppendOffset is the offset of the append object. +// AppendOffset is the offset of the append object. func (o *Object) GetAppendOffset() (int64, bool) { o.stat() @@ -85,7 +85,7 @@ func (o *Object) MustGetAppendOffset() int64 { return o.appendOffset } -// SetAppendOffset will set AppendOffset into Object. +// SetAppendOffset will get AppendOffset into Object. // // AppendOffset is the offset of the append object. func (o *Object) SetAppendOffset(v int64) *Object { @@ -95,8 +95,6 @@ func (o *Object) SetAppendOffset(v int64) *Object { } // GetContentLength will get ContentLength from Object. -// -// // ContentLength func (o *Object) GetContentLength() (int64, bool) { o.stat() @@ -116,7 +114,7 @@ func (o *Object) MustGetContentLength() int64 { return o.contentLength } -// SetContentLength will set ContentLength into Object. +// SetContentLength will get ContentLength into Object. func (o *Object) SetContentLength(v int64) *Object { o.contentLength = v o.bit |= objectIndexContentLength @@ -124,8 +122,6 @@ func (o *Object) SetContentLength(v int64) *Object { } // GetContentMd5 will get ContentMd5 from Object. -// -// // ContentMd5 func (o *Object) GetContentMd5() (string, bool) { o.stat() @@ -145,7 +141,7 @@ func (o *Object) MustGetContentMd5() string { return o.contentMd5 } -// SetContentMd5 will set ContentMd5 into Object. +// SetContentMd5 will get ContentMd5 into Object. func (o *Object) SetContentMd5(v string) *Object { o.contentMd5 = v o.bit |= objectIndexContentMd5 @@ -153,8 +149,6 @@ func (o *Object) SetContentMd5(v string) *Object { } // GetContentType will get ContentType from Object. -// -// // ContentType func (o *Object) GetContentType() (string, bool) { o.stat() @@ -174,7 +168,7 @@ func (o *Object) MustGetContentType() string { return o.contentType } -// SetContentType will set ContentType into Object. +// SetContentType will get ContentType into Object. func (o *Object) SetContentType(v string) *Object { o.contentType = v o.bit |= objectIndexContentType @@ -182,8 +176,6 @@ func (o *Object) SetContentType(v string) *Object { } // GetEtag will get Etag from Object. -// -// // Etag func (o *Object) GetEtag() (string, bool) { o.stat() @@ -203,7 +195,7 @@ func (o *Object) MustGetEtag() string { return o.etag } -// SetEtag will set Etag into Object. +// SetEtag will get Etag into Object. func (o *Object) SetEtag(v string) *Object { o.etag = v o.bit |= objectIndexEtag @@ -218,8 +210,6 @@ func (o *Object) SetID(v string) *Object { } // GetLastModified will get LastModified from Object. -// -// // LastModified func (o *Object) GetLastModified() (time.Time, bool) { o.stat() @@ -239,7 +229,7 @@ func (o *Object) MustGetLastModified() time.Time { return o.lastModified } -// SetLastModified will set LastModified into Object. +// SetLastModified will get LastModified into Object. func (o *Object) SetLastModified(v time.Time) *Object { o.lastModified = v o.bit |= objectIndexLastModified @@ -248,7 +238,7 @@ func (o *Object) SetLastModified(v time.Time) *Object { // GetLinkTarget will get LinkTarget from Object. // -// // LinkTarget LinkTarget is the symlink target for link object. +// LinkTarget is the symlink target for link object. func (o *Object) GetLinkTarget() (string, bool) { o.stat() @@ -270,7 +260,7 @@ func (o *Object) MustGetLinkTarget() string { return o.linkTarget } -// SetLinkTarget will set LinkTarget into Object. +// SetLinkTarget will get LinkTarget into Object. // // LinkTarget is the symlink target for link object. func (o *Object) SetLinkTarget(v string) *Object { @@ -288,7 +278,7 @@ func (o *Object) SetMode(v ObjectMode) *Object { // GetMultipartID will get MultipartID from Object. // -// // MultipartID MultipartID is the part id of part object. +// MultipartID is the part id of part object. func (o *Object) GetMultipartID() (string, bool) { o.stat() @@ -310,7 +300,7 @@ func (o *Object) MustGetMultipartID() string { return o.multipartID } -// SetMultipartID will set MultipartID into Object. +// SetMultipartID will get MultipartID into Object. // // MultipartID is the part id of part object. func (o *Object) SetMultipartID(v string) *Object { @@ -328,7 +318,7 @@ func (o *Object) SetPath(v string) *Object { // GetSystemMetadata will get SystemMetadata from Object. // -// // SystemMetadata SystemMetadata stores system defined metadata. +// SystemMetadata stores system defined metadata. func (o *Object) GetSystemMetadata() (interface{}, bool) { o.stat() @@ -350,7 +340,7 @@ func (o *Object) MustGetSystemMetadata() interface{} { return o.systemMetadata } -// SetSystemMetadata will set SystemMetadata into Object. +// SetSystemMetadata will get SystemMetadata into Object. // // SystemMetadata stores system defined metadata. func (o *Object) SetSystemMetadata(v interface{}) *Object { @@ -361,7 +351,7 @@ func (o *Object) SetSystemMetadata(v interface{}) *Object { // GetUserMetadata will get UserMetadata from Object. // -// // UserMetadata UserMetadata stores user defined metadata. +// UserMetadata stores user defined metadata. func (o *Object) GetUserMetadata() (map[string]string, bool) { o.stat() @@ -383,7 +373,7 @@ func (o *Object) MustGetUserMetadata() map[string]string { return o.userMetadata } -// SetUserMetadata will set UserMetadata into Object. +// SetUserMetadata will get UserMetadata into Object. // // UserMetadata stores user defined metadata. func (o *Object) SetUserMetadata(v map[string]string) *Object { diff --git a/types/operation.generated.go b/types/operation.generated.go index c7cb463b9..b6729929b 100644 --- a/types/operation.generated.go +++ b/types/operation.generated.go @@ -41,7 +41,8 @@ type Appender interface { } // UnimplementedAppender must be embedded to have forward compatible implementations. -type UnimplementedAppender struct{} +type UnimplementedAppender struct { +} func (s UnimplementedAppender) mustEmbedUnimplementedAppender() { } @@ -111,7 +112,8 @@ type Blocker interface { } // UnimplementedBlocker must be embedded to have forward compatible implementations. -type UnimplementedBlocker struct{} +type UnimplementedBlocker struct { +} func (s UnimplementedBlocker) mustEmbedUnimplementedBlocker() { } @@ -190,7 +192,8 @@ type Copier interface { } // UnimplementedCopier must be embedded to have forward compatible implementations. -type UnimplementedCopier struct{} +type UnimplementedCopier struct { +} func (s UnimplementedCopier) mustEmbedUnimplementedCopier() { } @@ -217,7 +220,8 @@ type Direr interface { } // UnimplementedDirer must be embedded to have forward compatible implementations. -type UnimplementedDirer struct{} +type UnimplementedDirer struct { +} func (s UnimplementedDirer) mustEmbedUnimplementedDirer() { } @@ -256,7 +260,8 @@ type Fetcher interface { } // UnimplementedFetcher must be embedded to have forward compatible implementations. -type UnimplementedFetcher struct{} +type UnimplementedFetcher struct { +} func (s UnimplementedFetcher) mustEmbedUnimplementedFetcher() { } @@ -309,7 +314,8 @@ type Linker interface { } // UnimplementedLinker must be embedded to have forward compatible implementations. -type UnimplementedLinker struct{} +type UnimplementedLinker struct { +} func (s UnimplementedLinker) mustEmbedUnimplementedLinker() { } @@ -364,7 +370,8 @@ type Mover interface { } // UnimplementedMover must be embedded to have forward compatible implementations. -type UnimplementedMover struct{} +type UnimplementedMover struct { +} func (s UnimplementedMover) mustEmbedUnimplementedMover() { } @@ -414,7 +421,8 @@ type Multiparter interface { } // UnimplementedMultiparter must be embedded to have forward compatible implementations. -type UnimplementedMultiparter struct{} +type UnimplementedMultiparter struct { +} func (s UnimplementedMultiparter) mustEmbedUnimplementedMultiparter() { } @@ -478,7 +486,8 @@ type Pager interface { } // UnimplementedPager must be embedded to have forward compatible implementations. -type UnimplementedPager struct{} +type UnimplementedPager struct { +} func (s UnimplementedPager) mustEmbedUnimplementedPager() { } @@ -519,7 +528,8 @@ type Reacher interface { } // UnimplementedReacher must be embedded to have forward compatible implementations. -type UnimplementedReacher struct{} +type UnimplementedReacher struct { +} func (s UnimplementedReacher) mustEmbedUnimplementedReacher() { } @@ -562,7 +572,8 @@ type Servicer interface { } // UnimplementedServicer must be embedded to have forward compatible implementations. -type UnimplementedServicer struct{} +type UnimplementedServicer struct { +} func (s UnimplementedServicer) mustEmbedUnimplementedServicer() { } @@ -620,7 +631,8 @@ type StorageHTTPSigner interface { } // UnimplementedStorageHTTPSigner must be embedded to have forward compatible implementations. -type UnimplementedStorageHTTPSigner struct{} +type UnimplementedStorageHTTPSigner struct { +} func (s UnimplementedStorageHTTPSigner) mustEmbedUnimplementedStorageHTTPSigner() { } @@ -749,7 +761,8 @@ type Storager interface { } // UnimplementedStorager must be embedded to have forward compatible implementations. -type UnimplementedStorager struct{} +type UnimplementedStorager struct { +} func (s UnimplementedStorager) mustEmbedUnimplementedStorager() { }