Coverage for harbor_cli/commands/api/scanner.py: 60%

48 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-02-09 12:09 +0100

1from __future__ import annotations 

2 

3from typing import Optional 

4 

5import typer 

6from harborapi.models.models import ScannerRegistration 

7from harborapi.models.models import ScannerRegistrationReq 

8 

9from ...logs import logger 

10from ...output.render import render_result 

11from ...state import state 

12from ...utils.args import create_updated_model 

13from ...utils.args import model_params_from_ctx 

14from ...utils.commands import inject_help 

15from ...utils.commands import inject_resource_options 

16 

17# Create a command group 

18app = typer.Typer( 

19 name="scanner", 

20 help="Manage scanners.", 

21 no_args_is_help=True, 

22) 

23 

24 

25def get_scanner(scanner_id: str) -> ScannerRegistration: 

26 return state.run(state.client.get_scanner(scanner_id), "Fetching scanner...") 

27 

28 

29# HarborAsyncClient.get_scanner() 

30@app.command("get") 

31def get_csanner( 

32 ctx: typer.Context, 

33 scanner_id: str = typer.Argument( 

34 ..., 

35 help="ID of the scanner to retrieve.", 

36 ), 

37) -> None: 

38 """Get a specific scanner.""" 

39 scanner = get_scanner(scanner_id) 

40 render_result(scanner, ctx) 

41 

42 

43# HarborAsyncClient.create_scanner() 

44@app.command("create", no_args_is_help=True) 

45@inject_help(ScannerRegistrationReq) 

46def create_scanner( 

47 ctx: typer.Context, 

48 name: str = typer.Argument( 

49 ..., 

50 ), 

51 url: str = typer.Argument( 

52 ..., 

53 ), 

54 description: Optional[str] = typer.Option( 

55 None, 

56 "--description", 

57 ), 

58 auth: Optional[str] = typer.Option( 

59 None, 

60 "--auth", 

61 ), 

62 access_credential: Optional[str] = typer.Option( 

63 None, 

64 "--access-credential", 

65 ), 

66 skip_cert_verify: Optional[bool] = typer.Option( 

67 None, 

68 "--skip-cert-verify", 

69 is_flag=False, 

70 ), 

71 use_internal_addr: Optional[bool] = typer.Option( 

72 None, 

73 "--use-internal-addr", 

74 is_flag=False, 

75 ), 

76 disabled: Optional[bool] = typer.Option( 

77 None, 

78 "--disabled", 

79 is_flag=False, 

80 ), 

81) -> None: 

82 """Create a new scanner.""" 

83 params = model_params_from_ctx(ctx, ScannerRegistrationReq) 

84 req = ScannerRegistrationReq(**params) 

85 location = state.run(state.client.create_scanner(req), "Creating scanner...") 

86 render_result(location, ctx) 

87 logger.info(f"Scanner created: {location}.") 

88 

89 

90# HarborAsyncClient.update_scanner() 

91@app.command("update", no_args_is_help=True) 

92@inject_help(ScannerRegistrationReq) 

93def update_scanner( 

94 ctx: typer.Context, 

95 scanner_id: str = typer.Argument(..., help="ID of the scanner to update."), 

96 name: Optional[str] = typer.Option( 

97 None, 

98 "--name", 

99 ), 

100 url: Optional[str] = typer.Option( 

101 None, 

102 "--url", 

103 ), 

104 description: Optional[str] = typer.Option( 

105 None, 

106 "--description", 

107 ), 

108 auth: Optional[str] = typer.Option( 

109 None, 

110 "--auth", 

111 ), 

112 access_credential: Optional[str] = typer.Option( 

113 None, 

114 "--access-credential", 

115 ), 

116 skip_cert_verify: Optional[bool] = typer.Option( 

117 None, 

118 "--skip-cert-verify", 

119 is_flag=False, 

120 ), 

121 use_internal_addr: Optional[bool] = typer.Option( 

122 None, 

123 "--use-internal-addr", 

124 is_flag=False, 

125 ), 

126 disabled: Optional[bool] = typer.Option( 

127 False, 

128 "--disabled", 

129 is_flag=False, 

130 ), 

131) -> None: 

132 """Update a scanner.""" 

133 scanner = get_scanner(scanner_id) 

134 req = create_updated_model(scanner, ScannerRegistrationReq, ctx) 

135 

136 state.run( 

137 state.client.update_scanner(scanner_id, req), 

138 "Updating scanner...", 

139 ) 

140 logger.info(f"Scanner {scanner_id!r} updated.") 

141 

142 

143# HarborAsyncClient.delete_scanner() 

144@app.command("delete", no_args_is_help=True) 

145def delete_scanner( 

146 ctx: typer.Context, 

147 scanner_id: str = typer.Argument( 

148 ..., 

149 help="ID of the scanner to delete.", 

150 ), 

151) -> None: 

152 """Delete a scanner.""" 

153 state.run(state.client.delete_scanner(scanner_id), "Deleting scanner...") 

154 logger.info(f"Scanner with ID {scanner_id!r} deleted.") 

155 

156 

157# HarborAsyncClient.get_scanners() 

158@app.command("list") 

159@inject_resource_options() 

160def list_scanners( 

161 ctx: typer.Context, 

162 query: Optional[str], 

163 sort: Optional[str], 

164 page: int, 

165 page_size: int, 

166) -> None: 

167 """List scanners.""" 

168 scanners = state.run( 

169 state.client.get_scanners( 

170 query=query, 

171 sort=sort, 

172 page=page, 

173 page_size=page_size, 

174 ), 

175 f"Fetching scanners...", 

176 ) 

177 render_result(scanners, ctx) 

178 

179 

180# HarborAsyncClient.set_default_scanner() 

181@app.command("default", no_args_is_help=True) 

182def set_default_scanner( 

183 ctx: typer.Context, 

184 scanner_id: str = typer.Argument( 

185 ..., 

186 help="ID of the scanner to set as default.", 

187 ), 

188 unset_default: bool = typer.Option( 

189 False, 

190 "--unset", 

191 help="Unset the given scanner as default.", 

192 ), 

193) -> None: 

194 """Set/unset default scanner.""" 

195 is_default = not unset_default # invert the flag 

196 state.run( 

197 state.client.set_default_scanner(scanner_id, is_default), 

198 "Setting default scanner...", 

199 ) 

200 logger.info(f"Scanner with ID {scanner_id!r} set as default.") 

201 

202 

203# HarborAsyncClient.ping_scanner_adapter() 

204# TODO: verify if this is necessary or not 

205# could maybe be replaced by a flag in create/update