Skip to content

Commit 184b68b

Browse files
committed
feat: unwrap hardening from code review
1 parent 07b82d1 commit 184b68b

5 files changed

Lines changed: 247 additions & 129 deletions

File tree

‎rust-bindings/src/expr/errors.rs‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,27 @@ pyo3::create_exception!(
7070
// caret column shifted accordingly. Falls back to
7171
// `str(self)` for context-free or multi-line errors.
7272
//
73+
// Rendering shape of `message_with_expr_prefix` (the "printing"
74+
// path). When `expr` is attached and single-line, it produces a
75+
// three-line, caret-annotated message:
76+
//
77+
// <base message>
78+
// <prefix><expr>
79+
// ^
80+
//
81+
// * line 1 is `self._base_message` (the original message text);
82+
// * line 2 is the expression source, two-space-indented, with
83+
// the caller-supplied `prefix` prepended
84+
// (`" " + prefix + expr`);
85+
// * line 3 is emitted only when `col_offset is not None`: a
86+
// caret under the offending column. The caret is shifted right
87+
// by `len(prefix)` (`" " * (col_offset + len(prefix))`) so it
88+
// stays aligned with the source character after the prefix
89+
// pushes the expression text rightward.
90+
//
91+
// If `expr is None` or the expression is multi-line (`"\n" in
92+
// expr`), it returns plain `str(self)` with no caret annotation.
93+
//
7394
// Implementing these as `#[pyfunction]`s installed via `setattr`
7495
// would *almost* work, except that PyO3's `#[pyfunction]` builds
7596
// a `PyCFunction` (builtin function) which is not bound to its

‎rust-bindings/src/expr/symbol_table.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -73,10 +73,10 @@ impl PySymbolTable {
7373
use pyo3::IntoPyObjectExt;
7474
match self.inner.get(key) {
7575
Some(openjd_expr::symbol_table::SymbolTableEntry::Value(v)) => {
76-
Ok(PyExprValue { inner: v.clone() }.into_py_any(py).unwrap())
76+
PyExprValue { inner: v.clone() }.into_py_any(py)
7777
}
7878
Some(openjd_expr::symbol_table::SymbolTableEntry::Table(t)) => {
79-
Ok(PySymbolTable { inner: t.clone() }.into_py_any(py).unwrap())
79+
PySymbolTable { inner: t.clone() }.into_py_any(py)
8080
}
8181
None => Err(pyo3::exceptions::PyKeyError::new_err(key.to_string())),
8282
}
@@ -85,12 +85,12 @@ impl PySymbolTable {
8585
fn get(&self, py: Python<'_>, name: &str) -> PyResult<Option<Py<pyo3::PyAny>>> {
8686
use pyo3::IntoPyObjectExt;
8787
match self.inner.get(name) {
88-
Some(openjd_expr::symbol_table::SymbolTableEntry::Value(v)) => Ok(Some(
89-
PyExprValue { inner: v.clone() }.into_py_any(py).unwrap(),
90-
)),
91-
Some(openjd_expr::symbol_table::SymbolTableEntry::Table(t)) => Ok(Some(
92-
PySymbolTable { inner: t.clone() }.into_py_any(py).unwrap(),
93-
)),
88+
Some(openjd_expr::symbol_table::SymbolTableEntry::Value(v)) => {
89+
Ok(Some(PyExprValue { inner: v.clone() }.into_py_any(py)?))
90+
}
91+
Some(openjd_expr::symbol_table::SymbolTableEntry::Table(t)) => {
92+
Ok(Some(PySymbolTable { inner: t.clone() }.into_py_any(py)?))
93+
}
9494
None => Ok(None),
9595
}
9696
}

‎rust-bindings/src/model/step_dependency_graph.rs‎

Lines changed: 43 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -18,37 +18,45 @@ pub(crate) struct PyStepDependencyGraph {
1818
}
1919

2020
impl PyStepDependencyGraph {
21-
fn make_node(&self, node_index: usize) -> PyStepDependencyNode {
22-
let node = self.inner.node(node_index).unwrap();
21+
fn make_node(&self, node_index: usize) -> PyResult<PyStepDependencyNode> {
22+
let node = self.inner.node(node_index).ok_or_else(|| {
23+
pyo3::exceptions::PyIndexError::new_err(format!(
24+
"step dependency graph has no node at index {node_index}"
25+
))
26+
})?;
27+
let step_for = |idx: usize| -> PyResult<openjd_model::job::Step> {
28+
self.job_steps.get(idx).cloned().ok_or_else(|| {
29+
pyo3::exceptions::PyIndexError::new_err(format!(
30+
"step dependency edge references out-of-range step index {idx}"
31+
))
32+
})
33+
};
34+
let edge_for = |edge_idx| -> PyResult<Option<PyStepDependencyEdge>> {
35+
match self.inner.edge(edge_idx) {
36+
Some(edge) => Ok(Some(PyStepDependencyEdge {
37+
origin_step: step_for(edge.origin)?,
38+
dependent_step: step_for(edge.dependent)?,
39+
})),
40+
None => Ok(None),
41+
}
42+
};
2343
let in_edges: Vec<PyStepDependencyEdge> = node
2444
.in_edges
2545
.iter()
26-
.filter_map(|&edge_idx| {
27-
let edge = self.inner.edge(edge_idx)?;
28-
Some(PyStepDependencyEdge {
29-
origin_step: self.job_steps[edge.origin].clone(),
30-
dependent_step: self.job_steps[edge.dependent].clone(),
31-
})
32-
})
33-
.collect();
46+
.filter_map(|&edge_idx| edge_for(edge_idx).transpose())
47+
.collect::<PyResult<_>>()?;
3448
let out_edges: Vec<PyStepDependencyEdge> = node
3549
.out_edges
3650
.iter()
37-
.filter_map(|&edge_idx| {
38-
let edge = self.inner.edge(edge_idx)?;
39-
Some(PyStepDependencyEdge {
40-
origin_step: self.job_steps[edge.origin].clone(),
41-
dependent_step: self.job_steps[edge.dependent].clone(),
42-
})
43-
})
44-
.collect();
45-
PyStepDependencyNode {
51+
.filter_map(|&edge_idx| edge_for(edge_idx).transpose())
52+
.collect::<PyResult<_>>()?;
53+
Ok(PyStepDependencyNode {
4654
step: PyStep {
47-
inner: self.job_steps[node.step_index].clone(),
55+
inner: step_for(node.step_index)?,
4856
},
4957
in_edges,
5058
out_edges,
51-
}
59+
})
5260
}
5361
}
5462

@@ -66,7 +74,7 @@ impl PyStepDependencyGraph {
6674
}
6775

6876
#[getter]
69-
fn _nodes(&self) -> Vec<PyStepDependencyNode> {
77+
fn _nodes(&self) -> PyResult<Vec<PyStepDependencyNode>> {
7078
(0..self.inner.node_count())
7179
.map(|i| self.make_node(i))
7280
.collect()
@@ -76,17 +84,25 @@ impl PyStepDependencyGraph {
7684
let node = self.inner.step_node(stepname).ok_or_else(|| {
7785
pyo3::exceptions::PyKeyError::new_err(format!("No step named '{stepname}'"))
7886
})?;
79-
Ok(self.make_node(node.step_index))
87+
self.make_node(node.step_index)
8088
}
8189

8290
fn topo_sorted(&self) -> PyResult<Vec<PyStep>> {
8391
let indices = self.inner.topo_sorted().map_err(model_err_to_py)?;
84-
Ok(indices
92+
indices
8593
.into_iter()
86-
.map(|i| PyStep {
87-
inner: self.job_steps[i].clone(),
94+
.map(|i| {
95+
self.job_steps
96+
.get(i)
97+
.cloned()
98+
.map(|inner| PyStep { inner })
99+
.ok_or_else(|| {
100+
pyo3::exceptions::PyIndexError::new_err(format!(
101+
"topo sort produced out-of-range step index {i}"
102+
))
103+
})
88104
})
89-
.collect())
105+
.collect()
90106
}
91107

92108
fn step_names(&self) -> PyResult<Vec<String>> {

‎rust-bindings/src/model/step_param_space.rs‎

Lines changed: 18 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,15 @@ fn param_type_to_expr_type(pt: TaskParameterType) -> openjd_expr::ExprType {
9191
}
9292
}
9393

94+
/// Lock the iterator mutex, recovering the guard if a previous holder
95+
/// panicked. A panic inside `next()` / `contains()` / `validate_containment()`
96+
/// would otherwise poison the mutex, and every subsequent `.lock().unwrap()`
97+
/// would raise an uncatchable `PanicException` on the Python side — wedging
98+
/// the iterator object permanently. Recovering keeps it usable.
99+
fn lock_recover<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
100+
m.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
101+
}
102+
94103
#[cfg_attr(feature = "stub-gen", gen_stub_pyclass(module = "openjd._openjd_rs"))]
95104
#[pyclass(module = "openjd.model._v1.job", name = "StepParameterSpaceIterator")]
96105
pub(crate) struct PyStepParameterSpaceIterator {
@@ -154,7 +163,7 @@ impl PyStepParameterSpaceIterator {
154163
// Match the pure-Python reference: adaptive-chunked spaces
155164
// cannot answer `len()` because the count depends on the
156165
// dynamic chunk size that may change during execution.
157-
let iter = self.iter.lock().unwrap();
166+
let iter = lock_recover(&self.iter);
158167
if iter.chunks_adaptive() {
159168
return Err(pyo3::exceptions::PyValueError::new_err(
160169
"Length is not available because the parameter space uses adaptive chunking.",
@@ -195,7 +204,7 @@ impl PyStepParameterSpaceIterator {
195204
}
196205

197206
fn __next__(&self, py: Python<'_>) -> PyResult<Option<Py<PyDict>>> {
198-
let mut iter = self.iter.lock().unwrap();
207+
let mut iter = lock_recover(&self.iter);
199208
match iter.next() {
200209
Some(params) => Ok(Some(task_param_set_to_py(py, &params)?)),
201210
None => Ok(None),
@@ -204,7 +213,7 @@ impl PyStepParameterSpaceIterator {
204213

205214
fn __contains__(&self, item: &Bound<'_, PyDict>) -> PyResult<bool> {
206215
let params = extract_task_parameter_set(item)?;
207-
let iter = self.iter.lock().unwrap();
216+
let iter = lock_recover(&self.iter);
208217
Ok(iter.contains(&params))
209218
}
210219

@@ -217,13 +226,13 @@ impl PyStepParameterSpaceIterator {
217226
/// crate's ``StepParameterSpaceIterator::validate_containment``.
218227
fn validate_containment(&self, params: &Bound<'_, PyDict>) -> PyResult<()> {
219228
let params = extract_task_parameter_set(params)?;
220-
let iter = self.iter.lock().unwrap();
229+
let iter = lock_recover(&self.iter);
221230
iter.validate_containment(&params)
222231
.map_err(pyo3::exceptions::PyValueError::new_err)
223232
}
224233

225234
fn reset_iter(&self) {
226-
let mut iter = self.iter.lock().unwrap();
235+
let mut iter = lock_recover(&self.iter);
227236
iter.reset();
228237
}
229238

@@ -234,19 +243,19 @@ impl PyStepParameterSpaceIterator {
234243

235244
#[getter]
236245
fn chunks_adaptive(&self) -> bool {
237-
let iter = self.iter.lock().unwrap();
246+
let iter = lock_recover(&self.iter);
238247
iter.chunks_adaptive()
239248
}
240249

241250
#[getter]
242251
fn chunks_parameter_name(&self) -> Option<String> {
243-
let iter = self.iter.lock().unwrap();
252+
let iter = lock_recover(&self.iter);
244253
iter.chunks_parameter_name().map(|s| s.to_string())
245254
}
246255

247256
#[getter]
248257
fn chunks_default_task_count(&self) -> Option<usize> {
249-
let iter = self.iter.lock().unwrap();
258+
let iter = lock_recover(&self.iter);
250259
iter.chunks_default_task_count()
251260
}
252261

@@ -257,7 +266,7 @@ impl PyStepParameterSpaceIterator {
257266
"chunks_default_task_count must be a positive integer.",
258267
));
259268
}
260-
let mut iter = self.iter.lock().unwrap();
269+
let mut iter = lock_recover(&self.iter);
261270
if !iter.chunks_adaptive() {
262271
return Err(pyo3::exceptions::PyValueError::new_err(
263272
"The parameter space does not use adaptive chunking, so cannot modify chunks_default_task_count.",

0 commit comments

Comments
 (0)