diff --git a/drip/api.gen.go b/drip/api.gen.go index a059d45..60c677c 100644 --- a/drip/api.gen.go +++ b/drip/api.gen.go @@ -423,6 +423,11 @@ type GetBranchParams struct { RepoName string `form:"repo_name" json:"repo_name"` } +// ComfyNodesBackfillParams defines parameters for ComfyNodesBackfill. +type ComfyNodesBackfillParams struct { + MaxNode *int `form:"max_node,omitempty" json:"max_node,omitempty"` +} + // GetGitcommitParams defines parameters for GetGitcommit. type GetGitcommitParams struct { // CommitId The ID of the commit to fetch data for. @@ -660,7 +665,7 @@ type ServerInterface interface { GetBranch(ctx echo.Context, params GetBranchParams) error // trigger comfy nodes backfill // (POST /comfy-nodes/backfill) - ComfyNodesBackfill(ctx echo.Context) error + ComfyNodesBackfill(ctx echo.Context, params ComfyNodesBackfillParams) error // Retrieve CI data for a given commit // (GET /gitcommit) GetGitcommit(ctx echo.Context, params GetGitcommitParams) error @@ -830,8 +835,17 @@ func (w *ServerInterfaceWrapper) GetBranch(ctx echo.Context) error { func (w *ServerInterfaceWrapper) ComfyNodesBackfill(ctx echo.Context) error { var err error + // Parameter object where we will unmarshal all parameters from the context + var params ComfyNodesBackfillParams + // ------------- Optional query parameter "max_node" ------------- + + err = runtime.BindQueryParameter("form", true, false, "max_node", ctx.QueryParams(), ¶ms.MaxNode) + if err != nil { + return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter max_node: %s", err)) + } + // Invoke the callback with all the unmarshaled arguments - err = w.Handler.ComfyNodesBackfill(ctx) + err = w.Handler.ComfyNodesBackfill(ctx, params) return err } @@ -1902,6 +1916,7 @@ func (response GetBranch500Response) VisitGetBranchResponse(w http.ResponseWrite } type ComfyNodesBackfillRequestObject struct { + Params ComfyNodesBackfillParams } type ComfyNodesBackfillResponseObject interface { @@ -2428,15 +2443,6 @@ func (response CreateComfyNodes404JSONResponse) VisitCreateComfyNodesResponse(w return json.NewEncoder(w).Encode(response) } -type CreateComfyNodes409JSONResponse ErrorResponse - -func (response CreateComfyNodes409JSONResponse) VisitCreateComfyNodesResponse(w http.ResponseWriter) error { - w.Header().Set("Content-Type", "application/json") - w.WriteHeader(409) - - return json.NewEncoder(w).Encode(response) -} - type CreateComfyNodes500JSONResponse ErrorResponse func (response CreateComfyNodes500JSONResponse) VisitCreateComfyNodesResponse(w http.ResponseWriter) error { @@ -3839,9 +3845,11 @@ func (sh *strictHandler) GetBranch(ctx echo.Context, params GetBranchParams) err } // ComfyNodesBackfill operation middleware -func (sh *strictHandler) ComfyNodesBackfill(ctx echo.Context) error { +func (sh *strictHandler) ComfyNodesBackfill(ctx echo.Context, params ComfyNodesBackfillParams) error { var request ComfyNodesBackfillRequestObject + request.Params = params + handler := func(ctx echo.Context, request interface{}) (interface{}, error) { return sh.ssi.ComfyNodesBackfill(ctx.Request().Context(), request.(ComfyNodesBackfillRequestObject)) } @@ -4874,110 +4882,109 @@ func (sh *strictHandler) GetWorkflowResult(ctx echo.Context, workflowResultId st // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+w9a3PbtpZ/BcO9M21mZcnpze3s+ptjJ6nb2vHYcTq9SVYXIiEJCQmwAGhH9fi/7+BF", - "giRAUfJLTjTTaRIBPHidN87BuY5imuWUICJ4tHcd8XiOMqj+uh8LTMmvdHKGeJEK+VPOaI6YwEh1gKrD", - "+DOdjHEif0gQjxnO5a/RXnSUICLwFCMG6BSIOQKf6QSIOeaAKYhgglJKZhwIGg0ischRtBdxwTCZRTcD", - "C54VpCd4VpBVwBdiTlkb7rs5ArrNwo1plmHhhXE5G18ymAWgXCIGZwi8P9s/BgVHCZgs7D5U0DARaIaY", - "BDdhkMTzMYEZakM8gRkqV4pSdAmJADMsgP7KN72YZtOF2sBpCmfcP0vVSe2d6jQEr4azIfjPzk5Kr3bk", - "4v4TAJ1hMZ5DPveDlS3LN9CA8Z2vBHJ02BtEhjiHM+SHYxp7AxM4C0C6IPgrkM1cwCwHV3NEHJDgCnKQ", - "wQRFg2hKWQaFPuCfX3jPOy4SOL5EjCv4zeEOLg73gWlV6OObMCJJx2wRSdRkXQKEHMDGMob9pjvDYsxQ", - "Tv1jyRaOBWULoBDYM1nfMV8Q/FeBAK6oeUpZOVlNye70igJ7N0JyIcHwbIbYuOAoQNiyBVzNKTBdUWKH", - "GvqAZjCeY4LGXEDNHv/B0DTai/5rVHHNkWGZo2Pd+Vz1vRlEklVCgclszBdcIA+TeGt7AN0jeMo5gl86", - "GI1s7s9lcjYmRTYJbVFepClg6K8CcQFMR9+UFmJOSRh7TxfvKIvnSxE4XwjZ7/aAuICsi3JV+x1Sg8SJ", - "YilS/EHZl2lKr84Kcq4/UJ9SKRjGU5yiZQDOdd/XsuvNILoy8HoICdu1vVk35S908hnFQgI+kGLghCao", - "LedjKNCMsoWHeI+AbZSskCE1MKEJApiDFHOBkoFGSknVM0aLXKK77MGHYZEl28ercQv5iQ9ggnKG5CR9", - "KgRJsGziAE9rM68+GoLD8u962gAyBOY4SRABWDP/iyNnLRNKUwSJHtsZrTn4S4bRFDi/2XOTo/zAwbQg", - "SgGCKRYLQBnIC5ZTjrzbhr7miOEMEQHTFdbpfjYAvFDYAAQF8RySGeJyWIYyeglT/wrtJLsxERHBFjs5", - "xUSUy5KjoK8oLkSFNN6lYZIXYix/9igwh2iKiVyX7ARyyGCGBGLcB4gWQkLCfCwR03MgelngEqaFAqk2", - "TaIrngIE4znQEOTGQYXccr5YoExNrL055hfIGFzIfzMkCkYU5XL/hnG7Y3okrrA7TiGTKIBJSdLcN3K1", - "0sDAgT08z1EsaYmrkVUnOQ07hZzRpIgrsRI4KB9PecWY1rDr/CRBAuKU++ShRnige6AEYKI5sUQYOKGF", - "0Pgk4UrcnGNiNokhTtNLdVhitc0JKo77IE4RZACSBMSUxJgjH7mqyayyIWeI55RwD6NFdr/aikg1yfYw", - "UlhjJhncBwOi+uCTZxZvsDhQ6up5kWVQ8/WGZXcHtlGnMSMB6Q6O3Gjr0PdsdoTnRhzuFQajVYAxr7YR", - "JgnWOHxa21CPWKqjWgZzRXRNjVBQoEcBOcQuX6uOs1Rc/EtZzVhJoEA7SonqhdA1nbetOOTFOIY5jLHw", - "KA/vqIApODi9AFRPy2jbXimQYP5lKSzZCdhOfaDO8mKsf/Tt3JvTC8UOhwDNhuDk/dHh0T54h3gKwW//", - "s+uXVVhgmI7jvPBJYdWoVgwvIU7hJEVggqbU4L/UR5WWyoddwOUqw9DVHtwGvNfKsNCljbEOcGtILdda", - "u44rQxlli6VooLv1OX/Kw3aHxIAWOZreGiMuJgURBfgdk+Ir+Gl3uPvCa+DgfDxlCP0dwLIc50C3G5Hr", - "AyJtP2XbjDli2CfF30nDRjfKrTTWIJy5C7d066Nkv+pfCYI2Dw1aBcqrZM0CR6n1E3ZdR2630yuSUpgE", - "vFfaQJWjlB0DQzqmG459B35x9rtkt44KLvsN+zoylHuhZZ4sW34q1XLhYmGXMSgP6b3pKj/GMTKKhAev", - "oJjb9fx+dPDq5PwVkAanNVrMGiu3jXd+YRGZYJ6ncFETlcFl5sUkxXyufQ5dKzwtO0rFRtFet3PV0Kd/", - "AsZ9oXQku8w+B79kU/qZ/vKwXJtf6Qpasw16KKSg112WbqkwHt2+mm6I6M/LxSBSZFKHrH7djwW+lKpA", - "9dMhSpFQHpjqt5eQEJQ4umY1Bxdj2/qBsjJT6jlio5rKXbC2qFRVNPJibhlxtwuBd6lkXUdXOUN8uxYz", - "BAVK9kWAMKBAymhQviZ5htZ1JRUu8/Gwp9KlHBiIJIjEXra/rwxRuU1Sjrh9gTULmoZbf9NoBd9JdSQN", - "/4nfMWJ49QXzkMKHt9rMfkvSxSdgiNN+UR/KoZEwm74F+RrMbVExQ5CHdAbdVvqlDFFrJPYScqcGUm5q", - "KVIGYErTlF4prQRlkAgc226YzIbguOACTEph5DrIepqp7aU3uEOtscYkai11XlFrMizD03KKSCJn5ml6", - "ncLZbDmjucglQZ1pF/ZKXEdpLrbZGPsTudEuFRt+NFzV2/jHHIk5YjVYS2nFdzyniHHJz/bjGHH+jn5B", - "Pt4aZlI1AvNzLCGBrsuvOpye1sMzBPsgk7ZD6enxeFbUJKQaRoTkagkoAt7P1TzFpfujz7WSX/85M6x1", - "CJrOAjXnITiARJIgBBxneVrzG/mFuT3EjpPSg+Xm8AFUp28HlD2A9vPJzSwkYH12/iG9eOUqab2xyY9A", - "pcJ3J0h0CwXcnno5oSE4Ej9wAL9g5YOG6k5QHuEQnM9pkSby4FJ6hVgMA/iW0hntVCPLwX7gQHYOWbMT", - "xDpluuliVfZqDa4Y76VOHyOrCTeFvMXwtpikBYvROKYJKq9915Sl5TQcSVrkOWXCC/QKTTgWAW9nGG3N", - "GlvIewtkMSfgPT9G04BpJFssQ1A3zr7za8Gzt9a9NvJCdu7ejrbobjSVgrvxe4c6Xx+/7cDOgsaNagIw", - "SZjkWnqjMVfbs56J3QPGEv/uMgC+3XWvY1vLl+b1WNrdnltsxxq3Vri5Br69RDOAFOA+Qk3hYTwufNq3", - "OuFYqt39NuRJIALm+0mGSY+bUUWuc8gBlB+AnOFLnKK6uucYMpjv5zmjl71ulzUr4ACaT/wg7wFp20EI", - "DlNoNZ4LyLTW3mp6rXQ1X8sBlXqO8LINye1RXDAsFueSj2kUeYkgQ2y/0NQyUf96bTH31z/eRQMdjKi2", - "R7VWi50LkUc3N8prPdWCCQtJkTqMAeyfHkWOYRU9H+6aiBwCcxztRf8c7g5/igaRJFY1m5E675HyGoyu", - "5R9Hyc3IQOCja/O3E+VQulEIX3iUIaWGKVAcxJDYowZQX7lb93FURgdRcpRIkS8/0XaL6zGREyyvtPc+", - "XEcSh9WkI4sokZ5r5F4DClYgs3vQK0S9gGpLXAneJ90ZcfGSJsrBFlOps6sNgnmeqot0SkafjdVcgaqz", - "jY2yzNuUVL9slbuiftDXuWraP+3urrT83s7em9ad4XsbD6WwJgG8UAbBtEhTpde9uMOp1O+tPZN5CRMb", - "MzYAmFzCFCcmKCOBAg71hJ77hJq+YsB/o0R3+ufDzfo1ZRMVyKNHfvFwI9vDI1SAKS2IWvu/HvLEjoiQ", - "Zk8KOGKXiOkwhhqvVgzH5dIfPklKL2+7NdMCmmsBia3ALsuQpXVSf7Dr5dEnOcLIhCzvXUczJHzmtbRj", - "OYBpaqIEkNYUIJjhS0SUf77NRN8g8dLGQjf4pj9cVSpkU5wKxMBEefoVV/yrQGxRsUXZcWwiWsMsMUFT", - "qILktfsZEkoWGS2MK/niyMNePt2Sd9RZp92n210JtPFknwDVW9oz5RgVuTQPLqdenO6NeyVynSHBMJKi", - "M1WX2gKTWISxQX09Unu/o4X4BMZfpjhVWmhOtSOwji+ll5+/tH1bR+JZpO1cxRBv2e3q7HZTmF2JcOY0", - "TT6EDvWcVHhhOVmFNIaXzbAwEUJ92BkrCB+Az3Si/28C3PlAec9cO44DyDmNsZLtV1jMS3TXo3nZ35ty", - "Lj04YDO5QnFDJOK5wiFJYSGWqPsrpbNTyewRUFFxYDmRgyM9dpgblwDOdUz9yjMgngjplWdhPzzRYmHF", - "KZjANzOJEn9WnkWZ+LPi+LnEMRM4IShghtOGhsm1j8Ij6563gysCm15GaSjRJEfFJE6LRPmz1YS6Rj/H", - "f4dmsNt3CivJ+9a5Prp4/2zT8OoCvosrNvP3PL5fQQVMtcH3dnoKZ7VgRWdDe6kJuhHIBUJMJI33Z3ZB", - "jULf1Ny1TmFpy9UiDOOs83QntLObtQNeBSzMsDDQ+MDgueJ4SikeOIkoeiNsklY3R7cz6anaOplYDb7i", - "zO4BqKCLAa49Of39esz3W2d+d8t2YidOHKP+vKcVYn6vzOfccX2UJ5o4yGSoE2tG869bbUlnKP7Sqa5m", - "+gS4imZSZYTTEs6UwxkmSo2014omjylmlGuttLyY4m0m9DvmYj9Ntcq7hPucOsTlxOboVLD7obCTcjQ9", - "kqbpgpGSuALjpljryWtrFWuPbKh/PLExMC0WVoV/3C056zW3cOUYfsVZkTknp1fkrKMdRFuiXy+G0Aim", - "K5lA7k29OSgYQ0S4zNo7B8VCQmHgzdWUcethUCUX6oYnp9UNr5fKFKJMx53QZB6OpT+wCpex/4Mq1Mkm", - "+hhbzM7m1FW7UNncrrmtnTsMYZKgr2HfzpnuYLmWj4aa/FJ9IFmsvsiqOdSHj+niGW7owekNk/JDE5jU", - "pjmCLJ5jMht2np/udv/C61yNs5VdzZF/Q4sryhKVXqa2qFpvYEhzYivp21sJuZWQWwn5OBLSxjAs5bGS", - "8E1GtoQMAdf54HEZMd5ySpzoePt7iU34dM836r5TUHeXNiv9+7mEVssmTwL3m2gJJgtwdNiLAEaYcAH1", - "PWCIEAx9lU9jlM5B861a/wAgXAbw67w9oPyH5cyC4T1HGoyfbtZII7yzMCDvSxCxL7+m5iwDR1NAMyzU", - "8y7OdjhpDTYWPeTaqhK4HFEMhUSJaC/6v48fk//++HHo/PGPe/Cx3yL85qTEkzLq/nENhobo40U8168b", - "TWBSHowODR1+t0xuU00pa+64UYKS4ibIsiATLrqc3TF0idEVD5vGp5QrCX6mOt5jjGF9IyrlkAvIzKWL", - "k3brpHR67Q8BewUl3p0nfB1N4jD8cE1DggVVWGn429y1+yCWIJFcbnJMmhN0lgCN4jp7h3tkFiwzQpeT", - "iw3xddSDtv/bkQX8voNy23gvCq6U/erb3gZlK0y2GQB23Wl/14Nqvf6GKUw5Gty9Wb7qEj2La+HX78Z6", - "si4rUB7+Q8tDRXDGu/GgRL7ZxK0OSJ6OPRgvNTeCSZfF7NeNYK8xe//x9uHMble1Bz+eUCkpLi6ODp8F", - "FP1yVRtlVndoyv1lYqkCbOVeL0u4S+StSCQ3buxsR8isSuR1YiAfI0PlcXJT7upBkTXzSvyxUQsVd18m", - "WHuSQLY5F505Fy92//fhZvDqq4pjnwGdpaaPDskf+UbyHI1VwOEM+kFSxATEpMlxWpHRK/Gc0XVsv18i", - "sCta2njm44fkLHRjZHiDQW0Zzbea3FUS9wwJo0ksHAoHE8hRAigBWHCg08dD9F1dvHcaz6dVt4ewCWsv", - "yC2zCJ3ns6pZblg2z4aro7UIDAddnGP/dDPo1CerI1tfWeuJEn1Uref3NbDnpQX1yEiYqW4WFm5Tyu40", - "f1YjvzTd0FVFQyESqnPckTofqB/J8V5rHsxR/KV8e6J60cY+d6ReokgZgskCCPgFea4t35sxXPpcennp", - "GUlQYKcbug60fR9UIWo8E8T3y3iVdoALK5D7jke5g/aTAVCeUEDFHLErXHs5quM1tzZiXVjoZsukJsHK", - "DJ5NuFLMMOfSiqn2QT9vpI50M2/YLCbLI4QhYnCjlXpQ4HX5d2OwJOq5w7aQ088gdhCRx0ZwYN+SJF4E", - "3vhR69dT9kmeB9SXq+k86ecQ9DG76BXWhkK27WMhye5DqzxVls4W9Vbz/lbMqxkD1dS4Cw+O6dc6HhDN", - "Hl2bf3DUfgoP8qygzW+pcVVBYF7EgSvr9DWNYjSBJHwR8xKSjVQo9NuR4HzrHnzyMuclJDUc7sbWZjaq", - "P4iGv6bsYfD2aSaj3CJTZHm4C9/Id4qeGneveT5DeRjd/s7el1cbpnlV90MP50LtzNl4Co7T/o9xPWn/", - "ZVxwQbOuwMtu0VFLWOr2pNw7+QzuL5nJm32mso9CjphtKtLT8v7Uo7y9oiFsmD8x1H5MEfNAaYHfmDW/", - "5SZPy4WwjJusIFj7OxS+RQG7dUys4JigDDyBbIGGg+IHDgwnX4EmcsTUdWZXBtAbJE7Lbm/rZMKfKp3c", - "6lU4SF4lWHg9IL2edSiDrpzd30ZdrXAN5GxcvWyJ+6Ll7dzPHXlygbxS/fWq+TRPWZNtZwj09d3JvmtW", - "/bUV4Ma6Aty4rB3Xfo6w2oQPkVEgagOHgH1aK0Xh+S33bs394HhGkL+UqKqqq5ptHdEiN1VEUTPX2kRA", - "rfGm4wm6KuFYbH4SPqltoF4/bdxwNuPpWiHralXm2sxZXO4He1KctjOx4j40/7JGDqno8kfjanv2uL62", - "QDbSAyQ9Pn56gmcGKxnH9jTtWT5bIyly4C/gZQxvSlJdNLuqBgxJ4tTqtdWj6i9mtcZux9SuV+Tr2yPd", - "+3EdeitAb+t2bet2bet2tZyLftYmV+fytsbTPKsqOrfxr2x0DOzWI/LdeUSUjbgk17Fdmp9vNBr3S6ls", - "r2rV+CNv2frv67FNs+anKzfqOZ/eAzXU5qMzhTbgGBI4Q5lc79KsUA/WPcVwdR/x3Lc7rfQJesrRoKt0", - "UUZOeY9xTT+YPuEnFJO19X+tk6jqw5huOu8hVUfX6s9+mXQPzBj8tq+Z7907rfQGfucBYXoTvrGIsDVJ", - "x464w2MdweHN9z4t0tRIZqLqzdVeOFQ2XkxJUsQCWIBAAvRWzbDV+mGIshox8hkm+7OuamyD6OvOjO6Y", - "H1W5u8NCDxl+hjKDZQGX1d95bTxtHUMSqO2ydbp8A9V7LcoChbOKbPRV3w5kAk9hLLofRL5Qnfdt37u6", - "Etbn5VfEdFu9Bm9b8RpE8HI2vmQwC0C5RKqMJsxoQZS59f5s/1iav4nNy2eFq9E5FT10HUVd3NxXLXxS", - "xF+QKNu7i+nqzuBqjhhSP9BCSJQ2xYwZUhU/VQJNayD1/tA4pTM+nsV8rATtnr96o5gDQYEpOAnkJ0OA", - "ZkMw43ujkZ7DjpzWSDaFx2IFGU9TxXd946im2ibqstCsIAGYGRbjOeRz70aadqd0YHtIU6nQ9gmPIpmn", - "H4RsadR0NrPXD2/Kto/Rn3/++efO8fHO4eG7X37ZOz7eOz//98cI/PjT7vOfd57v7jzffbe7u6f++/cz", - "7zyKBLp39c3KNAl0KyG0Pkck6ViDrYZq1/GZTvQz9hcEf1UtXMAsl5D1ojRK//zCi+Gf6WSMEx8nbVZY", - "kIarGc83aQnIVAgfFxwFSFo5na7mtCoN3wUzg/EcE/3K8lIfzLHufK763gwi6sHct83q2g0u4JuEptKx", - "otKS+Dyw9xVGQcCRVAf0DZiEAcQclkV/OXhzcK6I9Ef+TNKpywMCdKq7DEINP/kmnSP4pYMnyua1GGLO", - "xqaWkh+uVLGMYGgVXXJmtxBzSsIUokCpPuWFYY+DyheCsni+FKzstApchnLqK4pSqyHs/bAgK9JWYAaq", - "IHIHS6gKJt8NU9DXG8sI7g9T4/2scJ5Pt4Xfe8pE293rT3GDs9QhlOyq3FtF5nXxUhcDLdFSF+rNCdf2", - "2uHELua38NfD/AZWsSk3c72Iscerw9soGRwjfGmYtdUX6wWhOmqNsapYwy0qk6sZlINz8KPLOp+BKaOZ", - "mp7VfN5g8UsxAbrIu1F4eddTjG+QuODmib17uvlW8D2b/fa3Vd+baNdne716nMgbJDxvjivlCKapfcFq", - "6Gye66Xq+abla8ruYlu3T1tu+tOWtYtEwwWDd4i9qoqYqtpLCos0fCJl7E6nvxJ9zVMVjaw9kg9eWETK", - "hUUqf5DkF91jnZFtkf9bS9LbVRgtp9+zaGrlkiw3BtiemIPnu7vD21YydbyeD1jRdBC5VH8H9Wt6qDEb", - "W9Fmc0vL1BFEs3NOMyQ1LWGKSAeinKwyrZ/jHF3bf5+pfy95tv6PWudeF1ZN+BvzyJ/WOn+lE7MY/5vx", - "GW4o0Q94f2SGf3o1XYzfTr/td6P1XQlAI0nB0mgvmguR873RCOZ4qPySQ8pm0c2nm/8PAAD//1J3+b7O", - "wQAA", + "H4sIAAAAAAAC/+x9fW/bttb4VyH8u8BW/Bw73e29eJD/0mTtsi1pkDQddtc+vrRE22wlUiOppF6Q7/6A", + "bxIlkbLkvNmdgWFtTerw7bzzHJ7bQUTTjBJEBB8c3A54tEApVH89jASm5Gc6vUA8T4T8KWM0Q0xgpDpA", + "1WHymU4nOJY/xIhHDGfy18HB4CRGROAZRgzQGRALBD7TKRALzAFTEMEUJZTMORB0MByIZYYGBwMuGCbz", + "wd3Qgmc56Qie5aQP+FwsKGvCfb9AQLdZuBFNUyy8MK7nk2sG0wCUa8TgHIEPF4enIOcoBtOl3YcSGiYC", + "zRGT4KYMkmgxITBFTYhnMEXFSlGCriERYI4F0F/5phfRdLZUGzhL4Jz7Z6k6qb1TnUbgx9F8BP67t5fQ", + "mz25uP8GQKdYTBaQL/xgZcvqDTRgfOcrgZwcdwaRIs7hHPnhmMbOwAROA5CuCP4KZDMXMM3AzQIRByS4", + "gRykMEaD4WBGWQqFPuB/v/Ked5THcHKNGFfw68MdXR0fAtOq0Mc3YUTiltkiEqvJugQIOYC1ZYy6TXeO", + "xYShjPrHki0cC8qWQCGwZ7K+Y74i+M8cAVxS84yyYrKakt3p5Tn2boTkQoLh+RyxSc5RgLBlC7hZUGC6", + "otgONfIBTWG0wARNuICaPf6DodngYPD/xiXXHBuWOT7VnS9V37vhQLJKKDCZT/iSC+RhEu9sD6B7BE85", + "Q/BLC6ORzd25TMYmJE+noS3K8iQBDP2ZIy6A6eib0lIsKAlj7/nyPWXRYiUCZ0sh+90fEBeQtVGuan9A", + "apA4ka9Eit8o+zJL6M1FTi71B+pTKgXDZIYTtArApe77Rna9Gw5uDLwOQsJ2bW7WXfELnX5GkZCAj6QY", + "OKMxasr5CAo0p2zpId4TYBslK2RIDUxojADmIMFcoHiokVJS9ZzRPJPoLnvwUVhkyfZJP24hP/EBjFHG", + "kJykT4UgMZZNHOBZZeblRyNwXPxdTxtAhsACxzEiAGvmf3XirGVKaYIg0WM7o9UHf80wmgHnN3tucpTv", + "OJjlRClAMMFiCSgDWc4yypF329DXDDGcIiJg0mOd7mdDwHOFDUBQEC0gmSMuh2Uopdcw8a/QTrIdExER", + "bLmXUUxEsSw5CvqKolyUSONdGiZZLibyZ48Cc4xmmMh1yU4ggwymSCDGfYBoLiQkzCcSMT0HopcFrmGS", + "K5Bq0yS64hlAMFoADUFuHFTILeeLBUrVxJqbY36BjMGl/DdDImdEUS73bxi3O6ZH4gq7owQyiQKYFCTN", + "fSOXKw0MHNjDywxFkpa4Gll1ktOwU8gYjfOoFCuBg/LxlB8Z0xp2lZ/ESECccJ881AgPdA8UA0w0J5YI", + "A6c0FxqfJFyJmwtMzCYxxGlyrQ5L9NucoOJ4CKIEQQYgiUFESYQ58pGrmkyfDblAPKOEexgtsvvVVETK", + "STaHkcIaM8ng/jAgyg8+eWbxFosjpa5e5mkKNV+vWXYPYBu1GjMSkO7gyI2mDv3IZkd4bsThXmEwWgWY", + "8HIbYRxjjcPnlQ31iKUqqqUwU0RX1wgFBXoUkEHs8rXyOAvFxb+UfsZKDAXaU0pUJ4Su6LxNxSHLJxHM", + "YISFR3l4TwVMwNH5FaB6Wkbb9kqBGPMvK2HJTsB26gJ1nuUT/aNv596eXyl2OAJoPgJnH06OTw7Be8QT", + "CH75n32/rMICw2QSZblPCqtGtWJ4DXECpwkCUzSjBv+lPqq0VD5qAy5XGYau9uA+4L1WhoUubYx1gFtD", + "arXW2nZcKUopW65EA92ty/lTHrY7JAY0yNH01hhxNc2JyMGvmORfwQ/7o/1XXgMHZ5MZQ+ivAJZlOAO6", + "3YhcHxBp+ynbZsIRwz4p/l4aNrpRbqWxBuHcXbilWx8l+1X/UhA0eWjQKlBeJWsWOEqtn7CrOnKznd6Q", + "hMI44L3SBqocpegYGNIx3XDkO/Cri18lu3VUcNlv1NWRodwLDfNk1fITqZYLFwvbjEF5SB9MV/kxjpBR", + "JDx4BcXCrufXk6Mfzy5/BNLgtEaLWWPptvHOLywiY8yzBC4rojK4zCyfJpgvtM+hbYXnRUep2Cjaa3eu", + "Gvr0T8C4L5SOZJfZ5eBXbEo3018elmvzK11Ba7ZBD4UU9LrLyi0VxqPbVdMNEf1lsRhE8lTqkOWvh5HA", + "11IVKH86RgkSygNT/vYaEoJiR9cs5+BibFM/UFZmQj1HbFRTuQvWFpWqikZezC0jbnch8DaVrO3oSmeI", + "b9cihqBA8aEIEAYUSBkNytckz9C6rqTCZT4edVS6lAMDkRiRyMv2D5UhKrdJyhG3L7BmQd1w624a9fCd", + "lEdS85/4HSOGV18xDyn88U6b2e9IsvwEDHHaL6pDOTQSZtP3IF+DuQ0qZgjykM6g2wq/lCFqjcReQm7V", + "QIpNLUTKEMxoktAbpZWgFBKBI9sNk/kInOZcgGkhjFwHWUcztbn0GneoNFaYRKWlyisqTYZleFrOEYnl", + "zDxNbxI4n69mNFeZJKgL7cLuxXWU5mKbjbE/lRvtUrHhR6O+3sbfFkgsEKvAWkkrvuM5R4xLfnYYRYjz", + "9/QL8vHWMJOqEJifYwkJdF1+1eL0tB6eETgEqbQdCk+Px7OiJiHVMCIkV4tBHvB+9vMUF+6PLtdKfv3n", + "wrDWEag7C9ScR+AIEkmCEHCcZknFb+QX5vYQW05KD5aZwwdQnb4dUPYA2s8nNzOXgPXZ+Yf04pWrpHXG", + "Jj8CFQrfgyDRPRRwe+rFhEbgRHzHAfyClQ8aqjtBeYQjcLmgeRLLg0voDWIRDOBbQue0VY0sBvuOA9k5", + "ZM1OEWuV6aaLVdnLNbhivJM6fYqsJlwX8hbDm2KS5ixCk4jGqLj2XVOWFtNwJGmeZZQJL9AbNOVYBLyd", + "YbQ1a2wg7z2QxZyA9/wYTQKmkWyxDEHdOPvOrwHP3lp32sgr2bl9O5qiu9ZUCO7a7y3qfHX8pgM7DRo3", + "qgnAOGaSa+mNxlxtz3omdgcYK/y7qwD4dte9jm0sX5rXE2l3e26xHWvcWuHmGvj+Es0AUoC7CDWFh9Ek", + "92nf6oQjqXZ325CtQATMD+MUkw43o4pcF5ADKD8AGcPXOEFVdc8xZDA/zDJGrzvdLmtWwAE0n/hBPgLS", + "NoMQHKbQaLwUkGmtvdH0RulqvpYjKvUc4WUbktujKGdYLC8lH9Mo8hpBhthhrqllqv71xmLuz7+9Hwx1", + "MKLaHtVaLnYhRDa4u1Ne65kWTFhIitRhDODw/GTgGFaDl6N9E5FDYIYHB4N/jvZHPwyGA0msajZjdd5j", + "5TUY38o/TuK7sYHAx7fmb2fKoXSnED73KENKDVOgOIggsUcNoL5yt+7jQREdRMlJLEW+/ETbLa7HRE6w", + "uNI++ON2IHFYTXpgEWWg5zpwrwEFy5HZPegVol5AlSX2gvdJd0ZcvKaxcrBFVOrsaoNgliXqIp2S8Wdj", + "NZegqmxjoyzzJiVVL1vlrqgf9HWumvYP+/u9lt/Z2XvXuDP8YOOhFNbEgOfKIJjlSaL0ulcPOJXqvbVn", + "Mq9hbGPGhgCTa5jg2ARlxFDAkZ7QS59Q01cM+C8U607/fLpZv6FsqgJ59Mivnm5ke3iECjCjOVFr/9dT", + "ntgJEdLsSQBH7BoxHcZQ4dWK4bhc+o9PktKL227NtIDmWkBiK7DLMmRpndR/2PXywSc5wtiELB/cDuZI", + "+MxracdyAJPERAkgrSlAMMfXiCj/fJOJvkXitY2FrvFNf7iqVMhmOBGIgany9Cuu+GeO2LJki7LjxES0", + "hllijGZQBclr9zMklCxTmhtX8tWJh718uifvqLJOu0/3uxJo4skhAaq3tGeKMUpyqR9cRr043Rn3CuS6", + "QIJhJEVnoi61BSaRCGOD+nqs9n5PC/EpjL7McKK00IxqR2AVXwovP39t+/oFbg0jUvh1YlzOHgR4ud+8", + "cvSctWf37CzK4OQdH+/PxzeFixaYbE7TJFroGNJpiXCWRZbYaJjkHAsTetSFT7Kc8CH4TKf6/yZyng+V", + "W841EDmAnNMIK6XhBotFQUd6NC9ffVvMpQNrrWdtKDaLRLRQOCRJN8RrdX+lzbZqrx0iNUrWLidydKLH", + "DrP5AsClDtbvPQPiCb3uPQv74ZmWNz2nYCLqzCQK/Ok9iyKjqOf4mcQxE5EhKGCGhYeGybTzw8dDPSx0", + "2B7+oWSeHBWTKMlj5ShXE2ob/RL/1YeLD++tSDTO9dn1hs82v6+qObRxxXpioMepLKiAibYk383O4bwS", + "BelsaCf9QzcCuUCIiaTx7swuqKroK6CHVlYsbbnqiWGcVZ7uxIy2s3bAy0iIORYGGh8aPFccT2nbQyfD", + "RW+Ezf5q5+h2Jh11ZifFq8ZXnNk9ARW0McC1J6e/X4/5fuvM72HZTuQEoGPUnfc0YtcflflcOj6V4kRj", + "B5kMdWLNaP51ry1pjfFfOdV+NlWAq2gmVYROreBMGZxjotRIe19pEqQiRrnWSosbL95kQr9iLg6TRKu8", + "K7jPuUNcTtCPzjF7HAo7K0bTI2mazhkpiCswboK1nry2VrH2yIb6J1MbXNNgYWVcycOSs15zA1dO4Vec", + "5qlzcnpFzjqa0bkF+nViCLUovYIJZN6cnqOcMUSEy6y9c1AsJBRfXl9NERAfBlVwoXZ4clrt8DqpTCHK", + "dNwJdebhWPpDq3AZ+z+oQp1tovOywexssl65C6XN7Zrb2mvEECYx+hp2Gl3oDpZr+Wiozi/VB5LF6huy", + "iqd+9JwuntGGHpzeMCk/NIFJbZojyKIFJvNR6/npbo8vvC7VODvZVR/5F7S8oSxWeWtqi8r1BoY0J9ZL", + "395JyJ2E3EnI55GQNjhiJY+VhG9SvSVkCLhONI+KUPSGU+JM36o8StDDp0e+qvedgroUtenuf5/bbbVs", + "shW4X0dLMF2Ck+NOBDDGhAuoLxhDhGDoq3hzo3AOmm/V+ocA4SIzQCcEAuU/LGYWjBs60WD8dLNGfuKD", + "xRd5n5iIfIk7FWcZOJkBmmKh3o1xtsPJl7BB7iHXVpkZ5ohiKCRKDA4G//vxY/z/P34cOX/84xF87PeI", + "6zkr8KQI539eg6Em+ngeLfSzSVMYFwejY05Hf1smt6mmlDV33PBDSXFTZFmQiUNdze4YusbohodN43PK", + "lQS/UB0fMXixuhGlcsgFZObSxcnndXJFvfaHgJ2iHR/OE76OJnEcfhGnJsGCKqw0/G1S3GMQS5BIrjc5", + "2M2JZouBRnGdFsQ9MgsWqaarycXGDjvqQdP/7cgC/tjRvk28FzlXyn75bWeDshF/W48su221v6vRul5/", + "wwwmHA0f3izvu0TP4hr49auxnqzLChSH/9TyUBGc8W48KZFvNnGrA5KnYw/GS821KNVVyQBVI9hrzD5+", + "IH84ZdxV7cH3Z1RKiqurk+MXAUW/WNVGmdUtmnJ3mVioADu518kSbhN5PYnkzg3KbYnFVRnCTgzkc6S+", + "PE/Sy0O9VLJmwoo/NmqpAvqLzG1PdskumWMrkjkKOtcnCRxq1K+LIiYgJnUqb0Qj96Lz8W1kv18hJEv8", + "3XiC90NyFroxcrPGFHbE/c0T9xwJI72XDoWDKeQoBpQALDjQueAh+i4vu1sN1vOy21PYYZXn4FZZYc5b", + "WOUsNyyDZsNVwErUg4MuzrF/uhu26nDlka2vIHVEiS7qzcvHGtjzbIJ6MSTMVDcLC3dpXA+aDKuRX5pL", + "6KakoRAJVTnuWJ0P1C/eeK8SjxYo+lI8JFE+T2PfLlLPSiQMwXgJBPyCPFeFH8wYLn2uvDD0jCQosNMN", + "XcHZvk+qENXe/OGHRYxIM6iE5ch9lKPYQfvJECjvI6BigdgNrjwD1fI0WxOxrix0s2VSk2BF1swmXOOl", + "mHNM5s4+6LeK1JFu5q2WxWR5hDBEDG6EUAcKvC3+bgyWWL1d2BRy+k3DFiLy2AgO7HuSxKvAgz1q/XrK", + "PsnzhPpyOZ2tfttAH7OLXmFtKGTbPheS7D+1ylNmxuxQr5/HtWRe9bijusade3BMP73xhGj27Nr8k6P2", + "Nryu00Ob31FjX0FgnreBvXX6ikYxnkISvvx4DclGKhT6IUhwuXMPbr3MeQ1JBYfbsbWeAeoPXOFvKHsa", + "vN3OBJB7ZGesDjHhG/k20LZx94rnM5T70O7v7Hx5tWGaV3k/9HQu1NY8iW1wnHZ/AGur/ZdRzgVN24Id", + "20VHJUmo3ZPy6OQzfLwEIm/Gl8r4CTliduk/2+X9qUZWe0VD2DDfMtR+ThHzRKl435g1v+Mm2+VCWMVN", + "egjW7g6Fb1HA7hwTPRwTlIEtiNCvOSi+48Bw8h40kSGmrjPbsm7eInFedHtXJRO+rXRyr5fYIPkxxsLr", + "Aen0lEIRdOXs/i7qqsc1kLNx1Rok7iuS93M/t+SmBXI59dd9c1i2WZNtRuV39d3JvmuW8LXl3Ca6nNuk", + "KATXXubfKBCVgUPAPq2VFvDynnu35n5wPCfIXxdUlchVzbYoaJ6ZkqCont9sIqDWeEfxDN0UcCw2b4VP", + "aheo100bN5zNeLp6ZDr1Za71PMHVfrCt4rStiRWPofkXBW9ISZffG1fbi+f1tXmTBJ4k0fD50xM8M+hl", + "HNvTtGf5Yo1ExKG/GpcxvClJdAXssrQvJLFTeNeWgqq+UtUYuxlTu17Frm+PdB/Hdegt57wrwrUrwrUr", + "wtVwLvpZm1ydy9tqz+H0VXTu41/Z6BjYnUfkb+cRUTbiilzHZp19vtFo3C2lsrmqvvFH3hr0f68HLs2a", + "t1duVHM+vQdqqM1HZwptwCkkcI5Sud6VWaEerNvGcHUf8Ty2O63wCXpKwKCbZFlETnmPcU0/mD7hLYrJ", + "2vm/1klU9WFMO513kKrjW/Vnt0y6J2YMftvXzPfhnVZ6A//mAWF6E76xiLA1SceOuMcjHcHhzfc+z5PE", + "SGaiarxVXhVUNl5ESZxHAliAQAL0Vqqwpfch6VjfFpPDeVsFtOHg696c7pkfVYm541wPGX76MYVF0ZT+", + "b6vWnpOOIAnUU9k5Xb6BirkWZYHCWUU2+qpvDzKBZzAS7Y8QX6nOh7bvQ10J6/PyK2K6rVr3tql4DQfw", + "ej65ZjANQLlGqnQlTGlOlLn14eLwVJq/sc3LZ7mr0TlVNHTtQl2p3Ff6e5pHX5Ao2tsL2OrO4GaBGFI/", + "0FxIlDYFhBlSVTZVAk1jIPX+0CShcz6ZR3yiBO2Bv2KiWABBgSnyCOQnI4DmIzDnB+OxnsOenNZYNoXH", + "YjmZzBLFd33jqKbKJupSzCwnAZgpFpMF5AvvRpp2p1xfc0hTHdD2CY8imacfhGyp1VE2s9ePXcq2j4Pf", + "f//9973T073j4/c//XRwenpwefmfjwPw/Q/7L/+993J/7+X++/39A/Xff15455HH0L2rr1eDiaFbfaDx", + "OSJxyxpsBVK7js90qp+OvyL4q2rhAqaZhKwXpVH636+8GP6ZTic49nHSelUDabia8XyTloBMVe5JzlGA", + "pJXT6WZBy3LsbTBTGC0w0S8br/TBnOrOl6rv3XBAPZj7rl7RusYFfJPQVDpRVFoQnwf2ocIoCDiS6oC+", + "AZMwgFjAotAuB2+PLhWRfs9fSDp1eUCATnWXYajhB9+kMwS/tPBE2bwWQ8zYxNQv8sOVKpYRDI1CR87s", + "lmJBSZhCFCjVp7gw7HBQ2VJQFi1WgpWd+sBlKKO+QiSVur3eD3PSk7YCM1BFiFtYQlmk+GGYgr7eWEVw", + "v5m66he582S5LbbeUSba7l5/ihucpQ6hYFfF3ioyr4qXqhhoiJaqUK9PuLLXDid2Mb+Bvx7mN7SKTbGZ", + "60WMPV/t21qZ3gjha8Osrb5YLcLUUt+LlQUS7lENXM2gGJyD713W+QLMGE11KX6j+bzF4qd8CnRhdaPw", + "8ranGN8iccXNE3uPdPOt4Hs2+90vfd+baNZEe9M/TuQtEp53vpVyBJPEvmA1cjbP9VJ1fNPyDWUPsa27", + "py03/WnLykWi4YLBO8ROlTxMJesVxTxqPpEidqfVX4m+ZomKRtYeyScv5iHlwjKRP0jyGzxibY9dYf17", + "S9L7VfUspt+xUGnpkiw2BtiemIOX+/uj+1YPdbyeT1hFdDhwqf4BasZ0UGM2torM5pZzqSKIZuecpkhq", + "WsIUbg5EOVllWj/HOb61/75Q/17xbP1vlc6dLqzq8DfmkT+tdf5Mp2Yx/jfjU1xTop/w/sgMv311VIzf", + "Tr/td6f1XQlAI0nOksHBYCFExg/GY5jhkfJLjiibD+4+3f1fAAAA///sQAgpm8EAAA==", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/infrastructure/modules/node-pack-extract-trigger/main.tf b/infrastructure/modules/node-pack-extract-trigger/main.tf index 9144ef3..89587e5 100644 --- a/infrastructure/modules/node-pack-extract-trigger/main.tf +++ b/infrastructure/modules/node-pack-extract-trigger/main.tf @@ -88,7 +88,8 @@ resource "google_cloud_scheduler_job" "backfill" { http_target { http_method = "POST" - uri = "${var.registry_backend_url}/comfy-nodes/backfill" + uri = "${var.registry_backend_url}/comfy-nodes/backfill?max_node=${var.backfill_job_max_node}" + oidc_token { service_account_email = data.google_service_account.cloudbuild_service_account.email diff --git a/infrastructure/modules/node-pack-extract-trigger/variable.tf b/infrastructure/modules/node-pack-extract-trigger/variable.tf index d271009..99ae377 100644 --- a/infrastructure/modules/node-pack-extract-trigger/variable.tf +++ b/infrastructure/modules/node-pack-extract-trigger/variable.tf @@ -45,6 +45,12 @@ variable "backfill_job_schedule" { default = "30 3 29 2 *" } +variable "backfill_job_max_node" { + type = number + default = 10 + description = "maximum number of nodes to be backfilled" +} + variable "git_repo_uri" { type = string description = "Connected git repo containing the cloud build pipeline. See https://cloud.google.com/build/docs/repositories" diff --git a/integration-tests/registry_integration_test.go b/integration-tests/registry_integration_test.go index caffa77..02c30b2 100644 --- a/integration-tests/registry_integration_test.go +++ b/integration-tests/registry_integration_test.go @@ -900,6 +900,9 @@ func TestRegistryComfyNode(t *testing.T) { nodeVersionToBeBackfill := []*drip.NodeVersion{ randomNodeVersion(1), randomNodeVersion(2), + randomNodeVersion(3), + randomNodeVersion(4), + randomNodeVersion(5), } for _, nv := range nodeVersionToBeBackfill { _, err = withMiddleware(authz, impl.PublishNodeVersion)(ctx, drip.PublishNodeVersionRequestObject{ @@ -976,17 +979,6 @@ func TestRegistryComfyNode(t *testing.T) { } }) - t.Run("Conflict", func(t *testing.T) { - body := drip.CreateComfyNodesJSONRequestBody(comfyNodes) - res, err := withMiddleware(authz, impl.CreateComfyNodes)(ctx, drip.CreateComfyNodesRequestObject{ - NodeId: *node.Id, - Version: *nodeVersion.Version, - Body: &body, - }) - require.NoError(t, err) - require.IsType(t, drip.CreateComfyNodes409JSONResponse{}, res) - }) - t.Run("GetNodeVersion", func(t *testing.T) { res, err := withMiddleware(authz, impl.GetNodeVersion)(ctx, drip.GetNodeVersionRequestObject{ NodeId: *node.Id, @@ -1044,10 +1036,25 @@ func TestRegistryComfyNode(t *testing.T) { }) t.Run("TriggerBackfill", func(t *testing.T) { - impl.mockPubsubService.On("PublishNodePack", mock.Anything, mock.Anything).Return(nil) - res, err := withMiddleware(authz, impl.ComfyNodesBackfill)(ctx, drip.ComfyNodesBackfillRequestObject{}) - require.NoError(t, err, "should return created node version") - require.IsType(t, drip.ComfyNodesBackfill204Response{}, res) - impl.mockPubsubService.AssertNumberOfCalls(t, "PublishNodePack", len(nodeVersionToBeBackfill)) + mockCalled := 0 + t.Run("Unlimited", func(t *testing.T) { + impl.mockPubsubService.On("PublishNodePack", mock.Anything, mock.Anything).Return(nil) + res, err := withMiddleware(authz, impl.ComfyNodesBackfill)(ctx, drip.ComfyNodesBackfillRequestObject{}) + require.NoError(t, err, "should return created node version") + require.IsType(t, drip.ComfyNodesBackfill204Response{}, res) + impl.mockPubsubService.AssertNumberOfCalls(t, "PublishNodePack", len(nodeVersionToBeBackfill)+mockCalled) + mockCalled += len(nodeVersionToBeBackfill) + }) + + t.Run("Limited", func(t *testing.T) { + limit := 2 + impl.mockPubsubService.On("PublishNodePack", mock.Anything, mock.Anything).Return(nil) + res, err := withMiddleware(authz, impl.ComfyNodesBackfill)(ctx, drip.ComfyNodesBackfillRequestObject{Params: drip.ComfyNodesBackfillParams{MaxNode: &limit}}) + require.NoError(t, err, "should return created node version") + require.IsType(t, drip.ComfyNodesBackfill204Response{}, res) + impl.mockPubsubService.AssertNumberOfCalls(t, "PublishNodePack", limit+mockCalled) + mockCalled += limit + }) }) + } diff --git a/node-pack-extract/cloudbuild.yaml b/node-pack-extract/cloudbuild.yaml index 4df866f..7c156ea 100644 --- a/node-pack-extract/cloudbuild.yaml +++ b/node-pack-extract/cloudbuild.yaml @@ -27,8 +27,8 @@ steps: - -c - gcloud auth print-identity-token --audiences="$_REGISTRY_BACKEND_URL" | tee /workspace/token - - name: "gcr.io/cloud-builders/curl" - entrypoint: "bash" + - name: "curlimages/curl" + entrypoint: "sh" args: - -c - | diff --git a/node-pack-extract/test/trigger_test.go b/node-pack-extract/test/trigger_test.go index 07f8032..8c813e3 100644 --- a/node-pack-extract/test/trigger_test.go +++ b/node-pack-extract/test/trigger_test.go @@ -81,7 +81,7 @@ func TestApply(t *testing.T) { require.NoError(t, err) h := j.GetHttpTarget() require.NotNil(t, h) - assert.Contains(t, h.GetUri(), "/comfy-nodes/backfill") + assert.Equal(t, h.GetUri(), "https://stagingapi.comfy.org/comfy-nodes/backfill?max_node=10") assert.Equal(t, http.MethodPost, h.GetHttpMethod().String()) assert.Equal(t, "https://stagingapi.comfy.org", h.GetOidcToken().GetAudience()) assert.Equal(t, serviceAccount, h.GetOidcToken().GetServiceAccountEmail()) diff --git a/openapi.yml b/openapi.yml index df240cd..5b7f01e 100644 --- a/openapi.yml +++ b/openapi.yml @@ -1803,12 +1803,6 @@ paths: application/json: schema: $ref: '#/components/schemas/ErrorResponse' - '409': - description: Existing Comfy Nodes exists - content: - application/json: - schema: - $ref: '#/components/schemas/ErrorResponse' '500': description: Internal server error content: @@ -1870,6 +1864,13 @@ paths: operationId: ComfyNodesBackfill tags: - ComfyNodes + parameters: + - in: query + name: max_node + required: false + schema: + type: integer + default: 10 responses: '204': description: Backfill triggered diff --git a/server/implementation/registry.go b/server/implementation/registry.go index d448102..0519b63 100644 --- a/server/implementation/registry.go +++ b/server/implementation/registry.go @@ -2,7 +2,6 @@ package implementation import ( "context" - "errors" "registry-backend/drip" "registry-backend/ent" "registry-backend/ent/publisher" @@ -727,12 +726,6 @@ func (s *DripStrictServerImplementation) InstallNode( // Install node version if request.Params.Version == nil { - s.MixpanelService.Track(ctx, []*mixpanel.Event{ - s.MixpanelService.NewEvent("Install Node", "", map[string]any{ - "Node ID": request.NodeId, - "Version": "latest", - }), - }) nodeVersion, err := s.RegistryService.GetLatestNodeVersion(ctx, s.Client, request.NodeId) if err == nil && nodeVersion == nil { log.Ctx(ctx).Error().Msgf("Latest node version not found") @@ -743,19 +736,22 @@ func (s *DripStrictServerImplementation) InstallNode( log.Ctx(ctx).Error().Msgf("Error retrieving latest node version w/ err: %v", err) return drip.InstallNode500JSONResponse{Message: errMessage}, err } - - _, err = s.RegistryService.RecordNodeInstallation(ctx, s.Client, node) + _, err = s.RegistryService.RecordNodeInstalation(ctx, s.Client, node) if err != nil { errMessage := "Failed to get increment number of node version install: " + err.Error() log.Ctx(ctx).Error().Msgf("Error incrementing number of latest node version install w/ err: %v", err) return drip.InstallNode500JSONResponse{Message: errMessage}, err } - + s.MixpanelService.Track(ctx, []*mixpanel.Event{ + s.MixpanelService.NewEvent("Install Node Latest", "", map[string]any{ + "Node ID": request.NodeId, + "Version": nodeVersion.Version, + }), + }) return drip.InstallNode200JSONResponse( *mapper.DbNodeVersionToApiNodeVersion(nodeVersion), ), nil } else { - nodeVersion, err := s.RegistryService.GetNodeVersionByVersion(ctx, s.Client, request.NodeId, *request.Params.Version) if ent.IsNotFound(err) { log.Ctx(ctx).Error().Msgf("Error retrieving node version w/ err: %v", err) @@ -766,18 +762,18 @@ func (s *DripStrictServerImplementation) InstallNode( log.Ctx(ctx).Error().Msgf("Error retrieving node version w/ err: %v", err) return drip.InstallNode500JSONResponse{Message: errMessage}, err } - s.MixpanelService.Track(ctx, []*mixpanel.Event{ - s.MixpanelService.NewEvent("Install Node", "", map[string]any{ - "Node ID": request.NodeId, - "Version": request.Params.Version, - }), - }) - _, err = s.RegistryService.RecordNodeInstallation(ctx, s.Client, node) + _, err = s.RegistryService.RecordNodeInstalation(ctx, s.Client, node) if err != nil { errMessage := "Failed to get increment number of node version install: " + err.Error() log.Ctx(ctx).Error().Msgf("Error incrementing number of latest node version install w/ err: %v", err) return drip.InstallNode500JSONResponse{Message: errMessage}, err } + s.MixpanelService.Track(ctx, []*mixpanel.Event{ + s.MixpanelService.NewEvent("Install Node", "", map[string]any{ + "Node ID": request.NodeId, + "Version": nodeVersion.Version, + }), + }) return drip.InstallNode200JSONResponse( *mapper.DbNodeVersionToApiNodeVersion(nodeVersion), ), nil @@ -1027,10 +1023,6 @@ func (impl *DripStrictServerImplementation) CreateComfyNodes(ctx context.Context log.Ctx(ctx).Error().Msgf("Node or node version not found w/ err: %v", err) return drip.CreateComfyNodes404JSONResponse{Message: "Node or node version not found", Error: err.Error()}, nil } - if errors.Is(err, drip_services.ErrComfyNodesAlreadyExist) { - log.Ctx(ctx).Error().Msgf("Comfy nodes for %s %s exist", request.NodeId, request.Version) - return drip.CreateComfyNodes409JSONResponse{Message: "Comfy nodes already exist", Error: err.Error()}, nil - } if err != nil { log.Ctx(ctx).Error().Msgf("Failed to create comfy nodes w/ err: %v", err) return drip.CreateComfyNodes500JSONResponse{Message: "Failed to create comfy nodes", Error: err.Error()}, nil @@ -1063,7 +1055,7 @@ func (impl *DripStrictServerImplementation) GetComfyNode(ctx context.Context, re func (impl *DripStrictServerImplementation) ComfyNodesBackfill(ctx context.Context, request drip.ComfyNodesBackfillRequestObject) (drip.ComfyNodesBackfillResponseObject, error) { log.Ctx(ctx).Info().Msg("ComfyNodesBackfill request received") - err := impl.RegistryService.TriggerComfyNodesBackfill(ctx, impl.Client) + err := impl.RegistryService.TriggerComfyNodesBackfill(ctx, impl.Client, request.Params.MaxNode) if err != nil { log.Ctx(ctx).Error().Msgf("Failed to trigger comfy nodes backfill w/ err: %v", err) return drip.ComfyNodesBackfill500JSONResponse{Message: "Failed to trigger comfy nodes backfill", Error: err.Error()}, nil diff --git a/services/registry/registry_svc.go b/services/registry/registry_svc.go index 0f612cb..e87c920 100644 --- a/services/registry/registry_svc.go +++ b/services/registry/registry_svc.go @@ -585,7 +585,7 @@ func (s *RegistryService) UpdateNodeVersion(ctx context.Context, client *ent.Cli }) } -func (s *RegistryService) RecordNodeInstallation(ctx context.Context, client *ent.Client, node *ent.Node) (*ent.Node, error) { +func (s *RegistryService) RecordNodeInstalation(ctx context.Context, client *ent.Client, node *ent.Node) (*ent.Node, error) { var n *ent.Node err := db.WithTx(ctx, client, func(tx *ent.Tx) (err error) { node, err = tx.Node.UpdateOne(node).AddTotalInstall(1).Save(ctx) @@ -626,64 +626,52 @@ func (s *RegistryService) GetLatestNodeVersion(ctx context.Context, client *ent. return nodeVersion, nil } -var ErrComfyNodesAlreadyExist = errors.New("comfy nodes already exist") - func (s *RegistryService) CreateComfyNodes(ctx context.Context, client *ent.Client, nodeID string, nodeVersion string, comfyNodes map[string]drip.ComfyNode) (err error) { - return db.WithTx(ctx, client, func(tx *ent.Tx) error { - nv, err := client.NodeVersion.Query(). - Where(nodeversion.VersionEQ(nodeVersion)). - Where(nodeversion.NodeIDEQ(nodeID)). - WithComfyNodes(). - ForUpdate(). - Only(ctx) - if err != nil { - return err - } - - if len(nv.Edges.ComfyNodes) > 0 { - return ErrComfyNodesAlreadyExist - } + nv, err := client.NodeVersion.Query(). + Where(nodeversion.VersionEQ(nodeVersion)). + Where(nodeversion.NodeIDEQ(nodeID)).Only(ctx) + if err != nil { + return err + } - comfyNodesCreates := make([]*ent.ComfyNodeCreate, 0, len(comfyNodes)) - for k, n := range comfyNodes { - comfyNodeCreate := client.ComfyNode.Create(). - SetID(k). - SetNodeVersionID(nv.ID) + comfyNodesCreates := make([]*ent.ComfyNodeCreate, 0, len(comfyNodes)) + for k, n := range comfyNodes { + comfyNodeCreate := client.ComfyNode.Create(). + SetID(k). + SetNodeVersionID(nv.ID) - if n.Category != nil { - comfyNodeCreate.SetCategory(*n.Category) - } - if n.Description != nil { - comfyNodeCreate.SetDescription(*n.Description) - } - if n.InputTypes != nil { - comfyNodeCreate.SetInputTypes(*n.InputTypes) - } - if n.Deprecated != nil { - comfyNodeCreate.SetDeprecated(*n.Deprecated) - } - if n.Experimental != nil { - comfyNodeCreate.SetExperimental(*n.Experimental) - } - if n.OutputIsList != nil { - comfyNodeCreate.SetOutputIsList(*n.OutputIsList) - } - if n.ReturnNames != nil { - comfyNodeCreate.SetReturnNames(*n.ReturnNames) - } - if n.ReturnTypes != nil { - comfyNodeCreate.SetReturnTypes(*n.ReturnTypes) - } - if n.Function != nil { - comfyNodeCreate.SetFunction(*n.Function) - } - comfyNodesCreates = append(comfyNodesCreates, comfyNodeCreate) + if n.Category != nil { + comfyNodeCreate.SetCategory(*n.Category) } - return client.ComfyNode. - CreateBulk(comfyNodesCreates...). - Exec(ctx) - }) - + if n.Description != nil { + comfyNodeCreate.SetDescription(*n.Description) + } + if n.InputTypes != nil { + comfyNodeCreate.SetInputTypes(*n.InputTypes) + } + if n.Deprecated != nil { + comfyNodeCreate.SetDeprecated(*n.Deprecated) + } + if n.Experimental != nil { + comfyNodeCreate.SetExperimental(*n.Experimental) + } + if n.OutputIsList != nil { + comfyNodeCreate.SetOutputIsList(*n.OutputIsList) + } + if n.ReturnNames != nil { + comfyNodeCreate.SetReturnNames(*n.ReturnNames) + } + if n.ReturnTypes != nil { + comfyNodeCreate.SetReturnTypes(*n.ReturnTypes) + } + if n.Function != nil { + comfyNodeCreate.SetFunction(*n.Function) + } + comfyNodesCreates = append(comfyNodesCreates, comfyNodeCreate) + } + return client.ComfyNode. + CreateBulk(comfyNodesCreates...). + Exec(ctx) } func (s *RegistryService) GetComfyNode(ctx context.Context, client *ent.Client, nodeID string, nodeVersion string, comfyNodeID string) (*ent.ComfyNode, error) { @@ -700,12 +688,15 @@ func (s *RegistryService) GetComfyNode(ctx context.Context, client *ent.Client, return nv.Edges.ComfyNodes[0], nil } -func (s *RegistryService) TriggerComfyNodesBackfill(ctx context.Context, client *ent.Client) error { - nvs, err := client.NodeVersion. +func (s *RegistryService) TriggerComfyNodesBackfill(ctx context.Context, client *ent.Client, max *int) error { + q := client.NodeVersion. Query(). WithStorageFile(). - Where(nodeversion.Not(nodeversion.HasComfyNodes())). - All(ctx) + Where(nodeversion.Not(nodeversion.HasComfyNodes())) + if max != nil { + q.Limit(*max) + } + nvs, err := q.All(ctx) if err != nil { return fmt.Errorf("failed to query node versions: %w", err) }