shishantbiswas/coder
1
0
Fork 0
mirror of https://github.com/coder/coder.git synced 2026-06-02 20:48:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: Rename ProjectHistory to ProjectVersion (#165)

Browse Source 
* chore: Rename ProjectHistory to ProjectVersion

Version more accurately represents version storage. This
forks from the WorkspaceHistory name, but I think it's
easier to understand Workspace history.

* Rename files
This commit is contained in:
Kyle Carberry
2022-02-04 20:47:58 -06:00
committed by GitHub
parent 2b41ac697e
commit f19770b2c6
28 changed files with 609 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files
coderd/coderd.go
+8 -8
View File
@@ -66,13 +66,13 @@ func New(options *Options) http.Handler {
r.Get("/", api.parametersByProject)
r.Post("/", api.postParametersByProject)
})
r.Route("/history", func(r chi.Router) {
r.Get("/", api.projectHistoryByOrganization)
r.Post("/", api.postProjectHistoryByOrganization)
r.Route("/{projecthistory}", func(r chi.Router) {
r.Use(httpmw.ExtractProjectHistoryParam(api.Database))
r.Get("/", api.projectHistoryByOrganizationAndName)
r.Get("/parameters", api.projectHistoryParametersByOrganizationAndName)
r.Route("/versions", func(r chi.Router) {
r.Get("/", api.projectVersionsByOrganization)
r.Post("/", api.postProjectVersionByOrganization)
r.Route("/{projectversion}", func(r chi.Router) {
r.Use(httpmw.ExtractProjectVersionParam(api.Database))
r.Get("/", api.projectVersionByOrganizationAndName)
r.Get("/parameters", api.projectVersionParametersByOrganizationAndName)
})
})
})
@@ -91,7 +91,7 @@ func New(options *Options) http.Handler {
r.Route("/{workspace}", func(r chi.Router) {
r.Use(httpmw.ExtractWorkspaceParam(options.Database))
r.Get("/", api.workspaceByUser)
r.Route("/history", func(r chi.Router) {
r.Route("/version", func(r chi.Router) {
r.Post("/", api.postWorkspaceHistoryByUser)
r.Get("/", api.workspaceHistoryByUser)
r.Route("/{workspacehistory}", func(r chi.Router) {
coderd/projectparameter/projectparameter.go
+26 -26
View File
@@ -17,7 +17,7 @@ import (
type Scope struct {
OrganizationID string
ProjectID uuid.UUID
ProjectHistoryID uuid.UUID
ProjectVersionID uuid.UUID
UserID string
WorkspaceID uuid.UUID
WorkspaceHistoryID uuid.UUID
@@ -40,21 +40,21 @@ func Compute(ctx context.Context, db database.Store, scope Scope) ([]Value, erro
compute := &compute{
db: db,
computedParameterByName: map[string]Value{},
projectHistoryParametersByName: map[string]database.ProjectParameter{},
projectVersionParametersByName: map[string]database.ProjectParameter{},
}
// All parameters for the project version!
projectHistoryParameters, err := db.GetProjectParametersByHistoryID(ctx, scope.ProjectHistoryID)
projectVersionParameters, err := db.GetProjectParametersByVersionID(ctx, scope.ProjectVersionID)
if errors.Is(err, sql.ErrNoRows) {
// This occurs when the project history has defined
// This occurs when the project version has defined
// no parameters, so we have nothing to compute!
return []Value{}, nil
}
if err != nil {
return nil, xerrors.Errorf("get project parameters: %w", err)
}
for _, projectHistoryParameter := range projectHistoryParameters {
compute.projectHistoryParametersByName[projectHistoryParameter.Name] = projectHistoryParameter
for _, projectVersionParameter := range projectVersionParameters {
compute.projectVersionParametersByName[projectVersionParameter.Name] = projectVersionParameter
}
// Organization parameters come first!
@@ -67,33 +67,33 @@ func Compute(ctx context.Context, db database.Store, scope Scope) ([]Value, erro
}
// Default project parameter values come second!
for _, projectHistoryParameter := range projectHistoryParameters {
if !projectHistoryParameter.DefaultSourceValue.Valid {
for _, projectVersionParameter := range projectVersionParameters {
if !projectVersionParameter.DefaultSourceValue.Valid {
continue
}
if !projectHistoryParameter.DefaultDestinationValue.Valid {
if !projectVersionParameter.DefaultDestinationValue.Valid {
continue
}
destinationScheme, err := convertDestinationScheme(projectHistoryParameter.DefaultDestinationScheme)
destinationScheme, err := convertDestinationScheme(projectVersionParameter.DefaultDestinationScheme)
if err != nil {
return nil, xerrors.Errorf("convert default destination scheme for project history parameter %q: %w", projectHistoryParameter.Name, err)
return nil, xerrors.Errorf("convert default destination scheme for project version parameter %q: %w", projectVersionParameter.Name, err)
}
switch projectHistoryParameter.DefaultSourceScheme {
switch projectVersionParameter.DefaultSourceScheme {
case database.ParameterSourceSchemeData:
compute.computedParameterByName[projectHistoryParameter.Name] = Value{
compute.computedParameterByName[projectVersionParameter.Name] = Value{
Proto: &proto.ParameterValue{
DestinationScheme: destinationScheme,
Name: projectHistoryParameter.DefaultDestinationValue.String,
Value: projectHistoryParameter.DefaultSourceValue.String,
Name: projectVersionParameter.DefaultDestinationValue.String,
Value: projectVersionParameter.DefaultSourceValue.String,
},
DefaultValue: true,
Scope: database.ParameterScopeProject,
ScopeID: scope.ProjectID.String(),
}
default:
return nil, xerrors.Errorf("unsupported source scheme for project history parameter %q: %q", projectHistoryParameter.Name, string(projectHistoryParameter.DefaultSourceScheme))
return nil, xerrors.Errorf("unsupported source scheme for project version parameter %q: %q", projectVersionParameter.Name, string(projectVersionParameter.DefaultSourceScheme))
}
}
@@ -124,13 +124,13 @@ func Compute(ctx context.Context, db database.Store, scope Scope) ([]Value, erro
return nil, err
}
for _, projectHistoryParameter := range compute.projectHistoryParametersByName {
if _, ok := compute.computedParameterByName[projectHistoryParameter.Name]; ok {
for _, projectVersionParameter := range compute.projectVersionParametersByName {
if _, ok := compute.computedParameterByName[projectVersionParameter.Name]; ok {
continue
}
return nil, NoValueError{
ParameterID: projectHistoryParameter.ID,
ParameterName: projectHistoryParameter.Name,
ParameterID: projectVersionParameter.ID,
ParameterName: projectVersionParameter.Name,
}
}
@@ -144,7 +144,7 @@ func Compute(ctx context.Context, db database.Store, scope Scope) ([]Value, erro
type compute struct {
db database.Store
computedParameterByName map[string]Value
projectHistoryParametersByName map[string]database.ProjectParameter
projectVersionParametersByName map[string]database.ProjectParameter
}
// Validates and computes the value for parameters; setting the value on "parameterByName".
@@ -158,8 +158,8 @@ func (c *compute) inject(ctx context.Context, scopeParams database.GetParameterV
}
for _, scopedParameter := range scopedParameters {
projectHistoryParameter, hasProjectHistoryParameter := c.projectHistoryParametersByName[scopedParameter.Name]
if !hasProjectHistoryParameter {
projectVersionParameter, hasProjectVersionParameter := c.projectVersionParametersByName[scopedParameter.Name]
if !hasProjectVersionParameter {
// Don't inject parameters that aren't defined by the project.
continue
}
@@ -169,7 +169,7 @@ func (c *compute) inject(ctx context.Context, scopeParams database.GetParameterV
// If a parameter already exists, check if this variable can override it.
// Injection hierarchy is the responsibility of the caller. This check ensures
// project parameters cannot be overridden if already set.
if !projectHistoryParameter.AllowOverrideSource && scopedParameter.Scope != database.ParameterScopeProject {
if !projectVersionParameter.AllowOverrideSource && scopedParameter.Scope != database.ParameterScopeProject {
continue
}
}
@@ -181,7 +181,7 @@ func (c *compute) inject(ctx context.Context, scopeParams database.GetParameterV
switch scopedParameter.SourceScheme {
case database.ParameterSourceSchemeData:
c.computedParameterByName[projectHistoryParameter.Name] = Value{
c.computedParameterByName[projectVersionParameter.Name] = Value{
Proto: &proto.ParameterValue{
DestinationScheme: destinationScheme,
Name: scopedParameter.SourceValue,
@@ -189,7 +189,7 @@ func (c *compute) inject(ctx context.Context, scopeParams database.GetParameterV
},
}
default:
return xerrors.Errorf("unsupported source scheme: %q", string(projectHistoryParameter.DefaultSourceScheme))
return xerrors.Errorf("unsupported source scheme: %q", string(projectVersionParameter.DefaultSourceScheme))
}
}
return nil
coderd/projectparameter/projectparameter_test.go
+9 -9
View File
@@ -21,7 +21,7 @@ func TestCompute(t *testing.T) {
return projectparameter.Scope{
OrganizationID: uuid.New().String(),
ProjectID: uuid.New(),
ProjectHistoryID: uuid.New(),
ProjectVersionID: uuid.New(),
UserID: uuid.NewString(),
}
}
@@ -29,7 +29,7 @@ func TestCompute(t *testing.T) {
AllowOverrideSource bool
AllowOverrideDestination bool
DefaultDestinationScheme database.ParameterDestinationScheme
ProjectHistoryID uuid.UUID
ProjectVersionID uuid.UUID
}
generateProjectParameter := func(t *testing.T, db database.Store, opts projectParameterOptions) database.ProjectParameter {
if opts.DefaultDestinationScheme == "" {
@@ -44,7 +44,7 @@ func TestCompute(t *testing.T) {
param, err := db.InsertProjectParameter(context.Background(), database.InsertProjectParameterParams{
ID: uuid.New(),
Name: name,
ProjectHistoryID: opts.ProjectHistoryID,
ProjectVersionID: opts.ProjectVersionID,
DefaultSourceScheme: database.ParameterSourceSchemeData,
DefaultSourceValue: sql.NullString{
String: sourceValue,
@@ -68,7 +68,7 @@ func TestCompute(t *testing.T) {
scope := generateScope()
parameter, err := db.InsertProjectParameter(context.Background(), database.InsertProjectParameterParams{
ID: uuid.New(),
ProjectHistoryID: scope.ProjectHistoryID,
ProjectVersionID: scope.ProjectVersionID,
Name: "hey",
})
require.NoError(t, err)
@@ -85,7 +85,7 @@ func TestCompute(t *testing.T) {
db := databasefake.New()
scope := generateScope()
parameter := generateProjectParameter(t, db, projectParameterOptions{
ProjectHistoryID: scope.ProjectHistoryID,
ProjectVersionID: scope.ProjectVersionID,
DefaultDestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
})
values, err := projectparameter.Compute(context.Background(), db, scope)
@@ -105,7 +105,7 @@ func TestCompute(t *testing.T) {
db := databasefake.New()
scope := generateScope()
parameter := generateProjectParameter(t, db, projectParameterOptions{
ProjectHistoryID: scope.ProjectHistoryID,
ProjectVersionID: scope.ProjectVersionID,
})
_, err := db.InsertParameterValue(context.Background(), database.InsertParameterValueParams{
ID: uuid.New(),
@@ -131,7 +131,7 @@ func TestCompute(t *testing.T) {
db := databasefake.New()
scope := generateScope()
parameter := generateProjectParameter(t, db, projectParameterOptions{
ProjectHistoryID: scope.ProjectHistoryID,
ProjectVersionID: scope.ProjectVersionID,
})
value, err := db.InsertParameterValue(context.Background(), database.InsertParameterValueParams{
ID: uuid.New(),
@@ -157,7 +157,7 @@ func TestCompute(t *testing.T) {
db := databasefake.New()
scope := generateScope()
parameter := generateProjectParameter(t, db, projectParameterOptions{
ProjectHistoryID: scope.ProjectHistoryID,
ProjectVersionID: scope.ProjectVersionID,
})
_, err := db.InsertParameterValue(context.Background(), database.InsertParameterValueParams{
ID: uuid.New(),
@@ -183,7 +183,7 @@ func TestCompute(t *testing.T) {
scope := generateScope()
parameter := generateProjectParameter(t, db, projectParameterOptions{
AllowOverrideSource: true,
ProjectHistoryID: scope.ProjectHistoryID,
ProjectVersionID: scope.ProjectVersionID,
})
_, err := db.InsertParameterValue(context.Background(), database.InsertParameterValueParams{
ID: uuid.New(),
coderd/projects_test.go
+4 -4
View File
@@ -148,17 +148,17 @@ func TestProjects(t *testing.T) {
},
}}, nil)
require.NoError(t, err)
history, err := server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
version, err := server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: data,
})
require.NoError(t, err)
require.Eventually(t, func() bool {
projectHistory, err := server.Client.ProjectHistory(context.Background(), user.Organization, project.Name, history.Name)
projectVersion, err := server.Client.ProjectVersion(context.Background(), user.Organization, project.Name, version.Name)
require.NoError(t, err)
return projectHistory.Import.Status.Completed()
return projectVersion.Import.Status.Completed()
}, 15*time.Second, 10*time.Millisecond)
params, err := server.Client.ProjectHistoryParameters(context.Background(), user.Organization, project.Name, history.Name)
params, err := server.Client.ProjectVersionParameters(context.Background(), user.Organization, project.Name, version.Name)
require.NoError(t, err)
require.Len(t, params, 1)
require.Equal(t, "example", params[0].Name)
coderd/projecthistory.go → coderd/projectversion.go
+43 -43
View File
@@ -20,8 +20,8 @@ import (
"github.com/coder/coder/httpmw"
)
// ProjectHistory is the JSON representation of Coder project version history.
type ProjectHistory struct {
// ProjectVersion represents a single version of a project.
type ProjectVersion struct {
ID uuid.UUID `json:"id"`
ProjectID uuid.UUID `json:"project_id"`
CreatedAt time.Time `json:"created_at"`
@@ -31,11 +31,11 @@ type ProjectHistory struct {
Import ProvisionerJob `json:"import"`
}
// ProjectParameter represents a parameter parsed from project history source on creation.
// ProjectParameter represents a parameter parsed from project version source on creation.
type ProjectParameter struct {
ID uuid.UUID `json:"id"`
CreatedAt time.Time `json:"created_at"`
ProjectHistoryID uuid.UUID `json:"project_history_id"`
ProjectVersionID uuid.UUID `json:"project_version_id"`
Name string `json:"name"`
Description string `json:"description,omitempty"`
DefaultSourceScheme database.ParameterSourceScheme `json:"default_source_scheme,omitempty"`
@@ -52,28 +52,28 @@ type ProjectParameter struct {
ValidationValueType string `json:"validation_value_type,omitempty"`
}
// CreateProjectHistoryRequest enables callers to create a new Project Version.
type CreateProjectHistoryRequest struct {
// CreateProjectVersionRequest enables callers to create a new Project Version.
type CreateProjectVersionRequest struct {
StorageMethod database.ProjectStorageMethod `json:"storage_method" validate:"oneof=inline-archive,required"`
StorageSource []byte `json:"storage_source" validate:"max=1048576,required"`
}
// Lists history for a single project.
func (api *api) projectHistoryByOrganization(rw http.ResponseWriter, r *http.Request) {
// Lists versions for a single project.
func (api *api) projectVersionsByOrganization(rw http.ResponseWriter, r *http.Request) {
project := httpmw.ProjectParam(r)
history, err := api.Database.GetProjectHistoryByProjectID(r.Context(), project.ID)
version, err := api.Database.GetProjectVersionByProjectID(r.Context(), project.ID)
if errors.Is(err, sql.ErrNoRows) {
err = nil
}
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get project history: %s", err),
Message: fmt.Sprintf("get project version: %s", err),
})
return
}
apiHistory := make([]ProjectHistory, 0)
for _, version := range history {
apiVersion := make([]ProjectVersion, 0)
for _, version := range version {
job, err := api.Database.GetProvisionerJobByID(r.Context(), version.ImportJobID)
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
@@ -81,16 +81,16 @@ func (api *api) projectHistoryByOrganization(rw http.ResponseWriter, r *http.Req
})
return
}
apiHistory = append(apiHistory, convertProjectHistory(version, job))
apiVersion = append(apiVersion, convertProjectVersion(version, job))
}
render.Status(r, http.StatusOK)
render.JSON(rw, r, apiHistory)
render.JSON(rw, r, apiVersion)
}
// Return a single project history by organization and name.
func (api *api) projectHistoryByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
projectHistory := httpmw.ProjectHistoryParam(r)
job, err := api.Database.GetProvisionerJobByID(r.Context(), projectHistory.ImportJobID)
// Return a single project version by organization and name.
func (api *api) projectVersionByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
projectVersion := httpmw.ProjectVersionParam(r)
job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.ImportJobID)
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get provisioner job: %s", err),
@@ -98,14 +98,14 @@ func (api *api) projectHistoryByOrganizationAndName(rw http.ResponseWriter, r *h
return
}
render.Status(r, http.StatusOK)
render.JSON(rw, r, convertProjectHistory(projectHistory, job))
render.JSON(rw, r, convertProjectVersion(projectVersion, job))
}
// Creates a new version of the project. An import job is queued to parse
// the storage method provided. Once completed, the import job will specify
// the version as latest.
func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http.Request) {
var createProjectVersion CreateProjectHistoryRequest
func (api *api) postProjectVersionByOrganization(rw http.ResponseWriter, r *http.Request) {
var createProjectVersion CreateProjectVersionRequest
if !httpapi.Read(rw, r, &createProjectVersion) {
return
}
@@ -131,11 +131,11 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
project := httpmw.ProjectParam(r)
var provisionerJob database.ProvisionerJob
var projectHistory database.ProjectHistory
var projectVersion database.ProjectVersion
err := api.Database.InTx(func(db database.Store) error {
projectHistoryID := uuid.New()
projectVersionID := uuid.New()
input, err := json.Marshal(projectImportJob{
ProjectHistoryID: projectHistoryID,
ProjectVersionID: projectVersionID,
})
if err != nil {
return xerrors.Errorf("marshal import job: %w", err)
@@ -155,8 +155,8 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
return xerrors.Errorf("insert provisioner job: %w", err)
}
projectHistory, err = api.Database.InsertProjectHistory(r.Context(), database.InsertProjectHistoryParams{
ID: projectHistoryID,
projectVersion, err = api.Database.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
ID: projectVersionID,
ProjectID: project.ID,
CreatedAt: database.Now(),
UpdatedAt: database.Now(),
@@ -166,7 +166,7 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
ImportJobID: provisionerJob.ID,
})
if err != nil {
return xerrors.Errorf("insert project history: %s", err)
return xerrors.Errorf("insert project version: %s", err)
}
return nil
})
@@ -178,12 +178,12 @@ func (api *api) postProjectHistoryByOrganization(rw http.ResponseWriter, r *http
}
render.Status(r, http.StatusCreated)
render.JSON(rw, r, convertProjectHistory(projectHistory, provisionerJob))
render.JSON(rw, r, convertProjectVersion(projectVersion, provisionerJob))
}
func (api *api) projectHistoryParametersByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
projectHistory := httpmw.ProjectHistoryParam(r)
job, err := api.Database.GetProvisionerJobByID(r.Context(), projectHistory.ImportJobID)
func (api *api) projectVersionParametersByOrganizationAndName(rw http.ResponseWriter, r *http.Request) {
projectVersion := httpmw.ProjectVersionParam(r)
job, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.ImportJobID)
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get provisioner job: %s", err),
@@ -204,7 +204,7 @@ func (api *api) projectHistoryParametersByOrganizationAndName(rw http.ResponseWr
return
}
parameters, err := api.Database.GetProjectParametersByHistoryID(r.Context(), projectHistory.ID)
parameters, err := api.Database.GetProjectParametersByVersionID(r.Context(), projectVersion.ID)
if errors.Is(err, sql.ErrNoRows) {
err = nil
parameters = []database.ProjectParameter{}
@@ -225,14 +225,14 @@ func (api *api) projectHistoryParametersByOrganizationAndName(rw http.ResponseWr
render.JSON(rw, r, apiParameters)
}
func convertProjectHistory(history database.ProjectHistory, job database.ProvisionerJob) ProjectHistory {
return ProjectHistory{
ID: history.ID,
ProjectID: history.ProjectID,
CreatedAt: history.CreatedAt,
UpdatedAt: history.UpdatedAt,
Name: history.Name,
StorageMethod: history.StorageMethod,
func convertProjectVersion(version database.ProjectVersion, job database.ProvisionerJob) ProjectVersion {
return ProjectVersion{
ID: version.ID,
ProjectID: version.ProjectID,
CreatedAt: version.CreatedAt,
UpdatedAt: version.UpdatedAt,
Name: version.Name,
StorageMethod: version.StorageMethod,
Import: convertProvisionerJob(job),
}
}
@@ -241,7 +241,7 @@ func convertProjectParameter(parameter database.ProjectParameter) ProjectParamet
return ProjectParameter{
ID: parameter.ID,
CreatedAt: parameter.CreatedAt,
ProjectHistoryID: parameter.ProjectHistoryID,
ProjectVersionID: parameter.ProjectVersionID,
Name: parameter.Name,
Description: parameter.Description,
DefaultSourceScheme: parameter.DefaultSourceScheme,
@@ -259,6 +259,6 @@ func convertProjectParameter(parameter database.ProjectParameter) ProjectParamet
}
}
func projectHistoryLogsChannel(projectHistoryID uuid.UUID) string {
return fmt.Sprintf("project-history-logs:%s", projectHistoryID)
func projectVersionLogsChannel(projectVersionID uuid.UUID) string {
return fmt.Sprintf("project-version-logs:%s", projectVersionID)
}
coderd/projecthistory_test.go → coderd/projectversion_test.go
+8 -8
View File
@@ -15,7 +15,7 @@ import (
"github.com/coder/coder/provisionersdk/proto"
)
func TestProjectHistory(t *testing.T) {
func TestProjectVersion(t *testing.T) {
t.Parallel()
t.Run("NoHistory", func(t *testing.T) {
@@ -27,12 +27,12 @@ func TestProjectHistory(t *testing.T) {
Provisioner: database.ProvisionerTypeEcho,
})
require.NoError(t, err)
versions, err := server.Client.ListProjectHistory(context.Background(), user.Organization, project.Name)
versions, err := server.Client.ProjectVersions(context.Background(), user.Organization, project.Name)
require.NoError(t, err)
require.Len(t, versions, 0)
})
t.Run("CreateHistory", func(t *testing.T) {
t.Run("CreateVersion", func(t *testing.T) {
t.Parallel()
server := coderdtest.New(t)
user := server.RandomInitialUser(t)
@@ -47,16 +47,16 @@ func TestProjectHistory(t *testing.T) {
},
}}, nil)
require.NoError(t, err)
history, err := server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
version, err := server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: data,
})
require.NoError(t, err)
versions, err := server.Client.ListProjectHistory(context.Background(), user.Organization, project.Name)
versions, err := server.Client.ProjectVersions(context.Background(), user.Organization, project.Name)
require.NoError(t, err)
require.Len(t, versions, 1)
_, err = server.Client.ProjectHistory(context.Background(), user.Organization, project.Name, history.Name)
_, err = server.Client.ProjectVersion(context.Background(), user.Organization, project.Name, version.Name)
require.NoError(t, err)
})
@@ -78,7 +78,7 @@ func TestProjectHistory(t *testing.T) {
require.NoError(t, err)
_, err = writer.Write(make([]byte, 1<<21))
require.NoError(t, err)
_, err = server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
_, err = server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: buffer.Bytes(),
})
@@ -94,7 +94,7 @@ func TestProjectHistory(t *testing.T) {
Provisioner: database.ProvisionerTypeEcho,
})
require.NoError(t, err)
_, err = server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
_, err = server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: []byte{},
})
coderd/provisionerdaemons.go
+17 -17
View File
@@ -106,7 +106,7 @@ type workspaceProvisionJob struct {
// The input for a "project_import" job.
type projectImportJob struct {
ProjectHistoryID uuid.UUID `json:"project_history_id"`
ProjectVersionID uuid.UUID `json:"project_version_id"`
}
// Implementation of the provisioner daemon protobuf server.
@@ -182,7 +182,7 @@ func (server *provisionerdServer) AcquireJob(ctx context.Context, _ *proto.Empty
ProjectName: project.Name,
UserName: user.Username,
}
var projectHistory database.ProjectHistory
var projectVersion database.ProjectVersion
switch job.Type {
case database.ProvisionerJobTypeWorkspaceProvision:
var input workspaceProvisionJob
@@ -198,16 +198,16 @@ func (server *provisionerdServer) AcquireJob(ctx context.Context, _ *proto.Empty
if err != nil {
return nil, failJob(fmt.Sprintf("get workspace: %s", err))
}
projectHistory, err = server.Database.GetProjectHistoryByID(ctx, workspaceHistory.ProjectHistoryID)
projectVersion, err = server.Database.GetProjectVersionByID(ctx, workspaceHistory.ProjectVersionID)
if err != nil {
return nil, failJob(fmt.Sprintf("get project history: %s", err))
return nil, failJob(fmt.Sprintf("get project version: %s", err))
}
// Compute parameters for the workspace to consume.
parameters, err := projectparameter.Compute(ctx, server.Database, projectparameter.Scope{
OrganizationID: organization.ID,
ProjectID: project.ID,
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
UserID: user.ID,
WorkspaceID: workspace.ID,
WorkspaceHistoryID: workspaceHistory.ID,
@@ -249,23 +249,23 @@ func (server *provisionerdServer) AcquireJob(ctx context.Context, _ *proto.Empty
if err != nil {
return nil, failJob(fmt.Sprintf("unmarshal job input %q: %s", job.Input, err))
}
projectHistory, err = server.Database.GetProjectHistoryByID(ctx, input.ProjectHistoryID)
projectVersion, err = server.Database.GetProjectVersionByID(ctx, input.ProjectVersionID)
if err != nil {
return nil, failJob(fmt.Sprintf("get project history: %s", err))
return nil, failJob(fmt.Sprintf("get project version: %s", err))
}
protoJob.Type = &proto.AcquiredJob_ProjectImport_{
ProjectImport: &proto.AcquiredJob_ProjectImport{
ProjectHistoryId: projectHistory.ID.String(),
ProjectHistoryName: projectHistory.Name,
ProjectVersionId: projectVersion.ID.String(),
ProjectVersionName: projectVersion.Name,
},
}
}
switch projectHistory.StorageMethod {
switch projectVersion.StorageMethod {
case database.ProjectStorageMethodInlineArchive:
protoJob.ProjectSourceArchive = projectHistory.StorageSource
protoJob.ProjectSourceArchive = projectVersion.StorageSource
default:
return nil, failJob(fmt.Sprintf("unsupported storage source: %q", projectHistory.StorageMethod))
return nil, failJob(fmt.Sprintf("unsupported storage source: %q", projectVersion.StorageMethod))
}
return protoJob, err
@@ -309,8 +309,8 @@ func (server *provisionerdServer) UpdateJob(stream proto.DRPCProvisionerDaemon_U
if err != nil {
return xerrors.Errorf("unmarshal job input %q: %s", job.Input, err)
}
insertParams := database.InsertProjectHistoryLogsParams{
ProjectHistoryID: input.ProjectHistoryID,
insertParams := database.InsertProjectVersionLogsParams{
ProjectVersionID: input.ProjectVersionID,
}
for _, log := range update.ProjectImportLogs {
logLevel, err := convertLogLevel(log.Level)
@@ -327,7 +327,7 @@ func (server *provisionerdServer) UpdateJob(stream proto.DRPCProvisionerDaemon_U
insertParams.Source = append(insertParams.Source, logSource)
insertParams.Output = append(insertParams.Output, log.Output)
}
logs, err := server.Database.InsertProjectHistoryLogs(stream.Context(), insertParams)
logs, err := server.Database.InsertProjectVersionLogs(stream.Context(), insertParams)
if err != nil {
return xerrors.Errorf("insert project logs: %w", err)
}
@@ -335,7 +335,7 @@ func (server *provisionerdServer) UpdateJob(stream proto.DRPCProvisionerDaemon_U
if err != nil {
return xerrors.Errorf("marshal project log: %w", err)
}
err = server.Pubsub.Publish(projectHistoryLogsChannel(input.ProjectHistoryID), data)
err = server.Pubsub.Publish(projectVersionLogsChannel(input.ProjectVersionID), data)
if err != nil {
return xerrors.Errorf("publish history log: %w", err)
}
@@ -442,7 +442,7 @@ func (server *provisionerdServer) CompleteJob(ctx context.Context, completed *pr
projectParameter := database.InsertProjectParameterParams{
ID: uuid.New(),
CreatedAt: database.Now(),
ProjectHistoryID: input.ProjectHistoryID,
ProjectVersionID: input.ProjectVersionID,
Name: protoParameter.Name,
Description: protoParameter.Description,
RedisplayValue: protoParameter.RedisplayValue,
coderd/workspacehistory.go
+15 -15
View File
@@ -25,7 +25,7 @@ type WorkspaceHistory struct {
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
WorkspaceID uuid.UUID `json:"workspace_id"`
ProjectHistoryID uuid.UUID `json:"project_history_id"`
ProjectVersionID uuid.UUID `json:"project_version_id"`
BeforeID uuid.UUID `json:"before_id"`
AfterID uuid.UUID `json:"after_id"`
Name string `json:"name"`
@@ -36,7 +36,7 @@ type WorkspaceHistory struct {
// CreateWorkspaceHistoryRequest provides options to update the latest workspace history.
type CreateWorkspaceHistoryRequest struct {
ProjectHistoryID uuid.UUID `json:"project_history_id" validate:"required"`
ProjectVersionID uuid.UUID `json:"project_version_id" validate:"required"`
Transition database.WorkspaceTransition `json:"transition" validate:"oneof=create start stop delete,required"`
}
@@ -47,12 +47,12 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
}
user := httpmw.UserParam(r)
workspace := httpmw.WorkspaceParam(r)
projectHistory, err := api.Database.GetProjectHistoryByID(r.Context(), createBuild.ProjectHistoryID)
projectVersion, err := api.Database.GetProjectVersionByID(r.Context(), createBuild.ProjectVersionID)
if errors.Is(err, sql.ErrNoRows) {
httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
Message: "project history not found",
Message: "project version not found",
Errors: []httpapi.Error{{
Field: "project_history_id",
Field: "project_version_id",
Code: "exists",
}},
})
@@ -60,36 +60,36 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
}
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get project history: %s", err),
Message: fmt.Sprintf("get project version: %s", err),
})
return
}
projectHistoryJob, err := api.Database.GetProvisionerJobByID(r.Context(), projectHistory.ImportJobID)
projectVersionJob, err := api.Database.GetProvisionerJobByID(r.Context(), projectVersion.ImportJobID)
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get provisioner job: %s", err),
})
return
}
projectHistoryJobStatus := convertProvisionerJob(projectHistoryJob).Status
switch projectHistoryJobStatus {
projectVersionJobStatus := convertProvisionerJob(projectVersionJob).Status
switch projectVersionJobStatus {
case ProvisionerJobStatusPending, ProvisionerJobStatusRunning:
httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
Message: fmt.Sprintf("The provided project history is %s. Wait for it to complete importing!", projectHistoryJobStatus),
Message: fmt.Sprintf("The provided project version is %s. Wait for it to complete importing!", projectVersionJobStatus),
})
return
case ProvisionerJobStatusFailed:
httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
Message: fmt.Sprintf("The provided project history %q has failed to import. You cannot create workspaces using it!", projectHistory.Name),
Message: fmt.Sprintf("The provided project version %q has failed to import. You cannot create workspaces using it!", projectVersion.Name),
})
return
case ProvisionerJobStatusCancelled:
httpapi.Write(rw, http.StatusPreconditionFailed, httpapi.Response{
Message: "The provided project history was canceled during import. You cannot create workspaces using it!",
Message: "The provided project version was canceled during import. You cannot create workspaces using it!",
})
}
project, err := api.Database.GetProjectByID(r.Context(), projectHistory.ProjectID)
project, err := api.Database.GetProjectByID(r.Context(), projectVersion.ProjectID)
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get project: %s", err),
@@ -154,7 +154,7 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
CreatedAt: database.Now(),
UpdatedAt: database.Now(),
WorkspaceID: workspace.ID,
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
BeforeID: priorHistoryID,
Name: namesgenerator.GetRandomName(1),
Initiator: user.ID,
@@ -246,7 +246,7 @@ func convertWorkspaceHistory(workspaceHistory database.WorkspaceHistory, provisi
CreatedAt: workspaceHistory.CreatedAt,
UpdatedAt: workspaceHistory.UpdatedAt,
WorkspaceID: workspaceHistory.WorkspaceID,
ProjectHistoryID: workspaceHistory.ProjectHistoryID,
ProjectVersionID: workspaceHistory.ProjectVersionID,
BeforeID: workspaceHistory.BeforeID.UUID,
AfterID: workspaceHistory.AfterID.UUID,
Name: workspaceHistory.Name,
coderd/workspacehistory_test.go
+16 -16
View File
@@ -32,19 +32,19 @@ func TestWorkspaceHistory(t *testing.T) {
return project, workspace
}
setupProjectHistory := func(t *testing.T, client *codersdk.Client, user coderd.CreateInitialUserRequest, project coderd.Project, data []byte) coderd.ProjectHistory {
projectHistory, err := client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
setupProjectVersion := func(t *testing.T, client *codersdk.Client, user coderd.CreateInitialUserRequest, project coderd.Project, data []byte) coderd.ProjectVersion {
projectVersion, err := client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: data,
})
require.NoError(t, err)
require.Eventually(t, func() bool {
hist, err := client.ProjectHistory(context.Background(), user.Organization, project.Name, projectHistory.Name)
version, err := client.ProjectVersion(context.Background(), user.Organization, project.Name, projectVersion.Name)
require.NoError(t, err)
t.Logf("Import status: %s\n", hist.Import.Status)
return hist.Import.Status.Completed()
t.Logf("Import status: %s\n", version.Import.Status)
return version.Import.Status.Completed()
}, 15*time.Second, 50*time.Millisecond)
return projectHistory
return projectVersion
}
t.Run("AllHistory", func(t *testing.T) {
@@ -58,9 +58,9 @@ func TestWorkspaceHistory(t *testing.T) {
require.Len(t, history, 0)
data, err := echo.Tar(echo.ParseComplete, echo.ProvisionComplete)
require.NoError(t, err)
projectVersion := setupProjectHistory(t, server.Client, user, project, data)
projectVersion := setupProjectVersion(t, server.Client, user, project, data)
_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: projectVersion.ID,
ProjectVersionID: projectVersion.ID,
Transition: database.WorkspaceTransitionCreate,
})
require.NoError(t, err)
@@ -79,9 +79,9 @@ func TestWorkspaceHistory(t *testing.T) {
require.Error(t, err)
data, err := echo.Tar(echo.ParseComplete, echo.ProvisionComplete)
require.NoError(t, err)
projectHistory := setupProjectHistory(t, server.Client, user, project, data)
projectVersion := setupProjectVersion(t, server.Client, user, project, data)
_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
Transition: database.WorkspaceTransitionCreate,
})
require.NoError(t, err)
@@ -97,9 +97,9 @@ func TestWorkspaceHistory(t *testing.T) {
project, workspace := setupProjectAndWorkspace(t, server.Client, user)
data, err := echo.Tar(echo.ParseComplete, echo.ProvisionComplete)
require.NoError(t, err)
projectHistory := setupProjectHistory(t, server.Client, user, project, data)
projectVersion := setupProjectVersion(t, server.Client, user, project, data)
_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
Transition: database.WorkspaceTransitionCreate,
})
require.NoError(t, err)
@@ -122,16 +122,16 @@ func TestWorkspaceHistory(t *testing.T) {
project, workspace := setupProjectAndWorkspace(t, server.Client, user)
data, err := echo.Tar(echo.ParseComplete, echo.ProvisionComplete)
require.NoError(t, err)
projectHistory := setupProjectHistory(t, server.Client, user, project, data)
projectVersion := setupProjectVersion(t, server.Client, user, project, data)
_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
Transition: database.WorkspaceTransitionCreate,
})
require.NoError(t, err)
_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
Transition: database.WorkspaceTransitionCreate,
})
require.Error(t, err)
@@ -145,7 +145,7 @@ func TestWorkspaceHistory(t *testing.T) {
_, workspace := setupProjectAndWorkspace(t, server.Client, user)
_, err := server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: uuid.New(),
ProjectVersionID: uuid.New(),
Transition: database.WorkspaceTransitionCreate,
})
require.Error(t, err)
coderd/workspacehistorylogs_test.go
+6 -6
View File
@@ -32,18 +32,18 @@ func TestWorkspaceHistoryLogs(t *testing.T) {
return project, workspace
}
setupProjectHistory := func(t *testing.T, client *codersdk.Client, user coderd.CreateInitialUserRequest, project coderd.Project, data []byte) coderd.ProjectHistory {
projectHistory, err := client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
setupProjectVersion := func(t *testing.T, client *codersdk.Client, user coderd.CreateInitialUserRequest, project coderd.Project, data []byte) coderd.ProjectVersion {
projectVersion, err := client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: data,
})
require.NoError(t, err)
require.Eventually(t, func() bool {
hist, err := client.ProjectHistory(context.Background(), user.Organization, project.Name, projectHistory.Name)
hist, err := client.ProjectVersion(context.Background(), user.Organization, project.Name, projectVersion.Name)
require.NoError(t, err)
return hist.Import.Status.Completed()
}, 15*time.Second, 50*time.Millisecond)
return projectHistory
return projectVersion
}
server := coderdtest.New(t)
@@ -62,10 +62,10 @@ func TestWorkspaceHistoryLogs(t *testing.T) {
},
}})
require.NoError(t, err)
projectHistory := setupProjectHistory(t, server.Client, user, project, data)
projectVersion := setupProjectVersion(t, server.Client, user, project, data)
workspaceHistory, err := server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: projectHistory.ID,
ProjectVersionID: projectVersion.ID,
Transition: database.WorkspaceTransitionCreate,
})
require.NoError(t, err)
codersdk/projects.go
+35 -35
View File
@@ -57,9 +57,9 @@ func (c *Client) CreateProject(ctx context.Context, organization string, request
return project, json.NewDecoder(res.Body).Decode(&project)
}
// ListProjectHistory lists history for a project.
func (c *Client) ListProjectHistory(ctx context.Context, organization, project string) ([]coderd.ProjectHistory, error) {
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/%s/history", organization, project), nil)
// ProjectVersions lists versions of a project.
func (c *Client) ProjectVersions(ctx context.Context, organization, project string) ([]coderd.ProjectVersion, error) {
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/%s/versions", organization, project), nil)
if err != nil {
return nil, err
}
@@ -67,41 +67,41 @@ func (c *Client) ListProjectHistory(ctx context.Context, organization, project s
if res.StatusCode != http.StatusOK {
return nil, readBodyAsError(res)
}
var projectHistory []coderd.ProjectHistory
return projectHistory, json.NewDecoder(res.Body).Decode(&projectHistory)
}
// ProjectHistory returns project history by name.
func (c *Client) ProjectHistory(ctx context.Context, organization, project, history string) (coderd.ProjectHistory, error) {
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/%s/history/%s", organization, project, history), nil)
if err != nil {
return coderd.ProjectHistory{}, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return coderd.ProjectHistory{}, readBodyAsError(res)
}
var projectHistory coderd.ProjectHistory
return projectHistory, json.NewDecoder(res.Body).Decode(&projectHistory)
}
// CreateProjectHistory inserts a new version for the project.
func (c *Client) CreateProjectHistory(ctx context.Context, organization, project string, request coderd.CreateProjectHistoryRequest) (coderd.ProjectHistory, error) {
res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/projects/%s/%s/history", organization, project), request)
if err != nil {
return coderd.ProjectHistory{}, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusCreated {
return coderd.ProjectHistory{}, readBodyAsError(res)
}
var projectVersion coderd.ProjectHistory
var projectVersion []coderd.ProjectVersion
return projectVersion, json.NewDecoder(res.Body).Decode(&projectVersion)
}
// ProjectHistoryParameters returns project parameters for history by name.
func (c *Client) ProjectHistoryParameters(ctx context.Context, organization, project, history string) ([]coderd.ProjectParameter, error) {
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/%s/history/%s/parameters", organization, project, history), nil)
// ProjectVersion returns project version by name.
func (c *Client) ProjectVersion(ctx context.Context, organization, project, version string) (coderd.ProjectVersion, error) {
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/%s/versions/%s", organization, project, version), nil)
if err != nil {
return coderd.ProjectVersion{}, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return coderd.ProjectVersion{}, readBodyAsError(res)
}
var projectVersion coderd.ProjectVersion
return projectVersion, json.NewDecoder(res.Body).Decode(&projectVersion)
}
// CreateProjectVersion inserts a new version for the project.
func (c *Client) CreateProjectVersion(ctx context.Context, organization, project string, request coderd.CreateProjectVersionRequest) (coderd.ProjectVersion, error) {
res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/projects/%s/%s/versions", organization, project), request)
if err != nil {
return coderd.ProjectVersion{}, err
}
defer res.Body.Close()
if res.StatusCode != http.StatusCreated {
return coderd.ProjectVersion{}, readBodyAsError(res)
}
var projectVersion coderd.ProjectVersion
return projectVersion, json.NewDecoder(res.Body).Decode(&projectVersion)
}
// ProjectVersionParameters returns project parameters for a version by name.
func (c *Client) ProjectVersionParameters(ctx context.Context, organization, project, version string) ([]coderd.ProjectParameter, error) {
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/projects/%s/%s/versions/%s/parameters", organization, project, version), nil)
if err != nil {
return nil, err
}
codersdk/projects_test.go
+6 -6
View File
@@ -74,7 +74,7 @@ func TestProjects(t *testing.T) {
t.Run("UnauthenticatedHistory", func(t *testing.T) {
t.Parallel()
server := coderdtest.New(t)
_, err := server.Client.ListProjectHistory(context.Background(), "org", "project")
_, err := server.Client.ProjectVersions(context.Background(), "org", "project")
require.Error(t, err)
})
@@ -87,14 +87,14 @@ func TestProjects(t *testing.T) {
Provisioner: database.ProvisionerTypeEcho,
})
require.NoError(t, err)
_, err = server.Client.ListProjectHistory(context.Background(), user.Organization, project.Name)
_, err = server.Client.ProjectVersions(context.Background(), user.Organization, project.Name)
require.NoError(t, err)
})
t.Run("CreateHistoryUnauthenticated", func(t *testing.T) {
t.Parallel()
server := coderdtest.New(t)
_, err := server.Client.CreateProjectHistory(context.Background(), "org", "project", coderd.CreateProjectHistoryRequest{
_, err := server.Client.CreateProjectVersion(context.Background(), "org", "project", coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: []byte{},
})
@@ -119,13 +119,13 @@ func TestProjects(t *testing.T) {
require.NoError(t, err)
_, err = writer.Write(make([]byte, 1<<10))
require.NoError(t, err)
history, err := server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectHistoryRequest{
version, err := server.Client.CreateProjectVersion(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
StorageMethod: database.ProjectStorageMethodInlineArchive,
StorageSource: buffer.Bytes(),
})
require.NoError(t, err)
_, err = server.Client.ProjectHistory(context.Background(), user.Organization, project.Name, history.Name)
_, err = server.Client.ProjectVersion(context.Background(), user.Organization, project.Name, version.Name)
require.NoError(t, err)
})
@@ -168,7 +168,7 @@ func TestProjects(t *testing.T) {
t.Parallel()
server := coderdtest.New(t)
user := server.RandomInitialUser(t)
_, err := server.Client.ProjectHistoryParameters(context.Background(), user.Organization, "nothing", "nope")
_, err := server.Client.ProjectVersionParameters(context.Background(), user.Organization, "nothing", "nope")
require.Error(t, err)
})
}
codersdk/workspaces.go
+5 -5
View File
@@ -68,7 +68,7 @@ func (c *Client) ListWorkspaceHistory(ctx context.Context, owner, workspace stri
if owner == "" {
owner = "me"
}
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/history", owner, workspace), nil)
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/version", owner, workspace), nil)
if err != nil {
return nil, err
}
@@ -89,7 +89,7 @@ func (c *Client) WorkspaceHistory(ctx context.Context, owner, workspace, history
if history == "" {
history = "latest"
}
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/history/%s", owner, workspace, history), nil)
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/version/%s", owner, workspace, history), nil)
if err != nil {
return coderd.WorkspaceHistory{}, err
}
@@ -123,7 +123,7 @@ func (c *Client) CreateWorkspaceHistory(ctx context.Context, owner, workspace st
if owner == "" {
owner = "me"
}
res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/workspaces/%s/%s/history", owner, workspace), request)
res, err := c.request(ctx, http.MethodPost, fmt.Sprintf("/api/v2/workspaces/%s/%s/version", owner, workspace), request)
if err != nil {
return coderd.WorkspaceHistory{}, err
}
@@ -153,7 +153,7 @@ func (c *Client) WorkspaceHistoryLogsBetween(ctx context.Context, owner, workspa
if !before.IsZero() {
values["before"] = []string{strconv.FormatInt(before.UTC().UnixMilli(), 10)}
}
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/history/%s/logs?%s", owner, workspace, history, values.Encode()), nil)
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/version/%s/logs?%s", owner, workspace, history, values.Encode()), nil)
if err != nil {
return nil, err
}
@@ -177,7 +177,7 @@ func (c *Client) FollowWorkspaceHistoryLogsAfter(ctx context.Context, owner, wor
owner = "me"
}
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/history/%s/logs?follow%s", owner, workspace, history, afterQuery), nil)
res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaces/%s/%s/version/%s/logs?follow%s", owner, workspace, history, afterQuery), nil)
if err != nil {
return nil, err
}
codersdk/workspaces_test.go
+1 -1
View File
@@ -161,7 +161,7 @@ func TestWorkspaces(t *testing.T) {
})
require.NoError(t, err)
_, err = server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
ProjectHistoryID: uuid.New(),
ProjectVersionID: uuid.New(),
Transition: database.WorkspaceTransitionCreate,
})
require.Error(t, err)
database/databasefake/databasefake.go
+42 -42
View File
@@ -21,8 +21,8 @@ func New() database.Store {
parameterValue: make([]database.ParameterValue, 0),
project: make([]database.Project, 0),
projectHistory: make([]database.ProjectHistory, 0),
projectHistoryLog: make([]database.ProjectHistoryLog, 0),
projectVersion: make([]database.ProjectVersion, 0),
projectVersionLog: make([]database.ProjectVersionLog, 0),
projectParameter: make([]database.ProjectParameter, 0),
provisionerDaemons: make([]database.ProvisionerDaemon, 0),
provisionerJobs: make([]database.ProvisionerJob, 0),
@@ -47,8 +47,8 @@ type fakeQuerier struct {
// New tables
parameterValue []database.ParameterValue
project []database.Project
projectHistory []database.ProjectHistory
projectHistoryLog []database.ProjectHistoryLog
projectVersion []database.ProjectVersion
projectVersionLog []database.ProjectVersionLog
projectParameter []database.ProjectParameter
provisionerDaemons []database.ProvisionerDaemon
provisionerJobs []database.ProvisionerJob
@@ -410,55 +410,55 @@ func (q *fakeQuerier) GetProjectByOrganizationAndName(_ context.Context, arg dat
return database.Project{}, sql.ErrNoRows
}
func (q *fakeQuerier) GetProjectHistoryByProjectID(_ context.Context, projectID uuid.UUID) ([]database.ProjectHistory, error) {
func (q *fakeQuerier) GetProjectVersionByProjectID(_ context.Context, projectID uuid.UUID) ([]database.ProjectVersion, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
history := make([]database.ProjectHistory, 0)
for _, projectHistory := range q.projectHistory {
if projectHistory.ProjectID.String() != projectID.String() {
version := make([]database.ProjectVersion, 0)
for _, projectVersion := range q.projectVersion {
if projectVersion.ProjectID.String() != projectID.String() {
continue
}
history = append(history, projectHistory)
version = append(version, projectVersion)
}
if len(history) == 0 {
if len(version) == 0 {
return nil, sql.ErrNoRows
}
return history, nil
return version, nil
}
func (q *fakeQuerier) GetProjectHistoryByProjectIDAndName(_ context.Context, arg database.GetProjectHistoryByProjectIDAndNameParams) (database.ProjectHistory, error) {
func (q *fakeQuerier) GetProjectVersionByProjectIDAndName(_ context.Context, arg database.GetProjectVersionByProjectIDAndNameParams) (database.ProjectVersion, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
for _, projectHistory := range q.projectHistory {
if projectHistory.ProjectID.String() != arg.ProjectID.String() {
for _, projectVersion := range q.projectVersion {
if projectVersion.ProjectID.String() != arg.ProjectID.String() {
continue
}
if !strings.EqualFold(projectHistory.Name, arg.Name) {
if !strings.EqualFold(projectVersion.Name, arg.Name) {
continue
}
return projectHistory, nil
return projectVersion, nil
}
return database.ProjectHistory{}, sql.ErrNoRows
return database.ProjectVersion{}, sql.ErrNoRows
}
func (q *fakeQuerier) GetProjectHistoryLogsByIDBetween(_ context.Context, arg database.GetProjectHistoryLogsByIDBetweenParams) ([]database.ProjectHistoryLog, error) {
func (q *fakeQuerier) GetProjectVersionLogsByIDBetween(_ context.Context, arg database.GetProjectVersionLogsByIDBetweenParams) ([]database.ProjectVersionLog, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
logs := make([]database.ProjectHistoryLog, 0)
for _, projectHistoryLog := range q.projectHistoryLog {
if projectHistoryLog.ProjectHistoryID.String() != arg.ProjectHistoryID.String() {
logs := make([]database.ProjectVersionLog, 0)
for _, projectVersionLog := range q.projectVersionLog {
if projectVersionLog.ProjectVersionID.String() != arg.ProjectVersionID.String() {
continue
}
if projectHistoryLog.CreatedAt.After(arg.CreatedBefore) {
if projectVersionLog.CreatedAt.After(arg.CreatedBefore) {
continue
}
if projectHistoryLog.CreatedAt.Before(arg.CreatedAfter) {
if projectVersionLog.CreatedAt.Before(arg.CreatedAfter) {
continue
}
logs = append(logs, projectHistoryLog)
logs = append(logs, projectVersionLog)
}
if len(logs) == 0 {
return nil, sql.ErrNoRows
@@ -466,26 +466,26 @@ func (q *fakeQuerier) GetProjectHistoryLogsByIDBetween(_ context.Context, arg da
return logs, nil
}
func (q *fakeQuerier) GetProjectHistoryByID(_ context.Context, projectHistoryID uuid.UUID) (database.ProjectHistory, error) {
func (q *fakeQuerier) GetProjectVersionByID(_ context.Context, projectVersionID uuid.UUID) (database.ProjectVersion, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
for _, projectHistory := range q.projectHistory {
if projectHistory.ID.String() != projectHistoryID.String() {
for _, projectVersion := range q.projectVersion {
if projectVersion.ID.String() != projectVersionID.String() {
continue
}
return projectHistory, nil
return projectVersion, nil
}
return database.ProjectHistory{}, sql.ErrNoRows
return database.ProjectVersion{}, sql.ErrNoRows
}
func (q *fakeQuerier) GetProjectParametersByHistoryID(_ context.Context, projectHistoryID uuid.UUID) ([]database.ProjectParameter, error) {
func (q *fakeQuerier) GetProjectParametersByVersionID(_ context.Context, projectVersionID uuid.UUID) ([]database.ProjectParameter, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
parameters := make([]database.ProjectParameter, 0)
for _, projectParameter := range q.projectParameter {
if projectParameter.ProjectHistoryID.String() != projectHistoryID.String() {
if projectParameter.ProjectVersionID.String() != projectVersionID.String() {
continue
}
parameters = append(parameters, projectParameter)
@@ -660,12 +660,12 @@ func (q *fakeQuerier) InsertProject(_ context.Context, arg database.InsertProjec
return project, nil
}
func (q *fakeQuerier) InsertProjectHistory(_ context.Context, arg database.InsertProjectHistoryParams) (database.ProjectHistory, error) {
func (q *fakeQuerier) InsertProjectVersion(_ context.Context, arg database.InsertProjectVersionParams) (database.ProjectVersion, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
//nolint:gosimple
history := database.ProjectHistory{
version := database.ProjectVersion{
ID: arg.ID,
ProjectID: arg.ProjectID,
CreatedAt: arg.CreatedAt,
@@ -676,18 +676,18 @@ func (q *fakeQuerier) InsertProjectHistory(_ context.Context, arg database.Inser
StorageSource: arg.StorageSource,
ImportJobID: arg.ImportJobID,
}
q.projectHistory = append(q.projectHistory, history)
return history, nil
q.projectVersion = append(q.projectVersion, version)
return version, nil
}
func (q *fakeQuerier) InsertProjectHistoryLogs(_ context.Context, arg database.InsertProjectHistoryLogsParams) ([]database.ProjectHistoryLog, error) {
func (q *fakeQuerier) InsertProjectVersionLogs(_ context.Context, arg database.InsertProjectVersionLogsParams) ([]database.ProjectVersionLog, error) {
q.mutex.Lock()
defer q.mutex.Unlock()
logs := make([]database.ProjectHistoryLog, 0)
logs := make([]database.ProjectVersionLog, 0)
for index, output := range arg.Output {
logs = append(logs, database.ProjectHistoryLog{
ProjectHistoryID: arg.ProjectHistoryID,
logs = append(logs, database.ProjectVersionLog{
ProjectVersionID: arg.ProjectVersionID,
ID: arg.ID[index],
CreatedAt: arg.CreatedAt[index],
Source: arg.Source[index],
@@ -695,7 +695,7 @@ func (q *fakeQuerier) InsertProjectHistoryLogs(_ context.Context, arg database.I
Output: output,
})
}
q.projectHistoryLog = append(q.projectHistoryLog, logs...)
q.projectVersionLog = append(q.projectVersionLog, logs...)
return logs, nil
}
@@ -707,7 +707,7 @@ func (q *fakeQuerier) InsertProjectParameter(_ context.Context, arg database.Ins
param := database.ProjectParameter{
ID: arg.ID,
CreatedAt: arg.CreatedAt,
ProjectHistoryID: arg.ProjectHistoryID,
ProjectVersionID: arg.ProjectVersionID,
Name: arg.Name,
Description: arg.Description,
DefaultSourceScheme: arg.DefaultSourceScheme,
@@ -821,7 +821,7 @@ func (q *fakeQuerier) InsertWorkspaceHistory(_ context.Context, arg database.Ins
UpdatedAt: arg.UpdatedAt,
WorkspaceID: arg.WorkspaceID,
Name: arg.Name,
ProjectHistoryID: arg.ProjectHistoryID,
ProjectVersionID: arg.ProjectVersionID,
BeforeID: arg.BeforeID,
Transition: arg.Transition,
Initiator: arg.Initiator,
database/dump.sql
Generated
+18 -18
View File
@@ -137,7 +137,7 @@ CREATE TABLE project (
active_version_id uuid
);
CREATE TABLE project_history (
CREATE TABLE project_version (
id uuid NOT NULL,
project_id uuid NOT NULL,
created_at timestamp with time zone NOT NULL,
@@ -149,9 +149,9 @@ CREATE TABLE project_history (
import_job_id uuid NOT NULL
);
CREATE TABLE project_history_log (
CREATE TABLE project_version_log (
id uuid NOT NULL,
project_history_id uuid NOT NULL,
project_version_id uuid NOT NULL,
created_at timestamp with time zone NOT NULL,
source log_source NOT NULL,
level log_level NOT NULL,
@@ -161,7 +161,7 @@ CREATE TABLE project_history_log (
CREATE TABLE project_parameter (
id uuid NOT NULL,
created_at timestamp with time zone NOT NULL,
project_history_id uuid NOT NULL,
project_version_id uuid NOT NULL,
name character varying(64) NOT NULL,
description character varying(8192) DEFAULT ''::character varying NOT NULL,
default_source_scheme parameter_source_scheme,
@@ -247,7 +247,7 @@ CREATE TABLE workspace_history (
created_at timestamp with time zone NOT NULL,
updated_at timestamp with time zone NOT NULL,
workspace_id uuid NOT NULL,
project_history_id uuid NOT NULL,
project_version_id uuid NOT NULL,
name character varying(64) NOT NULL,
before_id uuid,
after_id uuid,
@@ -282,14 +282,14 @@ ALTER TABLE ONLY parameter_value
ALTER TABLE ONLY parameter_value
ADD CONSTRAINT parameter_value_name_scope_scope_id_key UNIQUE (name, scope, scope_id);
ALTER TABLE ONLY project_history
ADD CONSTRAINT project_history_id_key UNIQUE (id);
ALTER TABLE ONLY project_version
ADD CONSTRAINT project_version_id_key UNIQUE (id);
ALTER TABLE ONLY project_history_log
ADD CONSTRAINT project_history_log_id_key UNIQUE (id);
ALTER TABLE ONLY project_version_log
ADD CONSTRAINT project_version_log_id_key UNIQUE (id);
ALTER TABLE ONLY project_history
ADD CONSTRAINT project_history_project_id_name_key UNIQUE (project_id, name);
ALTER TABLE ONLY project_version
ADD CONSTRAINT project_version_project_id_name_key UNIQUE (project_id, name);
ALTER TABLE ONLY project
ADD CONSTRAINT project_id_key UNIQUE (id);
@@ -301,7 +301,7 @@ ALTER TABLE ONLY project_parameter
ADD CONSTRAINT project_parameter_id_key UNIQUE (id);
ALTER TABLE ONLY project_parameter
ADD CONSTRAINT project_parameter_project_history_id_name_key UNIQUE (project_history_id, name);
ADD CONSTRAINT project_parameter_project_version_id_name_key UNIQUE (project_version_id, name);
ALTER TABLE ONLY provisioner_daemon
ADD CONSTRAINT provisioner_daemon_id_key UNIQUE (id);
@@ -339,14 +339,14 @@ ALTER TABLE ONLY workspace_resource
ALTER TABLE ONLY workspace_resource
ADD CONSTRAINT workspace_resource_workspace_history_id_name_key UNIQUE (workspace_history_id, name);
ALTER TABLE ONLY project_history_log
ADD CONSTRAINT project_history_log_project_history_id_fkey FOREIGN KEY (project_history_id) REFERENCES project_history(id) ON DELETE CASCADE;
ALTER TABLE ONLY project_version_log
ADD CONSTRAINT project_version_log_project_version_id_fkey FOREIGN KEY (project_version_id) REFERENCES project_version(id) ON DELETE CASCADE;
ALTER TABLE ONLY project_history
ADD CONSTRAINT project_history_project_id_fkey FOREIGN KEY (project_id) REFERENCES project(id);
ALTER TABLE ONLY project_version
ADD CONSTRAINT project_version_project_id_fkey FOREIGN KEY (project_id) REFERENCES project(id);
ALTER TABLE ONLY project_parameter
ADD CONSTRAINT project_parameter_project_history_id_fkey FOREIGN KEY (project_history_id) REFERENCES project_history(id) ON DELETE CASCADE;
ADD CONSTRAINT project_parameter_project_version_id_fkey FOREIGN KEY (project_version_id) REFERENCES project_version(id) ON DELETE CASCADE;
ALTER TABLE ONLY provisioner_job
ADD CONSTRAINT provisioner_job_project_id_fkey FOREIGN KEY (project_id) REFERENCES project(id) ON DELETE CASCADE;
@@ -358,7 +358,7 @@ ALTER TABLE ONLY workspace_history_log
ADD CONSTRAINT workspace_history_log_workspace_history_id_fkey FOREIGN KEY (workspace_history_id) REFERENCES workspace_history(id) ON DELETE CASCADE;
ALTER TABLE ONLY workspace_history
ADD CONSTRAINT workspace_history_project_history_id_fkey FOREIGN KEY (project_history_id) REFERENCES project_history(id) ON DELETE CASCADE;
ADD CONSTRAINT workspace_history_project_version_id_fkey FOREIGN KEY (project_version_id) REFERENCES project_version(id) ON DELETE CASCADE;
ALTER TABLE ONLY workspace_history
ADD CONSTRAINT workspace_history_workspace_id_fkey FOREIGN KEY (workspace_id) REFERENCES workspace(id) ON DELETE CASCADE;
database/migrations/000002_projects.up.sql
+6 -6
View File
@@ -20,10 +20,10 @@ CREATE TABLE project (
CREATE TYPE project_storage_method AS ENUM ('inline-archive');
-- Project Versions store Project history. When a Project Version is imported,
-- Project Versions store historical project data. When a Project Version is imported,
-- an "import" job is queued to parse parameters. A Project Version
-- can only be used if the import job succeeds.
CREATE TABLE project_history (
CREATE TABLE project_version (
id uuid NOT NULL UNIQUE,
-- This should be indexed.
project_id uuid NOT NULL REFERENCES project (id),
@@ -66,7 +66,7 @@ CREATE TYPE parameter_destination_scheme AS ENUM('none', 'environment_variable',
CREATE TABLE project_parameter (
id uuid NOT NULL UNIQUE,
created_at timestamptz NOT NULL,
project_history_id uuid NOT NULL REFERENCES project_history(id) ON DELETE CASCADE,
project_version_id uuid NOT NULL REFERENCES project_version(id) ON DELETE CASCADE,
name varchar(64) NOT NULL,
-- 8KB limit
description varchar(8192) NOT NULL DEFAULT '',
@@ -88,7 +88,7 @@ CREATE TABLE project_parameter (
validation_condition varchar(512) NOT NULL,
validation_type_system parameter_type_system NOT NULL,
validation_value_type varchar(64) NOT NULL,
UNIQUE(project_history_id, name)
UNIQUE(project_version_id, name)
);
CREATE TYPE log_level AS ENUM (
@@ -104,9 +104,9 @@ CREATE TYPE log_source AS ENUM (
'provisioner'
);
CREATE TABLE project_history_log (
CREATE TABLE project_version_log (
id uuid NOT NULL UNIQUE,
project_history_id uuid NOT NULL REFERENCES project_history (id) ON DELETE CASCADE,
project_version_id uuid NOT NULL REFERENCES project_version (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL,
source log_source NOT NULL,
level log_level NOT NULL,
database/migrations/000003_workspaces.up.sql
+1 -1
View File
@@ -21,7 +21,7 @@ CREATE TABLE workspace_history (
created_at timestamptz NOT NULL,
updated_at timestamptz NOT NULL,
workspace_id uuid NOT NULL REFERENCES workspace (id) ON DELETE CASCADE,
project_history_id uuid NOT NULL REFERENCES project_history (id) ON DELETE CASCADE,
project_version_id uuid NOT NULL REFERENCES project_version (id) ON DELETE CASCADE,
name varchar(64) NOT NULL,
before_id uuid,
after_id uuid,
database/models.go
+23 -23
View File
@@ -316,31 +316,10 @@ type Project struct {
ActiveVersionID uuid.NullUUID `db:"active_version_id" json:"active_version_id"`
}
type ProjectHistory struct {
ID uuid.UUID `db:"id" json:"id"`
ProjectID uuid.UUID `db:"project_id" json:"project_id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
Name string `db:"name" json:"name"`
Description string `db:"description" json:"description"`
StorageMethod ProjectStorageMethod `db:"storage_method" json:"storage_method"`
StorageSource []byte `db:"storage_source" json:"storage_source"`
ImportJobID uuid.UUID `db:"import_job_id" json:"import_job_id"`
}
type ProjectHistoryLog struct {
ID uuid.UUID `db:"id" json:"id"`
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
Source LogSource `db:"source" json:"source"`
Level LogLevel `db:"level" json:"level"`
Output string `db:"output" json:"output"`
}
type ProjectParameter struct {
ID uuid.UUID `db:"id" json:"id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
Name string `db:"name" json:"name"`
Description string `db:"description" json:"description"`
DefaultSourceScheme ParameterSourceScheme `db:"default_source_scheme" json:"default_source_scheme"`
@@ -357,6 +336,27 @@ type ProjectParameter struct {
ValidationValueType string `db:"validation_value_type" json:"validation_value_type"`
}
type ProjectVersion struct {
ID uuid.UUID `db:"id" json:"id"`
ProjectID uuid.UUID `db:"project_id" json:"project_id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
Name string `db:"name" json:"name"`
Description string `db:"description" json:"description"`
StorageMethod ProjectStorageMethod `db:"storage_method" json:"storage_method"`
StorageSource []byte `db:"storage_source" json:"storage_source"`
ImportJobID uuid.UUID `db:"import_job_id" json:"import_job_id"`
}
type ProjectVersionLog struct {
ID uuid.UUID `db:"id" json:"id"`
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
Source LogSource `db:"source" json:"source"`
Level LogLevel `db:"level" json:"level"`
Output string `db:"output" json:"output"`
}
type ProvisionerDaemon struct {
ID uuid.UUID `db:"id" json:"id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
@@ -426,7 +426,7 @@ type WorkspaceHistory struct {
CreatedAt time.Time `db:"created_at" json:"created_at"`
UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"`
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
Name string `db:"name" json:"name"`
BeforeID uuid.NullUUID `db:"before_id" json:"before_id"`
AfterID uuid.NullUUID `db:"after_id" json:"after_id"`
database/querier.go
+7 -7
View File
@@ -18,11 +18,11 @@ type querier interface {
GetParameterValuesByScope(ctx context.Context, arg GetParameterValuesByScopeParams) ([]ParameterValue, error)
GetProjectByID(ctx context.Context, id uuid.UUID) (Project, error)
GetProjectByOrganizationAndName(ctx context.Context, arg GetProjectByOrganizationAndNameParams) (Project, error)
GetProjectHistoryByID(ctx context.Context, id uuid.UUID) (ProjectHistory, error)
GetProjectHistoryByProjectID(ctx context.Context, projectID uuid.UUID) ([]ProjectHistory, error)
GetProjectHistoryByProjectIDAndName(ctx context.Context, arg GetProjectHistoryByProjectIDAndNameParams) (ProjectHistory, error)
GetProjectHistoryLogsByIDBetween(ctx context.Context, arg GetProjectHistoryLogsByIDBetweenParams) ([]ProjectHistoryLog, error)
GetProjectParametersByHistoryID(ctx context.Context, projectHistoryID uuid.UUID) ([]ProjectParameter, error)
GetProjectParametersByVersionID(ctx context.Context, projectVersionID uuid.UUID) ([]ProjectParameter, error)
GetProjectVersionByID(ctx context.Context, id uuid.UUID) (ProjectVersion, error)
GetProjectVersionByProjectID(ctx context.Context, projectID uuid.UUID) ([]ProjectVersion, error)
GetProjectVersionByProjectIDAndName(ctx context.Context, arg GetProjectVersionByProjectIDAndNameParams) (ProjectVersion, error)
GetProjectVersionLogsByIDBetween(ctx context.Context, arg GetProjectVersionLogsByIDBetweenParams) ([]ProjectVersionLog, error)
GetProjectsByOrganizationIDs(ctx context.Context, ids []string) ([]Project, error)
GetProvisionerDaemonByID(ctx context.Context, id uuid.UUID) (ProvisionerDaemon, error)
GetProvisionerDaemons(ctx context.Context) ([]ProvisionerDaemon, error)
@@ -46,9 +46,9 @@ type querier interface {
InsertOrganizationMember(ctx context.Context, arg InsertOrganizationMemberParams) (OrganizationMember, error)
InsertParameterValue(ctx context.Context, arg InsertParameterValueParams) (ParameterValue, error)
InsertProject(ctx context.Context, arg InsertProjectParams) (Project, error)
InsertProjectHistory(ctx context.Context, arg InsertProjectHistoryParams) (ProjectHistory, error)
InsertProjectHistoryLogs(ctx context.Context, arg InsertProjectHistoryLogsParams) ([]ProjectHistoryLog, error)
InsertProjectParameter(ctx context.Context, arg InsertProjectParameterParams) (ProjectParameter, error)
InsertProjectVersion(ctx context.Context, arg InsertProjectVersionParams) (ProjectVersion, error)
InsertProjectVersionLogs(ctx context.Context, arg InsertProjectVersionLogsParams) ([]ProjectVersionLog, error)
InsertProvisionerDaemon(ctx context.Context, arg InsertProvisionerDaemonParams) (ProvisionerDaemon, error)
InsertProvisionerJob(ctx context.Context, arg InsertProvisionerJobParams) (ProvisionerJob, error)
InsertUser(ctx context.Context, arg InsertUserParams) (User, error)
database/query.sql
+18 -18
View File
@@ -155,46 +155,46 @@ FROM
WHERE
organization_id = ANY(@ids :: text [ ]);
-- name: GetProjectParametersByHistoryID :many
-- name: GetProjectParametersByVersionID :many
SELECT
*
FROM
project_parameter
WHERE
project_history_id = $1;
project_version_id = $1;
-- name: GetProjectHistoryByProjectID :many
-- name: GetProjectVersionByProjectID :many
SELECT
*
FROM
project_history
project_version
WHERE
project_id = $1;
-- name: GetProjectHistoryByProjectIDAndName :one
-- name: GetProjectVersionByProjectIDAndName :one
SELECT
*
FROM
project_history
project_version
WHERE
project_id = $1
AND name = $2;
-- name: GetProjectHistoryByID :one
-- name: GetProjectVersionByID :one
SELECT
*
FROM
project_history
project_version
WHERE
id = $1;
-- name: GetProjectHistoryLogsByIDBetween :many
-- name: GetProjectVersionLogsByIDBetween :many
SELECT
*
FROM
project_history_log
project_version_log
WHERE
project_history_id = @project_history_id
project_version_id = @project_version_id
AND (
created_at >= @created_after
OR created_at <= @created_before
@@ -414,9 +414,9 @@ INSERT INTO
VALUES
($1, $2, $3, $4, $5, $6) RETURNING *;
-- name: InsertProjectHistory :one
-- name: InsertProjectVersion :one
INSERT INTO
project_history (
project_version (
id,
project_id,
created_at,
@@ -430,11 +430,11 @@ INSERT INTO
VALUES
($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING *;
-- name: InsertProjectHistoryLogs :many
-- name: InsertProjectVersionLogs :many
INSERT INTO
project_history_log
project_version_log
SELECT
@project_history_id :: uuid AS project_history_id,
@project_version_id :: uuid AS project_version_id,
unnest(@id :: uuid [ ]) AS id,
unnest(@created_at :: timestamptz [ ]) AS created_at,
unnest(@source :: log_source [ ]) as source,
@@ -446,7 +446,7 @@ INSERT INTO
project_parameter (
id,
created_at,
project_history_id,
project_version_id,
name,
description,
default_source_scheme,
@@ -553,7 +553,7 @@ INSERT INTO
created_at,
updated_at,
workspace_id,
project_history_id,
project_version_id,
before_id,
name,
transition,
database/query.sql.go
+210 -210
View File
@@ -350,18 +350,68 @@ func (q *sqlQuerier) GetProjectByOrganizationAndName(ctx context.Context, arg Ge
return i, err
}
const getProjectHistoryByID = `-- name: GetProjectHistoryByID :one
const getProjectParametersByVersionID = `-- name: GetProjectParametersByVersionID :many
SELECT
id, created_at, project_version_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, default_destination_value, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type
FROM
project_parameter
WHERE
project_version_id = $1
`
func (q *sqlQuerier) GetProjectParametersByVersionID(ctx context.Context, projectVersionID uuid.UUID) ([]ProjectParameter, error) {
rows, err := q.db.QueryContext(ctx, getProjectParametersByVersionID, projectVersionID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ProjectParameter
for rows.Next() {
var i ProjectParameter
if err := rows.Scan(
&i.ID,
&i.CreatedAt,
&i.ProjectVersionID,
&i.Name,
&i.Description,
&i.DefaultSourceScheme,
&i.DefaultSourceValue,
&i.AllowOverrideSource,
&i.DefaultDestinationScheme,
&i.DefaultDestinationValue,
&i.AllowOverrideDestination,
&i.DefaultRefresh,
&i.RedisplayValue,
&i.ValidationError,
&i.ValidationCondition,
&i.ValidationTypeSystem,
&i.ValidationValueType,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getProjectVersionByID = `-- name: GetProjectVersionByID :one
SELECT
id, project_id, created_at, updated_at, name, description, storage_method, storage_source, import_job_id
FROM
project_history
project_version
WHERE
id = $1
`
func (q *sqlQuerier) GetProjectHistoryByID(ctx context.Context, id uuid.UUID) (ProjectHistory, error) {
row := q.db.QueryRowContext(ctx, getProjectHistoryByID, id)
var i ProjectHistory
func (q *sqlQuerier) GetProjectVersionByID(ctx context.Context, id uuid.UUID) (ProjectVersion, error) {
row := q.db.QueryRowContext(ctx, getProjectVersionByID, id)
var i ProjectVersion
err := row.Scan(
&i.ID,
&i.ProjectID,
@@ -376,24 +426,24 @@ func (q *sqlQuerier) GetProjectHistoryByID(ctx context.Context, id uuid.UUID) (P
return i, err
}
const getProjectHistoryByProjectID = `-- name: GetProjectHistoryByProjectID :many
const getProjectVersionByProjectID = `-- name: GetProjectVersionByProjectID :many
SELECT
id, project_id, created_at, updated_at, name, description, storage_method, storage_source, import_job_id
FROM
project_history
project_version
WHERE
project_id = $1
`
func (q *sqlQuerier) GetProjectHistoryByProjectID(ctx context.Context, projectID uuid.UUID) ([]ProjectHistory, error) {
rows, err := q.db.QueryContext(ctx, getProjectHistoryByProjectID, projectID)
func (q *sqlQuerier) GetProjectVersionByProjectID(ctx context.Context, projectID uuid.UUID) ([]ProjectVersion, error) {
rows, err := q.db.QueryContext(ctx, getProjectVersionByProjectID, projectID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ProjectHistory
var items []ProjectVersion
for rows.Next() {
var i ProjectHistory
var i ProjectVersion
if err := rows.Scan(
&i.ID,
&i.ProjectID,
@@ -418,24 +468,24 @@ func (q *sqlQuerier) GetProjectHistoryByProjectID(ctx context.Context, projectID
return items, nil
}
const getProjectHistoryByProjectIDAndName = `-- name: GetProjectHistoryByProjectIDAndName :one
const getProjectVersionByProjectIDAndName = `-- name: GetProjectVersionByProjectIDAndName :one
SELECT
id, project_id, created_at, updated_at, name, description, storage_method, storage_source, import_job_id
FROM
project_history
project_version
WHERE
project_id = $1
AND name = $2
`
type GetProjectHistoryByProjectIDAndNameParams struct {
type GetProjectVersionByProjectIDAndNameParams struct {
ProjectID uuid.UUID `db:"project_id" json:"project_id"`
Name string `db:"name" json:"name"`
}
func (q *sqlQuerier) GetProjectHistoryByProjectIDAndName(ctx context.Context, arg GetProjectHistoryByProjectIDAndNameParams) (ProjectHistory, error) {
row := q.db.QueryRowContext(ctx, getProjectHistoryByProjectIDAndName, arg.ProjectID, arg.Name)
var i ProjectHistory
func (q *sqlQuerier) GetProjectVersionByProjectIDAndName(ctx context.Context, arg GetProjectVersionByProjectIDAndNameParams) (ProjectVersion, error) {
row := q.db.QueryRowContext(ctx, getProjectVersionByProjectIDAndName, arg.ProjectID, arg.Name)
var i ProjectVersion
err := row.Scan(
&i.ID,
&i.ProjectID,
@@ -450,13 +500,13 @@ func (q *sqlQuerier) GetProjectHistoryByProjectIDAndName(ctx context.Context, ar
return i, err
}
const getProjectHistoryLogsByIDBetween = `-- name: GetProjectHistoryLogsByIDBetween :many
const getProjectVersionLogsByIDBetween = `-- name: GetProjectVersionLogsByIDBetween :many
SELECT
id, project_history_id, created_at, source, level, output
id, project_version_id, created_at, source, level, output
FROM
project_history_log
project_version_log
WHERE
project_history_id = $1
project_version_id = $1
AND (
created_at >= $2
OR created_at <= $3
@@ -465,24 +515,24 @@ ORDER BY
created_at
`
type GetProjectHistoryLogsByIDBetweenParams struct {
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
type GetProjectVersionLogsByIDBetweenParams struct {
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
CreatedAfter time.Time `db:"created_after" json:"created_after"`
CreatedBefore time.Time `db:"created_before" json:"created_before"`
}
func (q *sqlQuerier) GetProjectHistoryLogsByIDBetween(ctx context.Context, arg GetProjectHistoryLogsByIDBetweenParams) ([]ProjectHistoryLog, error) {
rows, err := q.db.QueryContext(ctx, getProjectHistoryLogsByIDBetween, arg.ProjectHistoryID, arg.CreatedAfter, arg.CreatedBefore)
func (q *sqlQuerier) GetProjectVersionLogsByIDBetween(ctx context.Context, arg GetProjectVersionLogsByIDBetweenParams) ([]ProjectVersionLog, error) {
rows, err := q.db.QueryContext(ctx, getProjectVersionLogsByIDBetween, arg.ProjectVersionID, arg.CreatedAfter, arg.CreatedBefore)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ProjectHistoryLog
var items []ProjectVersionLog
for rows.Next() {
var i ProjectHistoryLog
var i ProjectVersionLog
if err := rows.Scan(
&i.ID,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.CreatedAt,
&i.Source,
&i.Level,
@@ -501,56 +551,6 @@ func (q *sqlQuerier) GetProjectHistoryLogsByIDBetween(ctx context.Context, arg G
return items, nil
}
const getProjectParametersByHistoryID = `-- name: GetProjectParametersByHistoryID :many
SELECT
id, created_at, project_history_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, default_destination_value, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type
FROM
project_parameter
WHERE
project_history_id = $1
`
func (q *sqlQuerier) GetProjectParametersByHistoryID(ctx context.Context, projectHistoryID uuid.UUID) ([]ProjectParameter, error) {
rows, err := q.db.QueryContext(ctx, getProjectParametersByHistoryID, projectHistoryID)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ProjectParameter
for rows.Next() {
var i ProjectParameter
if err := rows.Scan(
&i.ID,
&i.CreatedAt,
&i.ProjectHistoryID,
&i.Name,
&i.Description,
&i.DefaultSourceScheme,
&i.DefaultSourceValue,
&i.AllowOverrideSource,
&i.DefaultDestinationScheme,
&i.DefaultDestinationValue,
&i.AllowOverrideDestination,
&i.DefaultRefresh,
&i.RedisplayValue,
&i.ValidationError,
&i.ValidationCondition,
&i.ValidationTypeSystem,
&i.ValidationValueType,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const getProjectsByOrganizationIDs = `-- name: GetProjectsByOrganizationIDs :many
SELECT
id, created_at, updated_at, organization_id, name, provisioner, active_version_id
@@ -870,7 +870,7 @@ func (q *sqlQuerier) GetWorkspaceByUserIDAndName(ctx context.Context, arg GetWor
const getWorkspaceHistoryByID = `-- name: GetWorkspaceHistoryByID :one
SELECT
id, created_at, updated_at, workspace_id, project_history_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
FROM
workspace_history
WHERE
@@ -887,7 +887,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByID(ctx context.Context, id uuid.UUID)
&i.CreatedAt,
&i.UpdatedAt,
&i.WorkspaceID,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.Name,
&i.BeforeID,
&i.AfterID,
@@ -901,7 +901,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByID(ctx context.Context, id uuid.UUID)
const getWorkspaceHistoryByWorkspaceID = `-- name: GetWorkspaceHistoryByWorkspaceID :many
SELECT
id, created_at, updated_at, workspace_id, project_history_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
FROM
workspace_history
WHERE
@@ -922,7 +922,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByWorkspaceID(ctx context.Context, works
&i.CreatedAt,
&i.UpdatedAt,
&i.WorkspaceID,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.Name,
&i.BeforeID,
&i.AfterID,
@@ -946,7 +946,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByWorkspaceID(ctx context.Context, works
const getWorkspaceHistoryByWorkspaceIDAndName = `-- name: GetWorkspaceHistoryByWorkspaceIDAndName :one
SELECT
id, created_at, updated_at, workspace_id, project_history_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
FROM
workspace_history
WHERE
@@ -967,7 +967,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByWorkspaceIDAndName(ctx context.Context
&i.CreatedAt,
&i.UpdatedAt,
&i.WorkspaceID,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.Name,
&i.BeforeID,
&i.AfterID,
@@ -981,7 +981,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByWorkspaceIDAndName(ctx context.Context
const getWorkspaceHistoryByWorkspaceIDWithoutAfter = `-- name: GetWorkspaceHistoryByWorkspaceIDWithoutAfter :one
SELECT
id, created_at, updated_at, workspace_id, project_history_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
FROM
workspace_history
WHERE
@@ -999,7 +999,7 @@ func (q *sqlQuerier) GetWorkspaceHistoryByWorkspaceIDWithoutAfter(ctx context.Co
&i.CreatedAt,
&i.UpdatedAt,
&i.WorkspaceID,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.Name,
&i.BeforeID,
&i.AfterID,
@@ -1466,126 +1466,12 @@ func (q *sqlQuerier) InsertProject(ctx context.Context, arg InsertProjectParams)
return i, err
}
const insertProjectHistory = `-- name: InsertProjectHistory :one
INSERT INTO
project_history (
id,
project_id,
created_at,
updated_at,
name,
description,
storage_method,
storage_source,
import_job_id
)
VALUES
($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id, project_id, created_at, updated_at, name, description, storage_method, storage_source, import_job_id
`
type InsertProjectHistoryParams struct {
ID uuid.UUID `db:"id" json:"id"`
ProjectID uuid.UUID `db:"project_id" json:"project_id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
Name string `db:"name" json:"name"`
Description string `db:"description" json:"description"`
StorageMethod ProjectStorageMethod `db:"storage_method" json:"storage_method"`
StorageSource []byte `db:"storage_source" json:"storage_source"`
ImportJobID uuid.UUID `db:"import_job_id" json:"import_job_id"`
}
func (q *sqlQuerier) InsertProjectHistory(ctx context.Context, arg InsertProjectHistoryParams) (ProjectHistory, error) {
row := q.db.QueryRowContext(ctx, insertProjectHistory,
arg.ID,
arg.ProjectID,
arg.CreatedAt,
arg.UpdatedAt,
arg.Name,
arg.Description,
arg.StorageMethod,
arg.StorageSource,
arg.ImportJobID,
)
var i ProjectHistory
err := row.Scan(
&i.ID,
&i.ProjectID,
&i.CreatedAt,
&i.UpdatedAt,
&i.Name,
&i.Description,
&i.StorageMethod,
&i.StorageSource,
&i.ImportJobID,
)
return i, err
}
const insertProjectHistoryLogs = `-- name: InsertProjectHistoryLogs :many
INSERT INTO
project_history_log
SELECT
$1 :: uuid AS project_history_id,
unnest($2 :: uuid [ ]) AS id,
unnest($3 :: timestamptz [ ]) AS created_at,
unnest($4 :: log_source [ ]) as source,
unnest($5 :: log_level [ ]) as level,
unnest($6 :: varchar(1024) [ ]) as output RETURNING id, project_history_id, created_at, source, level, output
`
type InsertProjectHistoryLogsParams struct {
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
ID []uuid.UUID `db:"id" json:"id"`
CreatedAt []time.Time `db:"created_at" json:"created_at"`
Source []LogSource `db:"source" json:"source"`
Level []LogLevel `db:"level" json:"level"`
Output []string `db:"output" json:"output"`
}
func (q *sqlQuerier) InsertProjectHistoryLogs(ctx context.Context, arg InsertProjectHistoryLogsParams) ([]ProjectHistoryLog, error) {
rows, err := q.db.QueryContext(ctx, insertProjectHistoryLogs,
arg.ProjectHistoryID,
pq.Array(arg.ID),
pq.Array(arg.CreatedAt),
pq.Array(arg.Source),
pq.Array(arg.Level),
pq.Array(arg.Output),
)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ProjectHistoryLog
for rows.Next() {
var i ProjectHistoryLog
if err := rows.Scan(
&i.ID,
&i.ProjectHistoryID,
&i.CreatedAt,
&i.Source,
&i.Level,
&i.Output,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const insertProjectParameter = `-- name: InsertProjectParameter :one
INSERT INTO
project_parameter (
id,
created_at,
project_history_id,
project_version_id,
name,
description,
default_source_scheme,
@@ -1620,13 +1506,13 @@ VALUES
$15,
$16,
$17
) RETURNING id, created_at, project_history_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, default_destination_value, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type
) RETURNING id, created_at, project_version_id, name, description, default_source_scheme, default_source_value, allow_override_source, default_destination_scheme, default_destination_value, allow_override_destination, default_refresh, redisplay_value, validation_error, validation_condition, validation_type_system, validation_value_type
`
type InsertProjectParameterParams struct {
ID uuid.UUID `db:"id" json:"id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
Name string `db:"name" json:"name"`
Description string `db:"description" json:"description"`
DefaultSourceScheme ParameterSourceScheme `db:"default_source_scheme" json:"default_source_scheme"`
@@ -1647,7 +1533,7 @@ func (q *sqlQuerier) InsertProjectParameter(ctx context.Context, arg InsertProje
row := q.db.QueryRowContext(ctx, insertProjectParameter,
arg.ID,
arg.CreatedAt,
arg.ProjectHistoryID,
arg.ProjectVersionID,
arg.Name,
arg.Description,
arg.DefaultSourceScheme,
@@ -1667,7 +1553,7 @@ func (q *sqlQuerier) InsertProjectParameter(ctx context.Context, arg InsertProje
err := row.Scan(
&i.ID,
&i.CreatedAt,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.Name,
&i.Description,
&i.DefaultSourceScheme,
@@ -1686,6 +1572,120 @@ func (q *sqlQuerier) InsertProjectParameter(ctx context.Context, arg InsertProje
return i, err
}
const insertProjectVersion = `-- name: InsertProjectVersion :one
INSERT INTO
project_version (
id,
project_id,
created_at,
updated_at,
name,
description,
storage_method,
storage_source,
import_job_id
)
VALUES
($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING id, project_id, created_at, updated_at, name, description, storage_method, storage_source, import_job_id
`
type InsertProjectVersionParams struct {
ID uuid.UUID `db:"id" json:"id"`
ProjectID uuid.UUID `db:"project_id" json:"project_id"`
CreatedAt time.Time `db:"created_at" json:"created_at"`
UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
Name string `db:"name" json:"name"`
Description string `db:"description" json:"description"`
StorageMethod ProjectStorageMethod `db:"storage_method" json:"storage_method"`
StorageSource []byte `db:"storage_source" json:"storage_source"`
ImportJobID uuid.UUID `db:"import_job_id" json:"import_job_id"`
}
func (q *sqlQuerier) InsertProjectVersion(ctx context.Context, arg InsertProjectVersionParams) (ProjectVersion, error) {
row := q.db.QueryRowContext(ctx, insertProjectVersion,
arg.ID,
arg.ProjectID,
arg.CreatedAt,
arg.UpdatedAt,
arg.Name,
arg.Description,
arg.StorageMethod,
arg.StorageSource,
arg.ImportJobID,
)
var i ProjectVersion
err := row.Scan(
&i.ID,
&i.ProjectID,
&i.CreatedAt,
&i.UpdatedAt,
&i.Name,
&i.Description,
&i.StorageMethod,
&i.StorageSource,
&i.ImportJobID,
)
return i, err
}
const insertProjectVersionLogs = `-- name: InsertProjectVersionLogs :many
INSERT INTO
project_version_log
SELECT
$1 :: uuid AS project_version_id,
unnest($2 :: uuid [ ]) AS id,
unnest($3 :: timestamptz [ ]) AS created_at,
unnest($4 :: log_source [ ]) as source,
unnest($5 :: log_level [ ]) as level,
unnest($6 :: varchar(1024) [ ]) as output RETURNING id, project_version_id, created_at, source, level, output
`
type InsertProjectVersionLogsParams struct {
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
ID []uuid.UUID `db:"id" json:"id"`
CreatedAt []time.Time `db:"created_at" json:"created_at"`
Source []LogSource `db:"source" json:"source"`
Level []LogLevel `db:"level" json:"level"`
Output []string `db:"output" json:"output"`
}
func (q *sqlQuerier) InsertProjectVersionLogs(ctx context.Context, arg InsertProjectVersionLogsParams) ([]ProjectVersionLog, error) {
rows, err := q.db.QueryContext(ctx, insertProjectVersionLogs,
arg.ProjectVersionID,
pq.Array(arg.ID),
pq.Array(arg.CreatedAt),
pq.Array(arg.Source),
pq.Array(arg.Level),
pq.Array(arg.Output),
)
if err != nil {
return nil, err
}
defer rows.Close()
var items []ProjectVersionLog
for rows.Next() {
var i ProjectVersionLog
if err := rows.Scan(
&i.ID,
&i.ProjectVersionID,
&i.CreatedAt,
&i.Source,
&i.Level,
&i.Output,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const insertProvisionerDaemon = `-- name: InsertProvisionerDaemon :one
INSERT INTO
provisioner_daemon (id, created_at, name, provisioners)
@@ -1934,7 +1934,7 @@ INSERT INTO
created_at,
updated_at,
workspace_id,
project_history_id,
project_version_id,
before_id,
name,
transition,
@@ -1943,7 +1943,7 @@ INSERT INTO
provisioner_state
)
VALUES
($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_history_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, created_at, updated_at, workspace_id, project_version_id, name, before_id, after_id, transition, initiator, provisioner_state, provision_job_id
`
type InsertWorkspaceHistoryParams struct {
@@ -1951,7 +1951,7 @@ type InsertWorkspaceHistoryParams struct {
CreatedAt time.Time `db:"created_at" json:"created_at"`
UpdatedAt time.Time `db:"updated_at" json:"updated_at"`
WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"`
ProjectHistoryID uuid.UUID `db:"project_history_id" json:"project_history_id"`
ProjectVersionID uuid.UUID `db:"project_version_id" json:"project_version_id"`
BeforeID uuid.NullUUID `db:"before_id" json:"before_id"`
Name string `db:"name" json:"name"`
Transition WorkspaceTransition `db:"transition" json:"transition"`
@@ -1966,7 +1966,7 @@ func (q *sqlQuerier) InsertWorkspaceHistory(ctx context.Context, arg InsertWorks
arg.CreatedAt,
arg.UpdatedAt,
arg.WorkspaceID,
arg.ProjectHistoryID,
arg.ProjectVersionID,
arg.BeforeID,
arg.Name,
arg.Transition,
@@ -1980,7 +1980,7 @@ func (q *sqlQuerier) InsertWorkspaceHistory(ctx context.Context, arg InsertWorks
&i.CreatedAt,
&i.UpdatedAt,
&i.WorkspaceID,
&i.ProjectHistoryID,
&i.ProjectVersionID,
&i.Name,
&i.BeforeID,
&i.AfterID,
httpmw/projecthistoryparam.go
-60
View File
@@ -1,60 +0,0 @@
package httpmw
import (
"context"
"database/sql"
"errors"
"fmt"
"net/http"
"github.com/go-chi/chi/v5"
"github.com/coder/coder/database"
"github.com/coder/coder/httpapi"
)
type projectHistoryParamContextKey struct{}
// ProjectHistoryParam returns the project history from the ExtractProjectHistoryParam handler.
func ProjectHistoryParam(r *http.Request) database.ProjectHistory {
projectHistory, ok := r.Context().Value(projectHistoryParamContextKey{}).(database.ProjectHistory)
if !ok {
panic("developer error: project history param middleware not provided")
}
return projectHistory
}
// ExtractProjectHistoryParam grabs project history from the "projecthistory" URL parameter.
func ExtractProjectHistoryParam(db database.Store) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
project := ProjectParam(r)
projectHistoryName := chi.URLParam(r, "projecthistory")
if projectHistoryName == "" {
httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
Message: "project history name must be provided",
})
return
}
projectHistory, err := db.GetProjectHistoryByProjectIDAndName(r.Context(), database.GetProjectHistoryByProjectIDAndNameParams{
ProjectID: project.ID,
Name: projectHistoryName,
})
if errors.Is(err, sql.ErrNoRows) {
httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
Message: fmt.Sprintf("project history %q does not exist", projectHistoryName),
})
return
}
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get project history: %s", err.Error()),
})
return
}
ctx := context.WithValue(r.Context(), projectHistoryParamContextKey{}, projectHistory)
next.ServeHTTP(rw, r.WithContext(ctx))
})
}
}
httpmw/projectversionparam.go
+60
View File
@@ -0,0 +1,60 @@
package httpmw
import (
"context"
"database/sql"
"errors"
"fmt"
"net/http"
"github.com/go-chi/chi/v5"
"github.com/coder/coder/database"
"github.com/coder/coder/httpapi"
)
type projectVersionParamContextKey struct{}
// ProjectVersionParam returns the project version from the ExtractProjectVersionParam handler.
func ProjectVersionParam(r *http.Request) database.ProjectVersion {
projectVersion, ok := r.Context().Value(projectVersionParamContextKey{}).(database.ProjectVersion)
if !ok {
panic("developer error: project version param middleware not provided")
}
return projectVersion
}
// ExtractProjectVersionParam grabs project version from the "projectversion" URL parameter.
func ExtractProjectVersionParam(db database.Store) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
project := ProjectParam(r)
projectVersionName := chi.URLParam(r, "projectversion")
if projectVersionName == "" {
httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{
Message: "project version name must be provided",
})
return
}
projectVersion, err := db.GetProjectVersionByProjectIDAndName(r.Context(), database.GetProjectVersionByProjectIDAndNameParams{
ProjectID: project.ID,
Name: projectVersionName,
})
if errors.Is(err, sql.ErrNoRows) {
httpapi.Write(rw, http.StatusNotFound, httpapi.Response{
Message: fmt.Sprintf("project version %q does not exist", projectVersionName),
})
return
}
if err != nil {
httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
Message: fmt.Sprintf("get project version: %s", err.Error()),
})
return
}
ctx := context.WithValue(r.Context(), projectVersionParamContextKey{}, projectVersion)
next.ServeHTTP(rw, r.WithContext(ctx))
})
}
}
httpmw/projecthistoryparam_test.go → httpmw/projectversionparam_test.go
+9 -9
View File
@@ -19,7 +19,7 @@ import (
"github.com/coder/coder/httpmw"
)
func TestProjectHistoryParam(t *testing.T) {
func TestProjectVersionParam(t *testing.T) {
t.Parallel()
setupAuthentication := func(db database.Store) (*http.Request, database.Project) {
@@ -94,7 +94,7 @@ func TestProjectHistoryParam(t *testing.T) {
httpmw.ExtractAPIKey(db, nil),
httpmw.ExtractOrganizationParam(db),
httpmw.ExtractProjectParam(db),
httpmw.ExtractProjectHistoryParam(db),
httpmw.ExtractProjectVersionParam(db),
)
rtr.Get("/", nil)
r, _ := setupAuthentication(db)
@@ -114,12 +114,12 @@ func TestProjectHistoryParam(t *testing.T) {
httpmw.ExtractAPIKey(db, nil),
httpmw.ExtractOrganizationParam(db),
httpmw.ExtractProjectParam(db),
httpmw.ExtractProjectHistoryParam(db),
httpmw.ExtractProjectVersionParam(db),
)
rtr.Get("/", nil)
r, _ := setupAuthentication(db)
chi.RouteContext(r.Context()).URLParams.Add("projecthistory", "nothin")
chi.RouteContext(r.Context()).URLParams.Add("projectversion", "nothin")
rw := httptest.NewRecorder()
rtr.ServeHTTP(rw, r)
@@ -128,7 +128,7 @@ func TestProjectHistoryParam(t *testing.T) {
require.Equal(t, http.StatusNotFound, res.StatusCode)
})
t.Run("ProjectHistory", func(t *testing.T) {
t.Run("ProjectVersion", func(t *testing.T) {
t.Parallel()
db := databasefake.New()
rtr := chi.NewRouter()
@@ -136,21 +136,21 @@ func TestProjectHistoryParam(t *testing.T) {
httpmw.ExtractAPIKey(db, nil),
httpmw.ExtractOrganizationParam(db),
httpmw.ExtractProjectParam(db),
httpmw.ExtractProjectHistoryParam(db),
httpmw.ExtractProjectVersionParam(db),
)
rtr.Get("/", func(rw http.ResponseWriter, r *http.Request) {
_ = httpmw.ProjectHistoryParam(r)
_ = httpmw.ProjectVersionParam(r)
rw.WriteHeader(http.StatusOK)
})
r, project := setupAuthentication(db)
projectHistory, err := db.InsertProjectHistory(context.Background(), database.InsertProjectHistoryParams{
projectVersion, err := db.InsertProjectVersion(context.Background(), database.InsertProjectVersionParams{
ID: uuid.New(),
ProjectID: project.ID,
Name: "moo",
})
require.NoError(t, err)
chi.RouteContext(r.Context()).URLParams.Add("projecthistory", projectHistory.Name)
chi.RouteContext(r.Context()).URLParams.Add("projectversion", projectVersion.Name)
rw := httptest.NewRecorder()
rtr.ServeHTTP(rw, r)
provisionerd/proto/provisionerd.pb.go
Generated
+12 -12
View File
@@ -602,8 +602,8 @@ type AcquiredJob_ProjectImport struct {
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ProjectHistoryId string `protobuf:"bytes,1,opt,name=project_history_id,json=projectHistoryId,proto3" json:"project_history_id,omitempty"`
ProjectHistoryName string `protobuf:"bytes,2,opt,name=project_history_name,json=projectHistoryName,proto3" json:"project_history_name,omitempty"`
ProjectVersionId string `protobuf:"bytes,1,opt,name=project_version_id,json=projectVersionId,proto3" json:"project_version_id,omitempty"`
ProjectVersionName string `protobuf:"bytes,2,opt,name=project_version_name,json=projectVersionName,proto3" json:"project_version_name,omitempty"`
}
func (x *AcquiredJob_ProjectImport) Reset() {
@@ -638,16 +638,16 @@ func (*AcquiredJob_ProjectImport) Descriptor() ([]byte, []int) {
return file_provisionerd_proto_provisionerd_proto_rawDescGZIP(), []int{1, 1}
}
func (x *AcquiredJob_ProjectImport) GetProjectHistoryId() string {
func (x *AcquiredJob_ProjectImport) GetProjectVersionId() string {
if x != nil {
return x.ProjectHistoryId
return x.ProjectVersionId
}
return ""
}
func (x *AcquiredJob_ProjectImport) GetProjectHistoryName() string {
func (x *AcquiredJob_ProjectImport) GetProjectVersionName() string {
if x != nil {
return x.ProjectHistoryName
return x.ProjectVersionName
}
return ""
}
@@ -805,12 +805,12 @@ var file_provisionerd_proto_provisionerd_proto_rawDesc = []byte{
0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05,
0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x73, 0x74, 0x61,
0x74, 0x65, 0x1a, 0x6f, 0x0a, 0x0d, 0x50, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x49, 0x6d, 0x70,
0x6f, 0x72, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x68,
0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x10, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x49,
0x64, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x68, 0x69, 0x73,
0x74, 0x6f, 0x72, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x12, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x4e,
0x6f, 0x72, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x76,
0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
0x10, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49,
0x64, 0x12, 0x30, 0x0a, 0x14, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x76, 0x65, 0x72,
0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x12, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4e,
0x61, 0x6d, 0x65, 0x42, 0x06, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x3b, 0x0a, 0x0c, 0x43,
0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x65, 0x64, 0x4a, 0x6f, 0x62, 0x12, 0x15, 0x0a, 0x06, 0x6a,
0x6f, 0x62, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6a, 0x6f, 0x62,
provisionerd/proto/provisionerd.proto
+2 -2
View File
@@ -18,8 +18,8 @@ message AcquiredJob {
bytes state = 4;
}
message ProjectImport {
string project_history_id = 1;
string project_history_name = 2;
string project_version_id = 1;
string project_version_name = 2;
}
string job_id = 1;
int64 created_at = 2;
provisionerd/provisionerd.go
+2 -2
View File
@@ -318,7 +318,7 @@ func (p *provisionerDaemon) runJob(ctx context.Context, job *proto.AcquiredJob)
switch jobType := job.Type.(type) {
case *proto.AcquiredJob_ProjectImport_:
p.opts.Logger.Debug(context.Background(), "acquired job is project import",
slog.F("project_history_name", jobType.ProjectImport.ProjectHistoryName),
slog.F("project_version_name", jobType.ProjectImport.ProjectVersionName),
)
p.runProjectImport(ctx, provisioner, job)
@@ -362,7 +362,7 @@ func (p *provisionerDaemon) runProjectImport(ctx context.Context, provisioner sd
p.opts.Logger.Debug(context.Background(), "parse job logged",
slog.F("level", msgType.Log.Level),
slog.F("output", msgType.Log.Output),
slog.F("project_history_id", job.GetProjectImport().ProjectHistoryId),
slog.F("project_version_id", job.GetProjectImport().ProjectVersionId),
)
err = p.updateStream.Send(&proto.JobUpdate{