github.com/google/go-github/v74@v74.0.0/github/enterprise_actions_hosted_runners.go (about)

     1  // Copyright 2025 The go-github AUTHORS. All rights reserved.
     2  //
     3  // Use of this source code is governed by a BSD-style
     4  // license that can be found in the LICENSE file.
     5  
     6  package github
     7  
     8  import (
     9  	"context"
    10  	"fmt"
    11  )
    12  
    13  // ListHostedRunners lists all the GitHub-hosted runners for an enterprise.
    14  //
    15  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#list-github-hosted-runners-for-an-enterprise
    16  //
    17  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners
    18  func (s *EnterpriseService) ListHostedRunners(ctx context.Context, enterprise string, opts *ListOptions) (*HostedRunners, *Response, error) {
    19  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners", enterprise)
    20  	u, err := addOptions(u, opts)
    21  	if err != nil {
    22  		return nil, nil, err
    23  	}
    24  
    25  	req, err := s.client.NewRequest("GET", u, nil)
    26  	if err != nil {
    27  		return nil, nil, err
    28  	}
    29  
    30  	runners := &HostedRunners{}
    31  	resp, err := s.client.Do(ctx, req, &runners)
    32  	if err != nil {
    33  		return nil, resp, err
    34  	}
    35  
    36  	return runners, resp, nil
    37  }
    38  
    39  // CreateHostedRunner creates a GitHub-hosted runner for an enterprise.
    40  //
    41  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#create-a-github-hosted-runner-for-an-enterprise
    42  //
    43  //meta:operation POST /enterprises/{enterprise}/actions/hosted-runners
    44  func (s *EnterpriseService) CreateHostedRunner(ctx context.Context, enterprise string, request *HostedRunnerRequest) (*HostedRunner, *Response, error) {
    45  	if err := validateCreateHostedRunnerRequest(request); err != nil {
    46  		return nil, nil, fmt.Errorf("validation failed: %w", err)
    47  	}
    48  
    49  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners", enterprise)
    50  	req, err := s.client.NewRequest("POST", u, request)
    51  	if err != nil {
    52  		return nil, nil, err
    53  	}
    54  
    55  	hostedRunner := new(HostedRunner)
    56  	resp, err := s.client.Do(ctx, req, hostedRunner)
    57  	if err != nil {
    58  		return nil, resp, err
    59  	}
    60  
    61  	return hostedRunner, resp, nil
    62  }
    63  
    64  // GetHostedRunnerGitHubOwnedImages gets the list of GitHub-owned images available for GitHub-hosted runners for an enterprise.
    65  //
    66  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-github-owned-images-for-github-hosted-runners-in-an-enterprise
    67  //
    68  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/images/github-owned
    69  func (s *EnterpriseService) GetHostedRunnerGitHubOwnedImages(ctx context.Context, enterprise string) (*HostedRunnerImages, *Response, error) {
    70  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/github-owned", enterprise)
    71  	req, err := s.client.NewRequest("GET", u, nil)
    72  	if err != nil {
    73  		return nil, nil, err
    74  	}
    75  
    76  	hostedRunnerImages := new(HostedRunnerImages)
    77  	resp, err := s.client.Do(ctx, req, hostedRunnerImages)
    78  	if err != nil {
    79  		return nil, resp, err
    80  	}
    81  
    82  	return hostedRunnerImages, resp, nil
    83  }
    84  
    85  // GetHostedRunnerPartnerImages gets the list of partner images available for GitHub-hosted runners for an enterprise.
    86  //
    87  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-partner-images-for-github-hosted-runners-in-an-enterprise
    88  //
    89  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/images/partner
    90  func (s *EnterpriseService) GetHostedRunnerPartnerImages(ctx context.Context, enterprise string) (*HostedRunnerImages, *Response, error) {
    91  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/partner", enterprise)
    92  	req, err := s.client.NewRequest("GET", u, nil)
    93  	if err != nil {
    94  		return nil, nil, err
    95  	}
    96  
    97  	hostedRunnerImages := new(HostedRunnerImages)
    98  	resp, err := s.client.Do(ctx, req, hostedRunnerImages)
    99  	if err != nil {
   100  		return nil, resp, err
   101  	}
   102  
   103  	return hostedRunnerImages, resp, nil
   104  }
   105  
   106  // GetHostedRunnerLimits gets the GitHub-hosted runners Static public IP Limits for an enterprise.
   107  //
   108  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-limits-on-github-hosted-runners-for-an-enterprise
   109  //
   110  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/limits
   111  func (s *EnterpriseService) GetHostedRunnerLimits(ctx context.Context, enterprise string) (*HostedRunnerPublicIPLimits, *Response, error) {
   112  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/limits", enterprise)
   113  	req, err := s.client.NewRequest("GET", u, nil)
   114  	if err != nil {
   115  		return nil, nil, err
   116  	}
   117  
   118  	publicIPLimits := new(HostedRunnerPublicIPLimits)
   119  	resp, err := s.client.Do(ctx, req, publicIPLimits)
   120  	if err != nil {
   121  		return nil, resp, err
   122  	}
   123  
   124  	return publicIPLimits, resp, nil
   125  }
   126  
   127  // GetHostedRunnerMachineSpecs gets the list of machine specs available for GitHub-hosted runners for an enterprise.
   128  //
   129  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-github-hosted-runners-machine-specs-for-an-enterprise
   130  //
   131  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/machine-sizes
   132  func (s *EnterpriseService) GetHostedRunnerMachineSpecs(ctx context.Context, enterprise string) (*HostedRunnerMachineSpecs, *Response, error) {
   133  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/machine-sizes", enterprise)
   134  	req, err := s.client.NewRequest("GET", u, nil)
   135  	if err != nil {
   136  		return nil, nil, err
   137  	}
   138  
   139  	machineSpecs := new(HostedRunnerMachineSpecs)
   140  	resp, err := s.client.Do(ctx, req, machineSpecs)
   141  	if err != nil {
   142  		return nil, resp, err
   143  	}
   144  
   145  	return machineSpecs, resp, nil
   146  }
   147  
   148  // GetHostedRunnerPlatforms gets list of platforms available for GitHub-hosted runners for an enterprise.
   149  //
   150  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-platforms-for-github-hosted-runners-in-an-enterprise
   151  //
   152  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/platforms
   153  func (s *EnterpriseService) GetHostedRunnerPlatforms(ctx context.Context, enterprise string) (*HostedRunnerPlatforms, *Response, error) {
   154  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/platforms", enterprise)
   155  	req, err := s.client.NewRequest("GET", u, nil)
   156  	if err != nil {
   157  		return nil, nil, err
   158  	}
   159  
   160  	platforms := new(HostedRunnerPlatforms)
   161  	resp, err := s.client.Do(ctx, req, platforms)
   162  	if err != nil {
   163  		return nil, resp, err
   164  	}
   165  
   166  	return platforms, resp, nil
   167  }
   168  
   169  // GetHostedRunner gets a GitHub-hosted runner in an enterprise.
   170  //
   171  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-a-github-hosted-runner-for-an-enterprise
   172  //
   173  //meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/{hosted_runner_id}
   174  func (s *EnterpriseService) GetHostedRunner(ctx context.Context, enterprise string, runnerID int64) (*HostedRunner, *Response, error) {
   175  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/%v", enterprise, runnerID)
   176  	req, err := s.client.NewRequest("GET", u, nil)
   177  	if err != nil {
   178  		return nil, nil, err
   179  	}
   180  
   181  	hostedRunner := new(HostedRunner)
   182  	resp, err := s.client.Do(ctx, req, hostedRunner)
   183  	if err != nil {
   184  		return nil, resp, err
   185  	}
   186  
   187  	return hostedRunner, resp, nil
   188  }
   189  
   190  // UpdateHostedRunner updates a GitHub-hosted runner for an enterprise.
   191  //
   192  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#update-a-github-hosted-runner-for-an-enterprise
   193  //
   194  //meta:operation PATCH /enterprises/{enterprise}/actions/hosted-runners/{hosted_runner_id}
   195  func (s *EnterpriseService) UpdateHostedRunner(ctx context.Context, enterprise string, runnerID int64, updateReq HostedRunnerRequest) (*HostedRunner, *Response, error) {
   196  	if err := validateUpdateHostedRunnerRequest(&updateReq); err != nil {
   197  		return nil, nil, fmt.Errorf("validation failed: %w", err)
   198  	}
   199  
   200  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/%v", enterprise, runnerID)
   201  	req, err := s.client.NewRequest("PATCH", u, updateReq)
   202  	if err != nil {
   203  		return nil, nil, err
   204  	}
   205  
   206  	hostedRunner := new(HostedRunner)
   207  	resp, err := s.client.Do(ctx, req, hostedRunner)
   208  	if err != nil {
   209  		return nil, resp, err
   210  	}
   211  
   212  	return hostedRunner, resp, nil
   213  }
   214  
   215  // DeleteHostedRunner deletes GitHub-hosted runner from an enterprise.
   216  //
   217  // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#delete-a-github-hosted-runner-for-an-enterprise
   218  //
   219  //meta:operation DELETE /enterprises/{enterprise}/actions/hosted-runners/{hosted_runner_id}
   220  func (s *EnterpriseService) DeleteHostedRunner(ctx context.Context, enterprise string, runnerID int64) (*HostedRunner, *Response, error) {
   221  	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/%v", enterprise, runnerID)
   222  	req, err := s.client.NewRequest("DELETE", u, nil)
   223  	if err != nil {
   224  		return nil, nil, err
   225  	}
   226  
   227  	hostedRunner := new(HostedRunner)
   228  	resp, err := s.client.Do(ctx, req, hostedRunner)
   229  	if err != nil {
   230  		return nil, resp, err
   231  	}
   232  
   233  	return hostedRunner, resp, nil
   234  }