github.com/mutagen-io/mutagen@v0.18.0-rc1/pkg/service/synchronization/server.go (about)

     1  package synchronization
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  
     7  	"github.com/mutagen-io/mutagen/pkg/synchronization"
     8  )
     9  
    10  // Server provides an implementation of the Synchronization service.
    11  type Server struct {
    12  	// UnimplementedSynchronizationServer is the required base implementation.
    13  	UnimplementedSynchronizationServer
    14  	// manager is the underlying session manager.
    15  	manager *synchronization.Manager
    16  }
    17  
    18  // NewServer creates a new session server.
    19  func NewServer(manager *synchronization.Manager) *Server {
    20  	return &Server{
    21  		manager: manager,
    22  	}
    23  }
    24  
    25  // Create creates a new session.
    26  func (s *Server) Create(ctx context.Context, request *CreateRequest) (*CreateResponse, error) {
    27  	// Validate the request.
    28  	if err := request.ensureValid(); err != nil {
    29  		return nil, fmt.Errorf("invalid create request: %w", err)
    30  	}
    31  
    32  	// Perform creation.
    33  	session, err := s.manager.Create(
    34  		ctx,
    35  		request.Specification.Alpha,
    36  		request.Specification.Beta,
    37  		request.Specification.Configuration,
    38  		request.Specification.ConfigurationAlpha,
    39  		request.Specification.ConfigurationBeta,
    40  		request.Specification.Name,
    41  		request.Specification.Labels,
    42  		request.Specification.Paused,
    43  		request.Prompter,
    44  	)
    45  	if err != nil {
    46  		return nil, err
    47  	}
    48  
    49  	// Success.
    50  	return &CreateResponse{Session: session}, nil
    51  }
    52  
    53  // List queries session status.
    54  func (s *Server) List(ctx context.Context, request *ListRequest) (*ListResponse, error) {
    55  	// Validate the request.
    56  	if err := request.ensureValid(); err != nil {
    57  		return nil, fmt.Errorf("invalid list request: %w", err)
    58  	}
    59  
    60  	// Perform listing.
    61  	stateIndex, states, err := s.manager.List(ctx, request.Selection, request.PreviousStateIndex)
    62  	if err != nil {
    63  		return nil, err
    64  	}
    65  
    66  	// Success.
    67  	return &ListResponse{
    68  		StateIndex:    stateIndex,
    69  		SessionStates: states,
    70  	}, nil
    71  }
    72  
    73  // Flush flushes sessions.
    74  func (s *Server) Flush(ctx context.Context, request *FlushRequest) (*FlushResponse, error) {
    75  	// Validate the request.
    76  	if err := request.ensureValid(); err != nil {
    77  		return nil, fmt.Errorf("invalid flush request: %w", err)
    78  	}
    79  
    80  	// Perform flushing.
    81  	if err := s.manager.Flush(ctx, request.Selection, request.Prompter, request.SkipWait); err != nil {
    82  		return nil, err
    83  	}
    84  
    85  	// Success.
    86  	return &FlushResponse{}, nil
    87  }
    88  
    89  // Pause pauses sessions.
    90  func (s *Server) Pause(ctx context.Context, request *PauseRequest) (*PauseResponse, error) {
    91  	// Validate the request.
    92  	if err := request.ensureValid(); err != nil {
    93  		return nil, fmt.Errorf("invalid pause request: %w", err)
    94  	}
    95  
    96  	// Perform pausing.
    97  	if err := s.manager.Pause(ctx, request.Selection, request.Prompter); err != nil {
    98  		return nil, err
    99  	}
   100  
   101  	// Success.
   102  	return &PauseResponse{}, nil
   103  }
   104  
   105  // Resume resumes sessions.
   106  func (s *Server) Resume(ctx context.Context, request *ResumeRequest) (*ResumeResponse, error) {
   107  	// Validate the request.
   108  	if err := request.ensureValid(); err != nil {
   109  		return nil, fmt.Errorf("invalid resume request: %w", err)
   110  	}
   111  
   112  	// Perform resuming.
   113  	if err := s.manager.Resume(ctx, request.Selection, request.Prompter); err != nil {
   114  		return nil, err
   115  	}
   116  
   117  	// Success.
   118  	return &ResumeResponse{}, nil
   119  }
   120  
   121  // Reset resets sessions.
   122  func (s *Server) Reset(ctx context.Context, request *ResetRequest) (*ResetResponse, error) {
   123  	// Validate the request.
   124  	if err := request.ensureValid(); err != nil {
   125  		return nil, fmt.Errorf("invalid reset request: %w", err)
   126  	}
   127  
   128  	// Perform resuming.
   129  	if err := s.manager.Reset(ctx, request.Selection, request.Prompter); err != nil {
   130  		return nil, err
   131  	}
   132  
   133  	// Success.
   134  	return &ResetResponse{}, nil
   135  }
   136  
   137  // Terminate terminates sessions.
   138  func (s *Server) Terminate(ctx context.Context, request *TerminateRequest) (*TerminateResponse, error) {
   139  	// Validate the request.
   140  	if err := request.ensureValid(); err != nil {
   141  		return nil, fmt.Errorf("invalid terminate request: %w", err)
   142  	}
   143  
   144  	// Perform termination.
   145  	if err := s.manager.Terminate(ctx, request.Selection, request.Prompter); err != nil {
   146  		return nil, err
   147  	}
   148  
   149  	// Success.
   150  	return &TerminateResponse{}, nil
   151  }