10828257938

Committed 11 Sep 2024 11:17PM UTC coverage: 94.034% (-0.01%) from 94.048%

Build # 10828257938

Build Type

push

github

Committed by

kraih

Commit Message

Clear all state for re-opened reviews

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

6068 of 6453 relevant lines covered (94.03%)

3585.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.73

/lib/Cavil/Controller/Queue.pm

# Copyright (C) 2018-2020 SUSE LLC
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, see <http://www.gnu.org/licenses/>.

package Cavil::Controller::Queue;
use Mojo::Base 'Mojolicious::Controller', -signatures;

use Mojo::File 'path';

sub create_package ($self) {
  my $validation = $self->validation;
  $validation->required('api')->like(qr!^https?://.+!i);
  $validation->required('project');
  $validation->required('package');
  $validation->optional('rev')->like(qr/^[a-f0-9]+$/i);
  $validation->optional('created');
  $validation->optional('external_link');
  $validation->optional('priority')->like(qr/^\d+$/);
  return $self->reply->json_validation_error if $validation->has_error;

  my $api     = $validation->param('api');
  my $project = $validation->param('project');
  my $pkg     = $validation->param('package');
  my $rev     = $validation->param('rev');
  my $created = $validation->param('created');
  my $link    = $validation->param('external_link');
  my $prio    = $validation->param('priority') || 5;

  my $app    = $self->app;
  my $config = $app->config;
  my $obs    = $app->obs;

  # Get package infomation, rev may be pointing to link, so we need the
  # canonical srcmd5
  my $info = eval { $obs->package_info($api, $project, $pkg, {rev => $rev}) };
  unless ($info && $info->{verifymd5}) {
    $self->_log("Couldn't get package info", $api, $project, $pkg, $rev, $@);
    return $self->render(json => {error => 'Package not found'}, status => 404);
  }
  my ($srcpkg, $srcmd5, $verifymd5) = @{$info}{qw(package srcmd5 verifymd5)};

  # Check if we need to import from OBS
  my $dir    = path($config->{checkout_dir}, $srcpkg, $verifymd5);
  my $create = !-e $dir;

  my $user = $self->users->licensedigger;
  my $pkgs = $self->packages;
  my $obj  = $pkgs->find_by_name_and_md5($srcpkg, $verifymd5);
  if (!$obj) {
    my $id = $pkgs->add(
      name            => $srcpkg,
      checkout_dir    => $verifymd5,
      api_url         => $api,
      requesting_user => $user->{id},
      project         => $project,
      priority        => $prio,
      package         => $pkg,
      created         => $created,
      srcmd5          => $srcmd5,
    );
    $obj = $pkgs->find($id);
  }

  # Product imports are low priority, and we want real requests if possible
  $obj->{external_link} //= $link;
  $obj->{external_link} = $link if $link && $prio >= $obj->{priority};

  $obj->{obsolete} = 0;
  $pkgs->update($obj);
  $pkgs->obs_import(
    $obj->{id},
    {
      api       => $api,
      project   => $project,
      pkg       => $pkg,
      srcpkg    => $srcpkg,
      rev       => $rev,
      srcmd5    => $srcmd5,
      verifymd5 => $verifymd5,
      priority  => $prio
    },
    $prio + 10
  ) if $create;

  $self->render(json => {saved => $obj});
}

sub create_request ($self) {
  my $validation = $self->validation;
  $validation->required('external_link');
  $validation->required('package')->like(qr/^\d+$/);
  return $self->reply->json_validation_error if $validation->has_error;

  my $link = $validation->param('external_link');
  my $pkgs = $validation->every_param('package');

  my $requests = $self->requests;
  $requests->add($link, $_) for @$pkgs;

  $self->render(json => {created => $link});
}

sub import_package ($self) {
  my $validation = $self->validation;
  $validation->optional('state')->in('new');
  $validation->optional('priority');
  $validation->optional('external_link');
  return $self->reply->json_validation_error if $validation->has_error;

  my $pkgs = $self->packages;
  my $id   = $self->stash('id');
  my $obj  = $pkgs->find($id);

  my $reindex;
  if (my $link = $validation->param('external_link')) {
    $obj->{external_link} = $link;
  }
  if (my $priority = $validation->param('priority')) {
    $obj->{priority} = $priority;
  }
  if (my $state = $validation->param('state')) {
    $obj->{state} = $state;
    if ($state eq 'new') {
      $obj->{result}         = undef;
      $obj->{reviewed}       = undef;
      $obj->{reviewing_user} = undef;
      $obj->{obsolete}       = 0;
      $reindex               = 1;
    }
  }
  $pkgs->update($obj);
  $pkgs->reindex($id) if $reindex;

  return $self->render(json => {imported => $obj});
}

sub list_requests ($self) {
  $self->render(json => {requests => $self->requests->all});
}

sub package_status ($self) {
  return $self->render(json => {error => 'No such package'}, status => 404)
    unless my $pkg = $self->packages->find($self->stash('id'));

  my %reply = %$pkg;
  $reply{result} = $pkg->{result} if $pkg->{result};
  if ($pkg->{reviewing_user}) {
    my $user = $self->users->find(id => $pkg->{reviewing_user});
    $reply{reviewing_user} = $user->{login};
  }
  return $self->render(json => \%reply);
}

sub remove_request ($self) {
  my $validation = $self->validation;
  $validation->required('external_link');
  return $self->reply->json_validation_error if $validation->has_error;

  my $link    = $validation->param('external_link');
  my $removed = $self->requests->remove($link);
  my $pkgs    = $self->packages;
  for my $id (@$removed) {
    $pkgs->obsolete_if_not_in_product($id);
  }

  $self->render(json => {removed => $removed});
}

sub update_package ($self) {
  my $validation = $self->validation;
  $validation->required('priority')->like(qr/^\d+$/);
  return $self->reply->json_validation_error if $validation->has_error;

  my $pkgs = $self->packages;
  my $obj  = $pkgs->find($self->stash('id'));
  $obj->{priority} = $validation->param('priority');
  $pkgs->update($obj);

  $self->render(json => {updated => $obj});
}

sub update_product ($self) {
  my $validation = $self->validation;
  $validation->required('id')->like(qr/^\d+$/);
  return $self->reply->json_validation_error if $validation->has_error;

  my $name = $self->stash('name');
  $self->log->info("Updating product $name");
  my $products = $self->products;
  my $obj      = $products->find_or_create($name);

  # This might take some time for big products
  $self->inactivity_timeout(600);
  $products->update($obj->{id}, $validation->every_param('id'));

  $self->render(json => {updated => $obj->{id}});
}

sub _errors_to_markdown (@errors) {
  my $markdown = '';
  $markdown .= "* $_\n" for @errors;
  return $markdown;
}

sub _log ($self, $message, $api, $project, $pkg, $rev, $error) {
  my $target = "api=$api, project=$project, package=$pkg" . ($rev ? ", rev=$rev" : '');
  $self->app->log->error("$message ($target): $error");
}

1;

1	# Copyright (C) 2018-2020 SUSE LLC
2	#
3	# This program is free software; you can redistribute it and/or modify
4	# it under the terms of the GNU General Public License as published by
5	# the Free Software Foundation; either version 2 of the License, or
6	# (at your option) any later version.
7	#
8	# This program is distributed in the hope that it will be useful,
9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11	# GNU General Public License for more details.
12	#
13	# You should have received a copy of the GNU General Public License along
14	# with this program; if not, see <http://www.gnu.org/licenses/>.
15
16	package Cavil::Controller::Queue;
17	use Mojo::Base 'Mojolicious::Controller', -signatures;	373✔
18
19	use Mojo::File 'path';	373✔
20
21	sub create_package ($self) {	19✔
22	my $validation = $self->validation;	19✔
23	$validation->required('api')->like(qr!^https?://.+!i);	19✔
24	$validation->required('project');	19✔
25	$validation->required('package');	19✔
26	$validation->optional('rev')->like(qr/^[a-f0-9]+$/i);	19✔
27	$validation->optional('created');	19✔
28	$validation->optional('external_link');	19✔
29	$validation->optional('priority')->like(qr/^\d+$/);	19✔
30	return $self->reply->json_validation_error if $validation->has_error;	19✔
31
32	my $api = $validation->param('api');	18✔
33	my $project = $validation->param('project');	18✔
34	my $pkg = $validation->param('package');	18✔
35	my $rev = $validation->param('rev');	18✔
36	my $created = $validation->param('created');	18✔
37	my $link = $validation->param('external_link');	18✔
38	my $prio = $validation->param('priority') \|\| 5;	18✔
39
40	my $app = $self->app;	18✔
41	my $config = $app->config;	18✔
42	my $obs = $app->obs;	18✔
43
44	# Get package infomation, rev may be pointing to link, so we need the
45	# canonical srcmd5
46	my $info = eval { $obs->package_info($api, $project, $pkg, {rev => $rev}) };	18✔
47	unless ($info && $info->{verifymd5}) {	18✔
48	$self->_log("Couldn't get package info", $api, $project, $pkg, $rev, $@);	×
49	return $self->render(json => {error => 'Package not found'}, status => 404);	×
50	}
51	my ($srcpkg, $srcmd5, $verifymd5) = @{$info}{qw(package srcmd5 verifymd5)};	18✔
52
53	# Check if we need to import from OBS
54	my $dir = path($config->{checkout_dir}, $srcpkg, $verifymd5);	18✔
55	my $create = !-e $dir;	18✔
56
57	my $user = $self->users->licensedigger;	18✔
58	my $pkgs = $self->packages;	18✔
59	my $obj = $pkgs->find_by_name_and_md5($srcpkg, $verifymd5);	18✔
60	if (!$obj) {	18✔
61	my $id = $pkgs->add(
62	name => $srcpkg,
63	checkout_dir => $verifymd5,
64	api_url => $api,
65	requesting_user => $user->{id},
66	project => $project,	18✔
67	priority => $prio,
68	package => $pkg,
69	created => $created,
70	srcmd5 => $srcmd5,
71	);
72	$obj = $pkgs->find($id);	18✔
73	}
74
75	# Product imports are low priority, and we want real requests if possible
76	$obj->{external_link} //= $link;	18✔
77	$obj->{external_link} = $link if $link && $prio >= $obj->{priority};	18✔
78
79	$obj->{obsolete} = 0;	18✔
80	$pkgs->update($obj);	18✔
81	$pkgs->obs_import(
82	$obj->{id},
83	{
84	api => $api,	18✔
85	project => $project,
86	pkg => $pkg,
87	srcpkg => $srcpkg,
88	rev => $rev,
89	srcmd5 => $srcmd5,
90	verifymd5 => $verifymd5,
91	priority => $prio
92	},
93	$prio + 10
94	) if $create;
95
96	$self->render(json => {saved => $obj});	18✔
97	}
98
99	sub create_request ($self) {	6✔
100	my $validation = $self->validation;	6✔
101	$validation->required('external_link');	6✔
102	$validation->required('package')->like(qr/^\d+$/);	6✔
103	return $self->reply->json_validation_error if $validation->has_error;	6✔
104
105	my $link = $validation->param('external_link');	6✔
106	my $pkgs = $validation->every_param('package');	6✔
107
108	my $requests = $self->requests;	6✔
109	$requests->add($link, $_) for @$pkgs;	6✔
110
111	$self->render(json => {created => $link});	6✔
112	}
113
114	sub import_package ($self) {	×
115	my $validation = $self->validation;	×
116	$validation->optional('state')->in('new');	×
117	$validation->optional('priority');	×
118	$validation->optional('external_link');	×
119	return $self->reply->json_validation_error if $validation->has_error;	×
120
121	my $pkgs = $self->packages;	×
122	my $id = $self->stash('id');	×
123	my $obj = $pkgs->find($id);	×
124
125	my $reindex;	×
126	if (my $link = $validation->param('external_link')) {	×
127	$obj->{external_link} = $link;	×
128	}
129	if (my $priority = $validation->param('priority')) {	×
130	$obj->{priority} = $priority;	×
131	}
132	if (my $state = $validation->param('state')) {	×
133	$obj->{state} = $state;	×
134	if ($state eq 'new') {	×
NEW 135	$obj->{result} = undef;	×
136	$obj->{reviewed} = undef;	×
137	$obj->{reviewing_user} = undef;	×
138	$obj->{obsolete} = 0;	×
139	$reindex = 1;	×
140	}
141	}
142	$pkgs->update($obj);	×
143	$pkgs->reindex($id) if $reindex;	×
144
145	return $self->render(json => {imported => $obj});	×
146	}
147
148	sub list_requests ($self) {	5✔
149	$self->render(json => {requests => $self->requests->all});	5✔
150	}
151
152	sub package_status ($self) {	21✔
153	return $self->render(json => {error => 'No such package'}, status => 404)	21✔
154	unless my $pkg = $self->packages->find($self->stash('id'));
155
156	my %reply = %$pkg;	4✔
157	$reply{result} = $pkg->{result} if $pkg->{result};	4✔
158	if ($pkg->{reviewing_user}) {	4✔
159	my $user = $self->users->find(id => $pkg->{reviewing_user});	×
160	$reply{reviewing_user} = $user->{login};	×
161	}
162	return $self->render(json => \%reply);	4✔
163	}
164
165	sub remove_request ($self) {	2✔
166	my $validation = $self->validation;	2✔
167	$validation->required('external_link');	2✔
168	return $self->reply->json_validation_error if $validation->has_error;	2✔
169
170	my $link = $validation->param('external_link');	2✔
171	my $removed = $self->requests->remove($link);	2✔
172	my $pkgs = $self->packages;	2✔
173	for my $id (@$removed) {	2✔
174	$pkgs->obsolete_if_not_in_product($id);	6✔
175	}
176
177	$self->render(json => {removed => $removed});	2✔
178	}
179
180	sub update_package ($self) {	1✔
181	my $validation = $self->validation;	1✔
182	$validation->required('priority')->like(qr/^\d+$/);	1✔
183	return $self->reply->json_validation_error if $validation->has_error;	1✔
184
185	my $pkgs = $self->packages;	1✔
186	my $obj = $pkgs->find($self->stash('id'));	1✔
187	$obj->{priority} = $validation->param('priority');	1✔
188	$pkgs->update($obj);	1✔
189
190	$self->render(json => {updated => $obj});	1✔
191	}
192
193	sub update_product ($self) {	3✔
194	my $validation = $self->validation;	3✔
195	$validation->required('id')->like(qr/^\d+$/);	3✔
196	return $self->reply->json_validation_error if $validation->has_error;	3✔
197
198	my $name = $self->stash('name');	3✔
199	$self->log->info("Updating product $name");	3✔
200	my $products = $self->products;	3✔
201	my $obj = $products->find_or_create($name);	3✔
202
203	# This might take some time for big products
204	$self->inactivity_timeout(600);	3✔
205	$products->update($obj->{id}, $validation->every_param('id'));	3✔
206
207	$self->render(json => {updated => $obj->{id}});	3✔
208	}
209
210	sub _errors_to_markdown (@errors) {	×
211	my $markdown = '';	×
212	$markdown .= "* $_\n" for @errors;	×
213	return $markdown;	×
214	}
215
216	sub _log ($self, $message, $api, $project, $pkg, $rev, $error) {	×
217	my $target = "api=$api, project=$project, package=$pkg" . ($rev ? ", rev=$rev" : '');	×
218	$self->app->log->error("$message ($target): $error");	×
219	}
220
221	1;

openSUSE / cavil / 10828257938

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous