Method SetRepository

internal/server/server.go:602–657

SetRepository sets the repository (nil is allowed and indicates server that is not connected to the repository).

(ctx context.Context, rep repo.Repository)

// SetRepository sets the repository (nil is allowed and indicates server that is not
// connected to the repository).
func (s *Server) SetRepository(ctx context.Context, rep repo.Repository) error {
	s.serverMutex.Lock()
	defer s.serverMutex.Unlock()

	if s.rep == rep {
		// nothing to do
		return nil
	}

	if s.rep != nil {
		// stop previous scheduler asynchronously to avoid deadlock when
		// scheduler is inside s.getSchedulerItems which needs a lock, which we're holding right now.
		go s.sched.Stop()

		s.sched = nil

		s.unmountAllLocked(ctx)

		// close previous source managers
		userLog(ctx).Debug("stopping all source managers")
		s.stopAllSourceManagersLocked(ctx)
		userLog(ctx).Debug("stopped all source managers")

		if err := s.rep.Close(ctx); err != nil {
			return errors.Wrap(err, "unable to close previous repository")
		}

		// stop maintenance manager
		if s.maint != nil {
			s.maint.stop(ctx)
			s.maint = nil
		}
	}

	s.rep = rep
	if s.rep == nil {
		return nil
	}

	if err := s.syncSourcesLocked(ctx); err != nil {
		s.stopAllSourceManagersLocked(ctx)
		s.rep = nil

		return err
	}

	s.maint = maybeStartMaintenanceManager(ctx, s.rep, s, s.options.MinMaintenanceInterval)

	s.sched = scheduler.Start(context.WithoutCancel(ctx), s.getSchedulerItems, scheduler.Options{
		TimeNow:        clock.Now,
		Debug:          s.options.DebugScheduler,
		RefreshChannel: s.schedulerRefresh,
	})

	return nil
}

// +checklocks:s.serverMutex