synced/coder
1
0
Fork 0
mirror of https://github.com/coder/coder.git synced 2025-07-06 15:41:45 +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

16
coderd/coderd.go
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) {

52
coderd/projectparameter/projectparameter.go
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

18
coderd/projectparameter/projectparameter_test.go
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(),

8
coderd/projects_test.go
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)

86
coderd/projecthistory.go → coderd/projectversion.go
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)
}

16
coderd/projecthistory_test.go → coderd/projectversion_test.go
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{},
})

34
coderd/provisionerdaemons.go
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,

30
coderd/workspacehistory.go
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,

32
coderd/workspacehistory_test.go
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)

12
coderd/workspacehistorylogs_test.go
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)