text stringlengths 8 4.13M |
|---|
use ckb_types::core::Capacity;
use serde::{Deserialize, Serialize};
/// shannons per kilobytes
#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct FeeRate(u64);
const KB: u64 = 1000;
impl FeeRate {
pub fn calculate(fee: Capacity, vbytes: usize) -> Self {
if vbytes == 0 {
return FeeRate::zero();
}
FeeRate::from_u64(fee.as_u64().saturating_mul(KB) / (vbytes as u64))
}
pub const fn from_u64(fee_per_kb: u64) -> Self {
FeeRate(fee_per_kb)
}
pub const fn as_u64(self) -> u64 {
self.0
}
pub const fn zero() -> Self {
Self::from_u64(0)
}
pub fn fee(self, size: usize) -> Capacity {
let fee = self.0.saturating_mul(size as u64) / KB;
Capacity::shannons(fee)
}
}
impl ::std::fmt::Display for FeeRate {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "{}", self.0)
}
}
|
use chrono::{DateTime, Local};
use configuration::EmailConfig;
use failure::Error;
use lettre::{
smtp::{authentication::Credentials, SmtpClient},
Transport,
};
use lettre_email::EmailBuilder;
use mime::TEXT_HTML;
use parser::ParsedDocument;
pub fn send(doc: ParsedDocument, config: EmailConfig) -> Result<(), Error> {
let EmailConfig {
to,
username,
password,
} = config;
let ParsedDocument {
title,
author,
content,
domain,
date_published,
url,
} = doc;
let content = format!(
"<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"utf-8\"/><title>{}</title></head><body><h1>{}</h1>{}</body></html>",
title,
title,
content
);
let mut mailer = SmtpClient::new_simple("smtp.gmail.com")
.map_err(|err| format_err!("Error creating mail client: {}", err))?
.credentials(Credentials::new(username.to_owned(), password))
.transport();
let mut file_name = title.to_owned();
if let Some(author) = author {
file_name.push_str(&format!(" - {}", author));
}
if let Some(domain) = domain {
file_name.push_str(&format!(" - {}", domain));
}
let date: Option<DateTime<Local>> = date_published.and_then(|date| date.parse().ok());
if let Some(date) = date {
file_name.push_str(date.format(" - %Y-%m-%d").to_string().as_str());
}
file_name.push_str(".html".into());
debug!("file_name: {:?}", file_name);
let email = EmailBuilder::new()
.to(to)
.from(username)
.subject("convert")
.text(format!("Sent from tl;rl: {}", url.unwrap_or("".into())))
.attachment(&content.into_bytes(), file_name.as_str(), &TEXT_HTML)?
.build()
.map_err(|err| format_err!("Error building email: {}", err))?;
trace!("{:?}", email);
trace!("sending email...");
mailer
.send(email.into())
.map_err(|err| format_err!("Error sending email: {}", err))?;
trace!("email sent");
trace!("closing mailer...");
mailer.close();
trace!("mailer closed");
Ok(())
}
|
use gl::types::*;
use std::ffi::c_void;
pub type EBO = ElementBufferObject;
pub struct ElementBufferObject {
pub id: GLuint,
}
impl EBO {
pub fn bind(&self) {
unsafe { gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.id) }
}
pub fn unbind(&self) {
unsafe { gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, 0) }
}
pub fn buffer_data(&self, indices: &[u32], draw_type: GLenum) {
debug_assert!([gl::STATIC_DRAW, gl::DYNAMIC_DRAW].contains(&draw_type));
unsafe {
gl::BufferData(
gl::ELEMENT_ARRAY_BUFFER,
4 * indices.len() as isize,
indices.as_ptr() as *const c_void,
draw_type,
)
}
}
pub fn delete(self) {
unsafe { gl::DeleteBuffers(1, &self.id) }
}
}
impl Default for EBO {
fn default() -> Self {
let mut id = 0;
unsafe { gl::GenBuffers(1, &mut id) }
EBO { id }
}
}
impl Drop for EBO {
fn drop(&mut self) {
unsafe { gl::DeleteBuffers(1, &self.id) }
}
}
|
use super::*;
use hyper::header::HeaderValue;
enum ResponseHolder {
Resp(body::Sender),
Tx(ResponseResultSender),
}
thread_local! {
static REQ_ID_TO_TX: RefCell<HashMap<i32, ResponseHolder>> = RefCell::new(HashMap::new());
}
thread_local! {
static NEXT_REQ_ID: RefCell<i32> = RefCell::new(0);
}
lazy_thread_local!(HEAD_CB, set_head_cb, Persistent<V8::Function>);
pub fn handle_inbound((req, tx): Message, origin: &str) -> impl Future<Item = (), Error = ()> {
let req_id = get_next_req_id();
REQ_ID_TO_TX.with(|cell| {
cell.borrow_mut().insert(req_id, ResponseHolder::Tx(tx));
});
let body_handler: Persistent<V8::Function>;
let mut context = get_context();
handle_scope!({
let worker_handler = context.global().get_private(context, "worker_handler");
let method = req.method().to_string();
let mut uri = std::string::String::new();
uri.push_str(&origin);
uri.push_str(&req.uri().to_string());
let v8_headers = headers::v8_headers(req.headers());
body_handler = call_inbound_req_head_handler(
context,
vec![&req_id, &worker_handler, &method, &uri, &v8_headers],
)
.into();
});
req.into_body()
.for_each(move |chunk| {
let context = get_context();
handle_scope!({
let chunk = std::string::String::from_utf8(chunk.to_vec()).unwrap();
let null = Isolate::null();
let mut cb = body_handler.into_local();
cb.call(context, &null, vec![&chunk]);
});
future::ok(())
})
.and_then(move |_| {
let context = get_context();
handle_scope!({
let null = Isolate::null();
let mut cb = body_handler.into_local();
cb.call(context, &null, vec![]);
body_handler.reset();
});
future::ok(())
})
.map_err(|e| {
// TODO send a "Bad Request" response.
log_osgood_error!("Inbound request: {}", e);
})
}
macro_rules! send_response {
($req_id:expr, $response:expr) => {
REQ_ID_TO_TX.with(move |cell| {
let mut m = cell.borrow_mut();
let _ = match (*m).remove($req_id).unwrap() {
ResponseHolder::Tx(tx) => {
let _ = tx.send($response);
}
_ => log_osgood_error!("sending response after end"),
};
});
};
}
#[v8_fn]
pub fn set_inbound_req_head_handler(args: FunctionCallbackInfo) {
let func = args.get(0).unwrap().to_function();
set_head_cb(func.into());
}
pub fn call_inbound_req_head_handler(
context: Local<V8::Context>,
args: Vec<&dyn IntoValue>,
) -> Local<V8::Function> {
let null = Isolate::null();
HEAD_CB.with(|cb| {
let mut cb = cb.borrow().unwrap().into_local();
cb.call(context, &null, args).to_function()
})
}
#[v8_fn]
pub fn string_response(args: FunctionCallbackInfo) {
let req_id = args.get(1).unwrap().to_number().value() as i32;
let mut response = Response::new(args.get(0).unwrap().as_rust_string().into());
(*response.headers_mut()).insert("Content-Type", HeaderValue::from_str("text/plain").unwrap());
send_response!(&req_id, Ok(response));
}
#[v8_fn]
pub fn send_error(args: FunctionCallbackInfo) {
let req_id = args.get(2).unwrap().to_number().value() as i32;
let mut response = Response::new(args.get(1).unwrap().as_rust_string().into());
let status_code = args.get(0).unwrap().to_number().value() as u16;
(*response.headers_mut()).insert("Content-Type", HeaderValue::from_str("text/plain").unwrap());
*response.status_mut() = StatusCode::from_u16(status_code).unwrap();
send_response!(&req_id, Ok(response));
}
#[v8_fn]
pub fn start_response(args: FunctionCallbackInfo) {
let context = get_context();
let mut v8_response = args.get(0).unwrap().to_object();
let req_id = args.get(1).unwrap().to_number().value() as i32;
let status_code = v8_response.get(context, "status").to_number().value() as u16;
let v8_headers = v8_response
.get(context, "headers")
.to_object()
.get(context, "_headers");
let has_string_body = args.length() == 3;
let context = Isolate::get_current_context();
let header_map = headers::rust_headers(v8_headers, context);
if has_string_body {
let body = args.get(2).unwrap();
let mut response = Response::new(body.as_rust_string().into());
*response.status_mut() = StatusCode::from_u16(status_code).unwrap();
*response.headers_mut() = header_map;
send_response!(&req_id, Ok(response));
} else {
let (sender, body) = Body::channel();
let mut response = Response::new(body);
*response.status_mut() = StatusCode::from_u16(status_code).unwrap();
*response.headers_mut() = header_map;
send_response!(&req_id, Ok(response));
REQ_ID_TO_TX.with(move |cell| {
let mut m = cell.borrow_mut();
m.insert(req_id, ResponseHolder::Resp(sender));
});
}
}
#[v8_fn]
pub fn write_response(args: FunctionCallbackInfo) {
let mut v8_chunk = args.get(0).unwrap();
let req_id = args.get(1).unwrap().to_number().value() as i32;
//let context = Isolate::get_current_context();
if v8_chunk.as_rust_bool() {
let mut chunk = v8_chunk.to_array_buffer();
let chunk = chunk.as_vec_u8();
REQ_ID_TO_TX.with(|cell| {
let mut m = cell.borrow_mut();
let response_body_sender = match (*m).get_mut(&req_id).unwrap() {
ResponseHolder::Resp(x) => x,
_ => panic!("bad state"),
};
let _ = response_body_sender.send_data(chunk.into());
});
} else {
REQ_ID_TO_TX.with(|cell| {
(*cell.borrow_mut()).remove(&req_id).unwrap();
});
}
}
fn get_next_req_id() -> i32 {
NEXT_REQ_ID.with(|id| {
let new_id = *id.borrow();
*id.borrow_mut() = new_id + 1;
new_id
})
}
|
// This file was generated
pub mod any;
pub mod cmp;
pub mod collections;
pub mod error;
pub mod ffi;
pub mod fmt;
pub mod fs;
pub mod iter;
pub mod net;
pub mod ops;
pub mod option;
pub mod os;
pub mod path;
pub mod primitive;
pub mod process;
pub mod rc;
pub mod result;
pub mod string;
pub mod sync;
pub mod task;
pub mod vec;
|
extern crate glutin_window;
extern crate graphics;
extern crate opengl_graphics;
extern crate piston;
extern crate rand;
use glutin_window::GlutinWindow as Window;
use opengl_graphics::*;
use piston::event_loop::{EventSettings, Events};
use piston::input::{Button, Key, PressEvent, RenderArgs, RenderEvent, UpdateArgs, UpdateEvent};
use piston::window::WindowSettings;
use piston::EventLoop;
use rand::prelude::*;
use std::cell::RefCell;
use std::collections::BTreeSet;
use std::collections::LinkedList;
use std::ptr;
use std::rc::Rc;
const WINDOW_WIDTH: f64 = 400.0;
const WINDOW_HEIGHT: f64 = 400.0;
const HALF_CELL_SIZE: f64 = 5.0;
const STEP_MULTIPLICATOR: f64 = 100.0;
const GROW_MULTIPLICATOR: i64 = 4;
const STEPS_WITHOUT_ROTATION: i64 = 15;
const INITIAL_SIZE: usize = 12;
const INITIAL_HP: i64 = 3;
const POISON_DROP_CHANCE: i64 = 20; //%
const POISON_DROP_CHANCE_RANGE_NEXT: i64 = POISON_DROP_CHANCE + 1;
const HEAL_DROP_CHANCE: i64 = 7; // %
const HEAL_DROP_CHANCE_RANGE_TO: i64 = POISON_DROP_CHANCE_RANGE_NEXT + HEAL_DROP_CHANCE;
// const HEAL_DROP_CHANCE_RANGE_NEXT: i64 = HEAL_DROP_CHANCE + 1;
const POOPING_CHANCE: i64 = 8; // 0.x%
const INVULNERABILITY_THRESHOLD: usize = 50;
const GREEN: [f32; 4] = [0.0, 1.0, 0.0, 1.0];
const RED: [f32; 4] = [1.0, 0.0, 0.0, 1.0];
const BLUE: [f32; 4] = [0.0, 0.0, 1.0, 1.0];
const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
const WHITE: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
const BROWN: [f32; 4] = [0.76, 0.33, 0.08, 1.0];
#[derive(Copy, Clone, Debug)]
enum Direction {
None,
Up,
Down,
Left,
Right,
}
impl Direction {
fn is_invert(&self, other: &Direction) -> bool {
if (matches!(self, Direction::Up) && matches!(other, Direction::Down))
|| (matches!(self, Direction::Down) && matches!(other, Direction::Up))
|| (matches!(self, Direction::Left) && matches!(other, Direction::Right))
|| (matches!(self, Direction::Right) && matches!(other, Direction::Left))
{
return true;
} else {
return false;
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
enum ChainType {
Snake,
Poop,
Heal,
Poison,
}
impl ChainType {
fn get_color(&self) -> [f32; 4] {
match self {
ChainType::Poop => BROWN,
ChainType::Snake => BLUE,
ChainType::Poison => GREEN,
ChainType::Heal => RED,
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
struct ChainLink {
x: f64,
y: f64,
t: ChainType,
}
impl Eq for ChainLink {}
impl Ord for ChainLink {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
// in this business logic we cannot get NaN f64 values
self.partial_cmp(other).unwrap()
}
}
impl ChainLink {
fn new(x: f64, y: f64, t: ChainType) -> ChainLink {
ChainLink { x, y, t }
}
fn intersects(&self, other: &ChainLink) -> bool {
let this_x1 = self.x - HALF_CELL_SIZE;
let this_x2 = self.x + HALF_CELL_SIZE;
let this_y1 = self.y - HALF_CELL_SIZE;
let this_y2 = self.y + HALF_CELL_SIZE;
let other_x1 = other.x - HALF_CELL_SIZE;
let other_x2 = other.x + HALF_CELL_SIZE;
let other_y1 = other.y - HALF_CELL_SIZE;
let other_y2 = other.y + HALF_CELL_SIZE;
if (other_x1 <= this_x2 && other_x1 >= this_x1
|| other_x2 <= this_x2 && other_x2 >= this_x1)
&& (other_y1 <= this_y2 && other_y1 >= this_y1
|| other_y2 <= this_y2 && other_y2 >= this_y1)
{
return true;
} else {
return false;
}
}
}
#[derive(Clone)]
struct Snake {
direction: Direction,
chain: LinkedList<ChainLink>,
growth: i64,
poop: i64,
app_state: Rc<RefCell<AppState>>,
hp: i64,
cannot_rotate_steps: i64,
deffered_rotation: Direction,
rnd: ThreadRng,
score: i64,
}
impl Snake {
fn new(app_state: Rc<RefCell<AppState>>) -> Snake {
let snake_chain = ChainLink::new(0.0, 0.0, ChainType::Snake);
let mut chain: LinkedList<ChainLink> = LinkedList::new();
for _ in 0..INITIAL_SIZE {
chain.push_back(snake_chain);
}
Snake {
chain,
direction: Direction::None,
growth: 0,
poop: 0,
app_state,
hp: INITIAL_HP,
rnd: rand::thread_rng(),
cannot_rotate_steps: 0,
deffered_rotation: Direction::None,
score: 0,
}
}
fn new_direction(&mut self, direction: Direction) {
if !self.direction.is_invert(&direction) {
if self.cannot_rotate_steps <= 0 {
self.direction = direction;
self.cannot_rotate_steps = STEPS_WITHOUT_ROTATION;
} else {
self.deffered_rotation = direction;
}
}
}
fn make_deffered_rotation(&mut self) {
if !matches!(self.deffered_rotation, Direction::None) && self.cannot_rotate_steps <= 0 {
if !self.direction.is_invert(&self.deffered_rotation) {
self.direction = self.deffered_rotation;
}
self.deffered_rotation = Direction::None;
}
}
fn get_next_coords(&self, step_size: f64) -> (f64, f64) {
let old_head = self.chain.front().unwrap();
let mut new_y = old_head.y;
let mut new_x = old_head.x;
match self.direction {
Direction::Up => new_y -= step_size * STEP_MULTIPLICATOR,
Direction::Down => new_y += step_size * STEP_MULTIPLICATOR,
Direction::Left => new_x -= step_size * STEP_MULTIPLICATOR,
Direction::Right => new_x += step_size * STEP_MULTIPLICATOR,
_ => {}
};
// teleport if snake trying to leave out of window
if new_x > WINDOW_WIDTH - HALF_CELL_SIZE {
new_x -= WINDOW_WIDTH;
} else if new_x < HALF_CELL_SIZE {
new_x += WINDOW_WIDTH;
} else if new_y > WINDOW_HEIGHT - HALF_CELL_SIZE {
new_y -= WINDOW_HEIGHT;
} else if new_y < HALF_CELL_SIZE {
new_y += WINDOW_HEIGHT;
}
(new_x, new_y)
}
fn make_step(&mut self, step_size: f64) {
if self.is_dead() || matches!(self.direction, Direction::None) {
return;
}
self.cannot_rotate_steps -= 1;
self.make_deffered_rotation();
let (new_x, new_y) = self.get_next_coords(step_size);
self.chain
.push_front(ChainLink::new(new_x, new_y, ChainType::Snake));
self.find_something_to_eat();
self.check_collision_with_tail();
self.shit_generation();
// dropping tail business logic
if self.growth == 0 && self.poop == 0 {
self.chain.pop_back();
} else if self.growth > 0 {
self.growth -= 1;
} else if self.poop > 0 {
self.poop -= 1;
let tail = self.chain.pop_back();
if let Some(mut tail_ref) = tail {
let chain_type = match self.rnd.gen_range(0..100) {
0..=POISON_DROP_CHANCE => ChainType::Poison,
POISON_DROP_CHANCE_RANGE_NEXT..=HEAL_DROP_CHANCE_RANGE_TO => ChainType::Heal,
_ => ChainType::Poop,
};
let mut app_state = self.app_state.borrow_mut();
tail_ref.t = chain_type;
app_state.add_item_to_map(tail_ref);
}
}
}
fn find_something_to_eat(&mut self) {
let mut intersection: Option<ChainLink> = None;
let head = self.chain.front().unwrap();
{
let app_state = self.app_state.borrow();
let item_option = app_state
.map_objects
.iter()
.find(|item| head.intersects(item));
if let Some(item) = item_option {
intersection = Some(item.clone());
}
}
if let Some(item) = intersection {
match item.t {
ChainType::Poop => self.growth += GROW_MULTIPLICATOR,
ChainType::Poison => self.hp -= 1,
ChainType::Heal => self.hp += 1,
_ => {}
}
self.score += 1;
let mut app_state = self.app_state.borrow_mut();
app_state.map_objects.remove(&item);
}
}
fn check_collision_with_tail(&mut self) {
let head = self.chain.front().unwrap();
if self
.chain
.iter()
.enumerate()
.filter(|&(i, _)| i > INVULNERABILITY_THRESHOLD)
.position(|(_, item)| !ptr::eq(head, item) && head.intersects(item))
.is_some()
{
self.hp = 0;
}
}
fn is_dead(&self) -> bool {
self.hp <= 0
}
fn shit_generation(&mut self) {
let random: i64 = self.rnd.gen_range(1..1000);
if let 0..=POOPING_CHANCE = random {
self.poop += 1;
}
}
}
#[derive(Clone)]
struct AppState {
map_objects: BTreeSet<ChainLink>,
}
impl AppState {
fn new() -> AppState {
AppState {
map_objects: BTreeSet::new(),
}
}
fn add_item_to_map(&mut self, item: ChainLink) {
self.map_objects.insert(item);
}
}
struct App<'a> {
gl: GlGraphics,
snake: Snake,
app_state: Rc<RefCell<AppState>>,
font: GlyphCache<'a>,
}
impl App<'_> {
fn new(gl: GlGraphics, snake: Snake, app_state: Rc<RefCell<AppState>>) -> App<'static> {
App {
gl,
snake,
app_state,
font: opengl_graphics::GlyphCache::new(
"./assets/PressStart2P-Regular.ttf",
(),
TextureSettings::new(),
)
.unwrap(),
}
}
fn render(&mut self, args: &RenderArgs) {
use graphics::*;
let rect: [f64; 4] = rectangle::square(0.0, 0.0, 10.0);
let snake = &self.snake;
let app_state = &self.app_state;
let font = &mut self.font;
self.gl.draw(args.viewport(), |c, gl| {
// Clear the screen.
clear(WHITE, gl);
for snake_item in snake.chain.iter() {
let transform = c
.transform
.trans(snake_item.x, snake_item.y)
.trans(HALF_CELL_SIZE, HALF_CELL_SIZE);
rectangle(snake_item.t.get_color(), rect, transform, gl);
}
for item in app_state.borrow().map_objects.iter() {
let transform = c
.transform
.trans(item.x, item.y)
.trans(HALF_CELL_SIZE, HALF_CELL_SIZE);
rectangle(item.t.get_color(), rect, transform, gl);
}
let header = format!("COPRO SNAKE {} HP", snake.hp);
text(BLACK, 15, &header, font, c.transform.trans(30.0, 30.0), gl).unwrap();
let score_header = format!("SCORE: {}", snake.score);
text(
BLACK,
15,
&score_header,
font,
c.transform.trans(20.0, 380.0),
gl,
)
.unwrap();
if snake.is_dead() {
text(
BLACK,
30,
"GAME OVER",
font,
c.transform.trans(30.0, 70.0),
gl,
)
.unwrap();
}
});
}
fn update(&mut self, args: &UpdateArgs) {
self.snake.make_step(args.dt);
}
fn btn_press(&mut self, button: &Button) {
match button {
Button::Keyboard(Key::Up) => self.snake.new_direction(Direction::Up),
Button::Keyboard(Key::Down) => self.snake.new_direction(Direction::Down),
Button::Keyboard(Key::Left) => self.snake.new_direction(Direction::Left),
Button::Keyboard(Key::Right) => self.snake.new_direction(Direction::Right),
Button::Keyboard(Key::Space) => self.snake = Snake::new(self.app_state.clone()),
Button::Keyboard(Key::Return) => self.restart(),
_ => {}
}
}
fn restart(&mut self){
let mut app_state = self.app_state.borrow_mut();
app_state.map_objects = BTreeSet::new();
self.snake = Snake::new(self.app_state.clone());
}
}
fn main() {
let opengl = OpenGL::V3_2;
let mut window: Window = WindowSettings::new("snake", [WINDOW_WIDTH, WINDOW_HEIGHT])
.graphics_api(opengl)
.exit_on_esc(true)
.build()
.unwrap();
let app_state = Rc::new(RefCell::new(AppState::new()));
let snake = Snake::new(app_state.clone());
let mut app = App::new(GlGraphics::new(opengl), snake, app_state);
let mut settings = EventSettings::new();
settings.set_max_fps(30);
let mut events = Events::new(settings);
while let Some(e) = events.next(&mut window) {
if let Some(args) = e.render_args() {
app.render(&args);
}
if let Some(args) = e.update_args() {
app.update(&args);
}
if let Some(button) = e.press_args() {
app.btn_press(&button);
}
}
}
|
use libsyntax2::{
ast, AstNode,
TextRange, SyntaxNodeRef,
SyntaxKind::WHITESPACE,
algo::{find_leaf_at_offset, find_covering_node, ancestors},
};
pub fn extend_selection(file: &ast::File, range: TextRange) -> Option<TextRange> {
let syntax = file.syntax();
extend(syntax.as_ref(), range)
}
pub(crate) fn extend(root: SyntaxNodeRef, range: TextRange) -> Option<TextRange> {
if range.is_empty() {
let offset = range.start();
let mut leaves = find_leaf_at_offset(root, offset);
if let Some(leaf) = leaves.clone().find(|node| node.kind() != WHITESPACE) {
return Some(leaf.range());
}
let ws = leaves.next()?;
// let ws_suffix = file.text().slice(
// TextRange::from_to(offset, ws.range().end())
// );
// if ws.text().contains("\n") && !ws_suffix.contains("\n") {
// if let Some(line_end) = file.text()
// .slice(TextSuffix::from(ws.range().end()))
// .find("\n")
// {
// let range = TextRange::from_len(ws.range().end(), line_end);
// return Some(find_covering_node(file.root(), range).range());
// }
// }
return Some(ws.range());
};
let node = find_covering_node(root, range);
match ancestors(node).skip_while(|n| n.range() == range).next() {
None => None,
Some(parent) => Some(parent.range()),
}
}
|
use std::sync::Arc;
use std::sync::atomic::AtomicUsize;
use atomic::Ordering;
pub mod pwm;
pub trait AnalogOutput: Send {
fn set_value(&mut self, val: f32);
}
pub trait PwmOutput: AnalogOutput {
fn set_pulse_duty_cycle(&mut self, val: u32);
fn set_period(&mut self, val: u32);
}
pub struct TestPwm {
value: Arc<atomic::Atomic<f32>>,
duty_cycle: Arc<AtomicUsize>,
period: Arc<AtomicUsize>,
}
impl AnalogOutput for TestPwm {
fn set_value(&mut self, val: f32) {
self.value.swap(val, atomic::Ordering::SeqCst);
self.duty_cycle.swap((val * self.period.load(Ordering::SeqCst) as f32) as usize, Ordering::SeqCst);
}
}
impl PwmOutput for TestPwm {
fn set_pulse_duty_cycle(&mut self, val: u32) {
self.duty_cycle.store(val as usize, Ordering::SeqCst);
}
fn set_period(&mut self, val: u32) {
self.period.store(val as usize, Ordering::SeqCst);
}
}
impl TestPwm {
pub fn new(state: Arc<atomic::Atomic<f32>>) -> Self {
Self {
value: state,
duty_cycle: Arc::new(AtomicUsize::new(0)),
period: Arc::new(AtomicUsize::new(20_000))
}
}
pub fn pwm(value: Arc<atomic::Atomic<f32>>, duty_cycle: Arc<AtomicUsize>, period: Arc<AtomicUsize>) -> Self {
Self {
value,
duty_cycle,
period,
}
}
} |
#[macro_use] extern crate nickel;
extern crate hyper;
use nickel::{Nickel, HttpRouter, Request, Response, MiddlewareResult};
use hyper::header::{AccessControlAllowOrigin, AccessControlAllowHeaders};
fn enable_cors<'mw>(_req: &mut Request, mut res: Response<'mw>) -> MiddlewareResult<'mw> {
res.set(AccessControlAllowOrigin::Any);
res.set(AccessControlAllowHeaders(vec![
"Origin".into(),
"X-Requested-With".into(),
"Content-Type".into(),
"Accept".into(),
]));
res.next_middleware()
}
fn main() {
let mut server = Nickel::new();
server.utilize(enable_cors);
server.get("/", middleware! { |request,response|
format!("<h1>WELCOME TO API</h1>")
});
server.get("/user/:userid", middleware! { |request,response|
println!("User id: {:?}\n", request.param("userid"));
format!("This id user: {:?}", request.param("userid"))
});
server.get("user/login", middleware! { |request, response|
println!("The login was succesfull: username {:?}, password {:?}", request.param("userName"), request.param("password"))
});
server.listen("127.0.0.1:6767");
}
|
use crate::{
hex::coordinates::{
axial::AxialVector, cubic::CubicVector, direction::HexagonalDirection, HexagonalVector,
},
vector::Vector2ISize,
};
use std::{cmp::Ordering, fmt::Debug};
#[derive(Default, Debug)]
pub struct FieldOfView<V: HexagonalVector> {
center: V,
radius: usize,
arcs: Vec<Arc>,
}
impl<V: HexagonalVector + HexagonalDirection + Into<VertexVector>> FieldOfView<V> {
pub fn start(&mut self, center: V) {
self.center = center;
self.radius = 1;
self.arcs.clear();
self.arcs.push(Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 }),
},
stop: ArcEnd {
polar_index: 3,
vector: VertexVector(Vector2ISize { x: -3, y: 0 }),
},
});
self.arcs.push(Arc {
start: ArcEnd {
polar_index: 3,
vector: VertexVector(Vector2ISize { x: -3, y: 0 }),
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: 3, y: 0 }),
},
});
}
pub fn next_radius<F>(&mut self, is_obstacle: &F)
where
F: Fn(V) -> bool,
{
let radius = self.radius;
let mut expanded_arcs = Vec::new();
for arc in &mut self.arcs {
expanded_arcs.extend(
arc.clone()
.split(self.center, radius, is_obstacle)
.into_iter()
.map(|mut arc| {
arc.expand::<V>(radius);
arc
}),
);
}
self.arcs = expanded_arcs;
self.radius = radius + 1;
}
pub fn iter(&self) -> ArcsIter<'_, V> {
ArcsIter::new(self.radius, self.arcs.iter())
}
}
#[derive(PartialEq, Eq, Clone, Debug)]
struct Arc {
start: ArcEnd,
stop: ArcEnd,
}
impl Arc {
fn is_zero_angle(&self) -> bool {
if self.start.polar_index > self.stop.polar_index {
return true;
}
match self.start.vector.turns(&self.stop.vector) {
Turn::Right => true,
// The good thing with VertexVector holding integral values is that there is no need
// to introduce an epsilon here. However vectors could be opposite because
// the system is pushed to PI angles inclusive. This probably would not be necessary
// if the field of view was split into 3 slices or 4 quadrants like in the reference
// implementation.
// It is difficult to tell which implementation is more optimal CPU-wise without
// proper measurement.
Turn::Straight
if self.start.vector.0.x < 0 && self.stop.vector.0.x < 0
|| self.start.vector.0.x > 0 && self.stop.vector.0.x > 0
|| self.start.vector.0.y < 0 && self.stop.vector.0.y < 0
|| self.start.vector.0.y > 0 && self.stop.vector.0.y > 0 =>
{
true
}
Turn::Left | Turn::Straight => false,
}
}
fn split<V: HexagonalDirection + Into<VertexVector>, F>(
mut self,
center: V,
radius: usize,
is_obstacle: &F,
) -> Vec<Arc>
where
F: Fn(V) -> bool,
{
let mut split = Vec::new();
loop {
// Contract start
while self.start.polar_index <= self.stop.polar_index {
let vector = ArcEnd::polar_index_to_vector(self.start.polar_index, radius);
if is_obstacle(center + vector) {
self.start.contract_start(vector);
self.start.polar_index += 1;
} else {
break;
}
}
// Find stop obstacle
let mut polar_index = self.start.polar_index;
while polar_index <= self.stop.polar_index {
let vector = ArcEnd::polar_index_to_vector(polar_index, radius);
if is_obstacle(center + vector) {
let mut arc = self.clone();
// Contract stop
arc.stop.contract_stop(vector);
arc.stop.polar_index = polar_index - 1;
// Push if non zero angle
if !arc.is_zero_angle() {
split.push(arc);
}
// Reset start for next iteration
self.start.contract_start(vector);
self.start.polar_index = polar_index + 1;
break;
} else {
polar_index += 1;
}
}
// No obstacle found
if polar_index > self.stop.polar_index {
break;
}
}
// Push last if non zero angle
if !self.is_zero_angle() {
split.push(self);
}
split
}
fn expand<V: HexagonalDirection + Into<VertexVector>>(&mut self, radius: usize) {
self.start.expand_start::<V>(radius);
self.stop.expand_stop::<V>(radius);
}
}
#[derive(PartialEq, Eq, Clone, Debug)]
struct ArcEnd {
polar_index: usize,
vector: VertexVector,
}
impl ArcEnd {
fn polar_index_to_vector<V: HexagonalDirection>(polar_index: usize, radius: usize) -> V {
let side = (polar_index / radius) % 6;
let side_offset = polar_index % radius;
V::direction(side) * radius as isize + V::direction((side + 2) % 6) * side_offset as isize
}
fn is_right_of_arc<V: HexagonalDirection + Into<VertexVector>>(&self, radius: usize) -> bool {
let vector = ArcEnd::polar_index_to_vector::<V>(self.polar_index, radius);
for local_vertex in HEX_PLANE_VERTICES.iter() {
let vertex = vector.into() + *local_vertex;
if self.vector.turns(&vertex) == Turn::Right {
return true;
}
}
false
}
fn is_left_of_arc<V: HexagonalDirection + Into<VertexVector>>(&self, radius: usize) -> bool {
let vector = ArcEnd::polar_index_to_vector::<V>(self.polar_index, radius);
for local_vertex in HEX_PLANE_VERTICES.iter() {
let vertex = vector.into() + *local_vertex;
if self.vector.turns(&vertex) == Turn::Left {
return true;
}
}
false
}
fn contract_start<V: HexagonalVector + Into<VertexVector>>(&mut self, vector: V) {
for local_vertex in HEX_PLANE_VERTICES.iter() {
let vertex = vector.into() + *local_vertex;
if self.vector.turns(&vertex) == Turn::Left {
self.vector = vertex;
}
}
}
fn contract_stop<V: HexagonalVector + Into<VertexVector>>(&mut self, vector: V) {
for local_vertex in HEX_PLANE_VERTICES.iter() {
let vertex = vector.into() + *local_vertex;
if self.vector.turns(&vertex) == Turn::Right {
self.vector = vertex;
}
}
}
fn expand_start<V: HexagonalDirection + Into<VertexVector>>(&mut self, radius: usize) {
let side = self.polar_index / radius;
let side_offset = self.polar_index % radius;
let new_radius = radius + 1;
self.polar_index = side * new_radius + side_offset + 1;
loop {
if self.is_right_of_arc::<V>(new_radius) {
// Found one hex crossing the arc.
// Check whether the next one is in the same case before breaking the loop.
if self.polar_index > 0 {
self.polar_index -= 1;
if !self.is_left_of_arc::<V>(new_radius) {
self.polar_index += 1;
}
}
break;
}
debug_assert!(self.polar_index > 0);
self.polar_index -= 1;
}
}
fn expand_stop<V: HexagonalDirection + Into<VertexVector>>(&mut self, radius: usize) {
let side = self.polar_index / radius;
let side_offset = self.polar_index % radius;
let new_radius = radius + 1;
self.polar_index = side * new_radius + side_offset;
loop {
if self.is_left_of_arc::<V>(new_radius) {
// Found one hex crossing the arc.
// Check whether the next one is in the same case before breaking the loop.
if self.polar_index < new_radius * 6 {
self.polar_index += 1;
if !self.is_right_of_arc::<V>(new_radius) {
self.polar_index -= 1;
}
}
break;
}
debug_assert!(self.polar_index < new_radius * 6);
self.polar_index += 1;
}
}
}
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
enum Turn {
Left,
Straight,
Right,
}
#[derive(PartialEq, Eq, Clone, Copy, Add, AddAssign, Sub, SubAssign, Debug)]
pub struct VertexVector(Vector2ISize);
impl VertexVector {
fn turns(&self, other: &VertexVector) -> Turn {
let cross = self.0.x * other.0.y - self.0.y * other.0.x;
match cross.cmp(&0) {
Ordering::Greater => Turn::Left,
Ordering::Less => Turn::Right,
Ordering::Equal => Turn::Straight,
}
}
}
const HEX_PLANE_VERTICES: [VertexVector; 6] = [
VertexVector(Vector2ISize { x: 1, y: -1 }),
VertexVector(Vector2ISize { x: 1, y: 1 }),
VertexVector(Vector2ISize { x: 0, y: 2 }),
VertexVector(Vector2ISize { x: -1, y: 1 }),
VertexVector(Vector2ISize { x: -1, y: -1 }),
VertexVector(Vector2ISize { x: 0, y: -2 }),
];
impl From<AxialVector> for VertexVector {
fn from(axial: AxialVector) -> Self {
VertexVector(Vector2ISize {
x: 2 * axial.q() + axial.r(),
y: -3 * axial.r(),
})
}
}
impl From<CubicVector> for VertexVector {
fn from(cubic: CubicVector) -> Self {
VertexVector(Vector2ISize {
x: 2 * cubic.x() + cubic.z(),
y: -3 * cubic.z(),
})
}
}
pub struct ArcsIter<'a, V> {
radius: usize,
arcs: std::slice::Iter<'a, Arc>,
current: Option<(&'a Arc, usize, usize)>,
_v: std::marker::PhantomData<V>,
}
impl<'a, V> ArcsIter<'a, V> {
fn new(radius: usize, mut arcs: std::slice::Iter<'a, Arc>) -> Self {
let current = arcs
.next()
.map(|arc| (arc, arc.start.polar_index, arc.start.polar_index));
Self {
radius,
arcs,
current,
_v: Default::default(),
}
}
}
impl<'a, V: HexagonalDirection> Iterator for ArcsIter<'a, V> {
type Item = V;
fn next(&mut self) -> Option<Self::Item> {
if let Some((arc, polar_index, first_polar_index)) = &mut self.current {
let first_polar_index = *first_polar_index;
let res = Some(ArcEnd::polar_index_to_vector(*polar_index, self.radius));
let next_polar_index = *polar_index + 1;
if next_polar_index <= arc.stop.polar_index
&& next_polar_index % (self.radius * 6) != first_polar_index
{
*polar_index = next_polar_index;
} else {
let prev_polar_index = *polar_index;
loop {
self.current = self
.arcs
.next()
.map(|arc| (arc, arc.start.polar_index, first_polar_index));
match &mut self.current {
Some((arc, pi, _)) => {
if *pi == prev_polar_index {
*pi += 1;
}
if *pi <= arc.stop.polar_index
&& *pi % (self.radius * 6) != first_polar_index
{
break;
}
}
None => {
break;
}
}
}
}
res
} else {
None
}
}
}
#[test]
fn test_field_of_view_2_0() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(0));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 1,
vector: VertexVector(Vector2ISize { x: 2, y: 2 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 11,
vector: VertexVector(Vector2ISize { x: 1, y: -1 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_1() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(1));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 1,
vector: VertexVector(Vector2ISize { x: 2, y: 2 })
}
},
Arc {
start: ArcEnd {
polar_index: 3,
vector: VertexVector(Vector2ISize { x: 0, y: 4 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 12,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_2() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(2));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 3,
vector: VertexVector(Vector2ISize { x: 0, y: 2 })
}
},
Arc {
start: ArcEnd {
polar_index: 5,
vector: VertexVector(Vector2ISize { x: -2, y: 2 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 12,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_3() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(3));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 5,
vector: VertexVector(Vector2ISize { x: -1, y: 1 })
}
},
Arc {
start: ArcEnd {
polar_index: 7,
vector: VertexVector(Vector2ISize { x: -1, y: -1 })
},
stop: ArcEnd {
polar_index: 12,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_4() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(4));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 7,
vector: VertexVector(Vector2ISize { x: -1, y: -1 })
}
},
Arc {
start: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: 0, y: -4 })
},
stop: ArcEnd {
polar_index: 12,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_5() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(5));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: 0, y: -2 })
}
},
Arc {
start: ArcEnd {
polar_index: 11,
vector: VertexVector(Vector2ISize { x: 2, y: -2 })
},
stop: ArcEnd {
polar_index: 12,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_024() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(0));
set.insert(center + AxialVector::direction(2));
set.insert(center + AxialVector::direction(4));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 1,
vector: VertexVector(Vector2ISize { x: 2, y: 2 })
},
stop: ArcEnd {
polar_index: 3,
vector: VertexVector(Vector2ISize { x: 0, y: 2 })
}
},
Arc {
start: ArcEnd {
polar_index: 5,
vector: VertexVector(Vector2ISize { x: -2, y: 2 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 7,
vector: VertexVector(Vector2ISize { x: -1, y: -1 })
}
},
Arc {
start: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: 0, y: -4 })
},
stop: ArcEnd {
polar_index: 11,
vector: VertexVector(Vector2ISize { x: 1, y: -1 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_024_3_() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(0));
set.insert(center + AxialVector::direction(2));
set.insert(center + AxialVector::direction(4));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 3);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 1,
vector: VertexVector(Vector2ISize { x: 2, y: 2 })
},
stop: ArcEnd {
polar_index: 5,
vector: VertexVector(Vector2ISize { x: 0, y: 2 })
}
},
Arc {
start: ArcEnd {
polar_index: 7,
vector: VertexVector(Vector2ISize { x: -2, y: 2 })
},
stop: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 11,
vector: VertexVector(Vector2ISize { x: -1, y: -1 })
}
},
Arc {
start: ArcEnd {
polar_index: 13,
vector: VertexVector(Vector2ISize { x: 0, y: -4 })
},
stop: ArcEnd {
polar_index: 17,
vector: VertexVector(Vector2ISize { x: 1, y: -1 })
}
},
]
);
}
#[test]
fn test_field_of_view_2_024_3_1357911() {
use std::collections::HashSet;
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let obstacles = {
let mut set = HashSet::new();
set.insert(center + AxialVector::direction(0));
set.insert(center + AxialVector::direction(2));
set.insert(center + AxialVector::direction(4));
set.insert(center + AxialVector::direction(0) + AxialVector::direction(1));
set.insert(center + AxialVector::direction(1) + AxialVector::direction(2));
set.insert(center + AxialVector::direction(2) + AxialVector::direction(3));
set.insert(center + AxialVector::direction(3) + AxialVector::direction(4));
set.insert(center + AxialVector::direction(4) + AxialVector::direction(5));
set.insert(center + AxialVector::direction(5) + AxialVector::direction(0));
set
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&|pos| obstacles.contains(&pos));
fov.next_radius(&|pos| obstacles.contains(&pos));
assert_eq!(fov.radius, 3);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 2,
vector: VertexVector(Vector2ISize { x: 2, y: 4 })
},
stop: ArcEnd {
polar_index: 4,
vector: VertexVector(Vector2ISize { x: 1, y: 5 })
}
},
Arc {
start: ArcEnd {
polar_index: 8,
vector: VertexVector(Vector2ISize { x: -3, y: 1 })
},
stop: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 9,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 10,
vector: VertexVector(Vector2ISize { x: -3, y: -1 })
}
},
Arc {
start: ArcEnd {
polar_index: 14,
vector: VertexVector(Vector2ISize { x: 1, y: -5 })
},
stop: ArcEnd {
polar_index: 16,
vector: VertexVector(Vector2ISize { x: 2, y: -4 })
}
},
]
);
}
#[test]
fn test_field_of_view_line_dir_1_0() {
let center =
AxialVector::default() + AxialVector::direction(0) * 1 + AxialVector::direction(1) * 2;
let is_obstacle = |pos: AxialVector| -> bool {
let vector = pos - AxialVector::direction(1) - center;
let dir_0 = AxialVector::direction(0);
dir_0.q() * vector.r() - dir_0.r() * vector.q() == 0
};
let mut fov = FieldOfView::default();
fov.start(center);
fov.next_radius(&is_obstacle);
assert_eq!(fov.radius, 2);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 1,
vector: VertexVector(Vector2ISize { x: 2, y: 2 })
}
},
Arc {
start: ArcEnd {
polar_index: 5,
vector: VertexVector(Vector2ISize { x: -2, y: 2 })
},
stop: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 6,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 12,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
for i in 0..42 {
fov.next_radius(&is_obstacle);
assert_eq!(fov.radius, i + 3);
assert_eq!(
fov.arcs,
vec![
Arc {
start: ArcEnd {
polar_index: 0,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
},
stop: ArcEnd {
polar_index: 1,
vector: VertexVector(Vector2ISize {
x: 2 * i as isize + 3,
y: 1
})
}
},
Arc {
start: ArcEnd {
polar_index: 3 * i + 8,
vector: VertexVector(Vector2ISize {
x: -(2 * i as isize + 3),
y: 1
})
},
stop: ArcEnd {
polar_index: 3 * i + 9,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
}
},
Arc {
start: ArcEnd {
polar_index: 3 * i + 9,
vector: VertexVector(Vector2ISize { x: -3, y: 0 })
},
stop: ArcEnd {
polar_index: 6 * i + 18,
vector: VertexVector(Vector2ISize { x: 3, y: 0 })
}
},
]
);
}
}
|
fn main() {
let a = read::<String>().parse::<i32>().unwrap();
let bc = read::<String>();
let b_c = bc.split(' ').map(|x| x.parse::<i32>().unwrap());
let mut sum = a;
for b in b_c {
sum += b;
}
let s = read::<String>();
println!("{} {}", sum, s);
}
pub fn read<T: std::str::FromStr>() -> T {
let mut s = String::new();
std::io::stdin().read_line(&mut s).ok();
s.trim().parse().ok().unwrap()
} |
pub mod endpoint;
//pub mod file;
pub mod list;
pub mod num;
|
use super::helpers::auth::*;
use crate::models::user::*;
use crate::validation::Validate;
use actix_web::{cookie::Cookie, get, post, web, HttpResponse, Responder};
use time::Duration;
#[post("/register")]
/// User registration route
pub async fn register(
pool: web::Data<sqlx::PgPool>,
_: web::Data<r2d2::Pool<redis::Client>>,
body: web::Json<UserInsert>,
) -> impl Responder {
// Validate request body
let user = body.into_inner();
if let Some(e) = user.validate() {
return HttpResponse::BadRequest().json(e.to_error());
}
// Insert the `User` object into the database
HttpResponse::Ok().json(match User::insert(pool.into_inner().as_ref(), user).await {
Ok(u) => u,
Err(err) => return HttpResponse::InternalServerError().json(err),
})
}
#[post("/login")]
/// User login route
pub async fn login(
pool: web::Data<sqlx::PgPool>,
redis_pool: web::Data<r2d2::Pool<redis::Client>>,
req: web::HttpRequest,
body: web::Json<UserLogin>,
) -> impl Responder {
// Validate request body
let userlogin = body.into_inner();
if let Some(e) = userlogin.validate() {
return HttpResponse::BadRequest().json(e.to_error());
}
// Get `User` with a username of `userlogin.username`
let user = User::get_by_username(pool.into_inner().as_ref(), userlogin.username).await;
if let Err(e) = user {
return match e.error.kind {
"AuthError" => HttpResponse::NotFound().json(e),
"InternalServerError" => HttpResponse::InternalServerError().json(e),
_ => HttpResponse::InternalServerError().json(()),
};
}
// Check given password against password hash
let user = user.unwrap();
if let Some(e) = check_password_hash(userlogin.password, &user.password) {
return HttpResponse::Unauthorized().json(e);
}
let useragent = req.headers().get("User-Agent").unwrap().to_str().unwrap();
// Construct session (from user's id and useragent) and get the session/refresh token
let refresh_token =
UserSession::new(user.id, useragent).set_session(redis_pool.into_inner().as_ref());
let refresh_token_cookie = Cookie::build("refresh_token", refresh_token)
.path("/")
.max_age(Duration::days(1))
.finish();
// Generate access token string from `user` object
let access_token = UserClaims::from_user(user).to_token();
let access_token_cookie = Cookie::build("access_token", access_token)
.path("/")
.max_age(Duration::minutes(20))
.finish();
// Return `200` response with both cookies and a success message
HttpResponse::Ok()
.cookie(refresh_token_cookie)
.cookie(access_token_cookie)
.json(SuccessMessage {
message: "Successfully Logged in",
})
}
|
//! Runtime is a wasm go runtime
#![deny(
missing_docs,
trivial_numeric_casts,
unstable_features,
unused_extern_crates,
unused_features
)]
#![warn(unused_import_braces, unused_parens)]
#![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))]
#![cfg_attr(
feature = "cargo-clippy",
allow(clippy::new_without_default, clippy::new_without_default_derive)
)]
#![cfg_attr(
feature = "cargo-clippy",
warn(
clippy::float_arithmetic,
clippy::mut_mut,
clippy::nonminimal_bool,
clippy::option_map_unwrap_or,
clippy::option_map_unwrap_or_else,
clippy::unicode_not_nfc,
clippy::use_self
)
)]
extern crate cranelift_codegen;
extern crate cranelift_entity;
extern crate cranelift_native;
extern crate cranelift_wasm;
extern crate failure;
extern crate file_per_thread_logger;
extern crate rand;
extern crate slab;
extern crate target_lexicon;
extern crate wabt;
extern crate wasabi_io;
extern crate wasmtime_environ;
extern crate wasmtime_jit;
extern crate wasmtime_runtime;
mod bytes;
mod go;
mod js;
mod mem;
mod shared_state;
mod timeout_heap;
mod util;
use cranelift_codegen::settings;
use cranelift_codegen::settings::Configurable;
use std::env::args;
use std::error::Error;
use std::fs::File;
use std::io;
use std::io::prelude::*;
use std::path::Path;
use std::path::PathBuf;
use std::process::exit;
use wasmtime_jit::Compiler;
static LOG_FILENAME_PREFIX: &str = "cranelift.dbg.";
fn read_to_end(path: PathBuf) -> Result<Vec<u8>, io::Error> {
let mut buf: Vec<u8> = Vec::new();
let mut file = File::open(path)?;
file.read_to_end(&mut buf)?;
Ok(buf)
}
fn main() {
file_per_thread_logger::initialize(LOG_FILENAME_PREFIX);
let isa_builder = cranelift_native::builder().unwrap_or_else(|_| {
panic!("host machine is not a supported target");
});
let mut flag_builder = settings::builder();
// Enable verifier passes in debug mode.
if cfg!(debug_assertions) {
flag_builder.enable("enable_verifier").unwrap();
}
// flag_builder.set("opt_level", "best").unwrap();
let isa = isa_builder.finish(settings::Flags::new(flag_builder));
let compiler = Compiler::new(isa);
let args: Vec<String> = args().collect();
if args.len() < 2 {
println!("Runtime expects a wasm binary or wat file as the first argument");
exit(1);
}
let filename = args[1].clone();
let path = Path::new(&filename);
match handle_module(args, compiler, path) {
Ok(()) => {}
Err(message) => {
let name = path.as_os_str().to_string_lossy();
println!("error while processing {}: {}", name, message);
exit(1);
}
}
}
fn handle_module(args: Vec<String>, compiler: Compiler, path: &Path) -> Result<(), String> {
let mut data =
read_to_end(path.to_path_buf()).map_err(|err| String::from(err.description()))?;
// if data is using wat-format, first convert data to wasm
if !data.starts_with(&[b'\0', b'a', b's', b'm']) {
data = wabt::wat2wasm(data).map_err(|err| String::from(err.description()))?;
}
go::run(args, compiler, data)
}
|
// https://adventofcode.com/2017/day/24
use std::fs::File;
use std::collections::HashSet;
use std::io::{BufRead, BufReader};
use std::iter::FromIterator;
fn main() {
let f = BufReader::new(File::open("input.txt").expect("Opening input.txt failed"));
// Parse components
let mut components = Vec::new();
for line in f.lines() {
let raw_line = line.expect("Reading line failed");
let mut halves = raw_line.split('/');
components.push((
halves
.next()
.expect("Invalid component")
.parse::<u32>()
.expect("Invalid port"),
halves
.next()
.expect("Invalid component")
.parse::<u32>()
.expect("Invalid port"),
));
}
// Get strength of the strongest bridge
let strength = get_max_strength(0, 0, HashSet::from_iter(components.iter().cloned()));
// Assert to facilitate further tweaks
assert_eq!(1511, strength);
println!("Strength of the strongest bridge is {}", strength);
// Get strength of the longest (strongest of if multiple) bridge
let strength =
get_longest_max_strength(0, 0, 0, HashSet::from_iter(components.iter().cloned())).1;
// Assert to facilitate further tweaks
assert_eq!(1471, strength);
println!("Max strength of the longest bridge is {}", strength);
}
// Finds the max strength achievable from the open port with unused components
fn get_max_strength(strength: u32, open_port: u32, unused_components: HashSet<(u32, u32)>) -> u32 {
let mut max_strength = strength;
for c in &unused_components {
// Chech if component is viable
if c.0 == open_port || c.1 == open_port {
// Create copy of unused components without the match
let mut new_components = unused_components.clone();
new_components.remove(c);
// Find max strength from the match
let new_open = if c.0 == open_port { c.1 } else { c.0 };
let new_strength = get_max_strength(strength + c.0 + c.1, new_open, new_components);
if new_strength > max_strength {
max_strength = new_strength;
}
}
}
max_strength
}
// Finds the max strength of the longest achievable bridge from the open port with unused components
fn get_longest_max_strength(
length: u32,
strength: u32,
open_port: u32,
unused_components: HashSet<(u32, u32)>,
) -> (u32, u32) {
let mut max_length = length;
let mut max_strength = strength;
for c in &unused_components {
// Chech if component is viable
if c.0 == open_port || c.1 == open_port {
// Create copy of unused components without the match
let mut new_components = unused_components.clone();
new_components.remove(c);
// Find longest bridge with max strength from the match
let new_open = if c.0 == open_port { c.1 } else { c.0 };
let (new_length, new_strength) = get_longest_max_strength(
length + 1,
strength + c.0 + c.1,
new_open,
new_components,
);
if new_length >= max_length && new_strength > max_strength {
max_length = new_length;
max_strength = new_strength;
}
}
}
(max_length, max_strength)
}
|
#![feature(test)]
use dev_util::impl_benchmark;
impl_benchmark!(keccak, Keccak224);
impl_benchmark!(keccak, Keccak256);
impl_benchmark!(keccak, Keccak384);
impl_benchmark!(keccak, Keccak512);
|
pub const MAKEFILE: &[u8] = b"# **************************************************************************** #
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: nieyraud <nieyraud@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2019/11/10 16:28:15 by nieyraud #+# #+# #
# Updated: 2021/03/09 09:16:41 by nieyraud ### ########.fr #
# #
# **************************************************************************** #
#####################
# COLOR #
#####################
rose=\\033[1;31m
violetfonce=\\033[0;35m
violetclair=\\033[1;35m
neutre=\\033[0m
cyanfonce=\\033[0;36m
cyanclair=\\033[1;36m
vertfonce=\\033[0;32m
vertclair=\\033[1;32m
rouge=\\033[31m
orange=\\033[33m
#####################
# SOURCES #
#####################
NAME = a.out
include files.mk
CLASSES_SRCS= $(addsuffix .cpp,$(CLASSES))
CLASSES_HEADERS= $(addsuffix .hpp,$(CLASSES)) $(INTERFACES)
INCLUDES_DIR = include/
TEMPLATE_DIR = $(addprefix $(INCLUDES_DIR), template/)
CLASSES_DIR = $(addprefix $(INCLUDES_DIR), classes/)
INCLUDE = $(addprefix $(TEMPLATE_DIR), $(TEMPLATES)) \
$(addprefix $(CLASSES_DIR), $(CLASSES_HEADERS)) \
$(addprefix $(INCLUDES_DIR), $(HEADERS))
#############################
# DIRCTORIES PATH #
#############################
PATH = ${shell find srcs -type d}
OBJ_PATH = objs
vpath %.cpp $(foreach dir, $(PATH), $(dir))
#################################
# FILES VARIABLE #
#################################
SRC = ${SRC_FILE} $(CLASSES_SRCS)
OBJ = ${addprefix ${OBJ_PATH}/, ${SRC:%.cpp=%.o}}
#########################
# FLAGS #
#########################
STD_VERSION= -std=c++98
FLAGS = -Wall -Wextra -ferror-limit=5 $(STD_VERSION)
SAN = -g
OPT_FLAGS = -flto
INCLUDE_FLAGS = -I $(TEMPLATE_DIR) -I $(INCLUDES_DIR) -I $(CLASSES_DIR)
#########################
# LIBRARIES #
#########################
LIB_DIR = lib/
LINK_FLAGS = $(addprefix -L, $(LIB_DIR))
LIBS = ${addprefix -l, ${LIBS_BIN}}
########################
# COMMAND #
#######################
CC= /usr/bin/clang++
DIFF = /usr/bin/diff
MKDIR= /bin/mkdir
ECHO=echo
RM=/bin/rm
#############################
# RULES #
#############################
all : $(NAME)
$(NAME) : ${INCLUDE} ${OBJ}
@$(ECHO) \"${vertclair}Creating ${NAME}\"
@$(CC) ${FLAGS} ${OPT_FLAGS} $(INCLUDE_FLAGS) ${OBJ} $(LINK_FLAGS) $(LIBS) -o ${NAME}
@$(ECHO) \"${vertclair}[$(NAME) ready to use]$(neutre)\"
${OBJ_PATH}/%.o: %.cpp ${INCLUDE}
@$(MKDIR) -p ${OBJ_PATH}
@$(ECHO) \"${cyanfonce}Compiling ${notdir $(basename $@)}\"
@$(CC) $(FLAGS) -c -o $@ $(INCLUDE_FLAGS) $<
debug: extend_flags re
extend_flags:
$(eval FLAGS += $(SAN))
clean :
@$(ECHO) \"${rouge}Removing objects files\"
@$(RM) -rf ${OBJ_PATH}
fclean : clean
@$(ECHO) \"${rose}Removing ${NAME}\"
@$(RM) -f $(NAME)
re : fclean all
.PHONY : all clean fclean re f
";
pub const FILEMK: &[u8] = b"SRC_FILE= main.cpp
CLASSES=
INTERFACES=
TEMPLATES=
HEADERS=
";
pub const MAIN: &[u8] = b"#include <iostream>
int main(void)
{
std::cout << \"Hello_world\" << std::endl;
return (0);
}
";
|
mod utils;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use ffi::*;
use libc::size_t;
use libmdbx::{ObjectLength, WriteFlags};
use rand::{prelude::SliceRandom, SeedableRng};
use rand_xorshift::XorShiftRng;
use std::ptr;
use utils::*;
fn bench_get_rand(c: &mut Criterion) {
let n = 100u32;
let (_dir, db) = setup_bench_db(n);
let txn = db.begin_ro_txn().unwrap();
let table = txn.open_table(None).unwrap();
let mut keys: Vec<String> = (0..n).map(get_key).collect();
keys.shuffle(&mut XorShiftRng::from_seed(Default::default()));
c.bench_function("bench_get_rand", |b| {
b.iter(|| {
let mut i = 0usize;
for key in &keys {
i += *txn
.get::<ObjectLength>(&table, key.as_bytes())
.unwrap()
.unwrap();
}
black_box(i);
})
});
}
fn bench_get_rand_raw(c: &mut Criterion) {
let n = 100u32;
let (_dir, db) = setup_bench_db(n);
let _txn = db.begin_ro_txn().unwrap();
let table = _txn.open_table(None).unwrap();
let mut keys: Vec<String> = (0..n).map(get_key).collect();
keys.shuffle(&mut XorShiftRng::from_seed(Default::default()));
let dbi = table.dbi();
let txn = _txn.txn();
let mut key_val: MDBX_val = MDBX_val {
iov_len: 0,
iov_base: ptr::null_mut(),
};
let mut data_val: MDBX_val = MDBX_val {
iov_len: 0,
iov_base: ptr::null_mut(),
};
c.bench_function("bench_get_rand_raw", |b| {
b.iter(|| unsafe {
let mut i: size_t = 0;
for key in &keys {
key_val.iov_len = key.len() as size_t;
key_val.iov_base = key.as_bytes().as_ptr() as *mut _;
mdbx_get(txn, dbi, &key_val, &mut data_val);
i += key_val.iov_len;
}
black_box(i);
})
});
}
fn bench_put_rand(c: &mut Criterion) {
let n = 100u32;
let (_dir, db) = setup_bench_db(0);
let txn = db.begin_ro_txn().unwrap();
let table = txn.open_table(None).unwrap();
txn.prime_for_permaopen(table);
let table = txn.commit_and_rebind_open_dbs().unwrap().1.remove(0);
let mut items: Vec<(String, String)> = (0..n).map(|n| (get_key(n), get_data(n))).collect();
items.shuffle(&mut XorShiftRng::from_seed(Default::default()));
c.bench_function("bench_put_rand", |b| {
b.iter(|| {
let txn = db.begin_rw_txn().unwrap();
for (key, data) in items.iter() {
txn.put(&table, key, data, WriteFlags::empty()).unwrap();
}
})
});
}
fn bench_put_rand_raw(c: &mut Criterion) {
let n = 100u32;
let (_dir, _db) = setup_bench_db(0);
let mut items: Vec<(String, String)> = (0..n).map(|n| (get_key(n), get_data(n))).collect();
items.shuffle(&mut XorShiftRng::from_seed(Default::default()));
let dbi = _db.begin_ro_txn().unwrap().open_table(None).unwrap().dbi();
let env = _db.ptr();
let mut key_val: MDBX_val = MDBX_val {
iov_len: 0,
iov_base: ptr::null_mut(),
};
let mut data_val: MDBX_val = MDBX_val {
iov_len: 0,
iov_base: ptr::null_mut(),
};
c.bench_function("bench_put_rand_raw", |b| {
b.iter(|| unsafe {
let mut txn: *mut MDBX_txn = ptr::null_mut();
mdbx_txn_begin_ex(env, ptr::null_mut(), 0, &mut txn, ptr::null_mut());
let mut i: ::libc::c_int = 0;
for (key, data) in items.iter() {
key_val.iov_len = key.len() as size_t;
key_val.iov_base = key.as_bytes().as_ptr() as *mut _;
data_val.iov_len = data.len() as size_t;
data_val.iov_base = data.as_bytes().as_ptr() as *mut _;
i += mdbx_put(txn, dbi, &key_val, &mut data_val, 0);
}
assert_eq!(0, i);
mdbx_txn_abort(txn);
})
});
}
criterion_group!(
benches,
bench_get_rand,
bench_get_rand_raw,
bench_put_rand,
bench_put_rand_raw
);
criterion_main!(benches);
|
/*
* Datadog API V1 Collection
*
* Collection of all Datadog Public endpoints.
*
* The version of the OpenAPI document: 1.0
* Contact: support@datadoghq.com
* Generated by: https://openapi-generator.tech
*/
/// SyntheticsTriggerCiTestRunResult : Information about a single test run.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SyntheticsTriggerCiTestRunResult {
#[serde(rename = "device", skip_serializing_if = "Option::is_none")]
pub device: Option<crate::models::SyntheticsDeviceId>,
/// The location ID of the test run.
#[serde(rename = "location", skip_serializing_if = "Option::is_none")]
pub location: Option<i64>,
/// The public ID of the Synthetics test.
#[serde(rename = "public_id", skip_serializing_if = "Option::is_none")]
pub public_id: Option<String>,
/// ID of the result.
#[serde(rename = "result_id", skip_serializing_if = "Option::is_none")]
pub result_id: Option<String>,
}
impl SyntheticsTriggerCiTestRunResult {
/// Information about a single test run.
pub fn new() -> SyntheticsTriggerCiTestRunResult {
SyntheticsTriggerCiTestRunResult {
device: None,
location: None,
public_id: None,
result_id: None,
}
}
}
|
#![no_main]
#[macro_use] extern crate libfuzzer_sys;
extern crate jellyschema;
extern crate serde_yaml;
use std::str::FromStr;
use jellyschema::{
schema::Schema,
generator::generate_json_ui_schema
};
// this is a fuzz target that makes sure that we do not crash given arbitrary data
fuzz_target!(|data: &[u8]| {
if let Ok(data) = std::str::from_utf8(data) {
if let Ok(schema) = Schema::from_str(data) {
let _ = generate_json_ui_schema(&schema);
}
}
});
|
use actix::*;
#[derive(Message)]
struct Ping;
#[derive(Default)]
struct SystemActor;
impl Actor for SystemActor {
type Context = Context<Self>;
}
impl actix::Supervised for SystemActor {}
impl SystemService for SystemActor {
fn service_started(&mut self, _ctx: &mut Context<Self>) {
println!("System Service started");
}
}
impl Handler<Ping> for SystemActor {
type Result = ();
fn handle(&mut self, _: Ping, _ctx: &mut Context<Self>) {
println!("ping received by system actor");
}
}
struct MyActor1;
impl Actor for MyActor1 {
type Context = Context<Self>;
fn started(&mut self, _: &mut Context<Self>) {
let act = System::current().registry().get::<SystemActor>();
act.do_send(Ping);
}
}
#[derive(Default)]
struct ArbiterActor;
impl Actor for ArbiterActor {
type Context = Context<Self>;
}
impl actix::Supervised for ArbiterActor {}
impl ArbiterService for ArbiterActor {
fn service_started(&mut self, _ctx: &mut Context<Self>) {
println!("Arbiter service started");
}
}
impl Handler<Ping> for ArbiterActor {
type Result = ();
fn handle(&mut self, _: Ping, _ctx: &mut Context<Self>) {
println!("ping received by arbiter actor");
}
}
struct MyActor2;
impl Actor for MyActor2 {
type Context = Context<Self>;
fn started(&mut self, _: &mut Context<Self>) {
// get MyActor1 addres from the registry
let act = Arbiter::registry().get::<ArbiterActor>();
act.do_send(Ping);
}
}
fn main() {
// initialize system
System::run(|| {
// Start MyActor1
SystemActor.start();
// Start MyActor2
MyActor1.start();
// Start MyActor3 in new Arbiter
Arbiter::start(|_| {
MyActor2
});
});
} |
mod error_message;
mod product;
mod source;
mod wishlist;
pub use self::error_message::ErrorMessage;
pub use self::product::Product;
pub use self::source::Source;
pub use self::wishlist::Wishlist;
|
// ===============================================================================
// Authors: AFRL/RQQA
// Organization: Air Force Research Laboratory, Aerospace Systems Directorate, Power and Control Division
//
// Copyright (c) 2017 Government of the United State of America, as represented by
// the Secretary of the Air Force. No copyright is claimed in the United States under
// Title 17, U.S. Code. All Other Rights Reserved.
// ===============================================================================
// This file was auto-created by LmcpGen. Modifications will be overwritten.
use avtas::lmcp::{Error, ErrorType, Lmcp, LmcpSubscription, SrcLoc, Struct, StructInfo};
use std::fmt::Debug;
#[derive(Clone, Debug, Default)]
#[repr(C)]
pub struct SubTaskAssignment {
pub sub_tasks: Vec<Box<::afrl::cmasi::task::TaskT>>,
pub neighbors: Vec<Box<::afrl::cmasi::entity_state::EntityStateT>>,
}
impl PartialEq for SubTaskAssignment {
fn eq(&self, _other: &SubTaskAssignment) -> bool {
true
&& &self.sub_tasks == &_other.sub_tasks
&& &self.neighbors == &_other.neighbors
}
}
impl LmcpSubscription for SubTaskAssignment {
fn subscription() -> &'static str { "uxas.messages.uxnative.SubTaskAssignment" }
}
impl Struct for SubTaskAssignment {
fn struct_info() -> StructInfo {
StructInfo {
exist: 1,
series: 6149751333668345413u64,
version: 8,
struct_ty: 11,
}
}
}
impl Lmcp for SubTaskAssignment {
fn ser(&self, buf: &mut[u8]) -> Result<usize, Error> {
let mut pos = 0;
{
let x = Self::struct_info().ser(buf)?;
pos += x;
}
{
let r = get!(buf.get_mut(pos ..));
let writeb: usize = self.sub_tasks.ser(r)?;
pos += writeb;
}
{
let r = get!(buf.get_mut(pos ..));
let writeb: usize = self.neighbors.ser(r)?;
pos += writeb;
}
Ok(pos)
}
fn deser(buf: &[u8]) -> Result<(SubTaskAssignment, usize), Error> {
let mut pos = 0;
let (si, u) = StructInfo::deser(buf)?;
pos += u;
if si == SubTaskAssignment::struct_info() {
let mut out: SubTaskAssignment = Default::default();
{
let r = get!(buf.get(pos ..));
let (x, readb): (Vec<Box<::afrl::cmasi::task::TaskT>>, usize) = Lmcp::deser(r)?;
out.sub_tasks = x;
pos += readb;
}
{
let r = get!(buf.get(pos ..));
let (x, readb): (Vec<Box<::afrl::cmasi::entity_state::EntityStateT>>, usize) = Lmcp::deser(r)?;
out.neighbors = x;
pos += readb;
}
Ok((out, pos))
} else {
Err(error!(ErrorType::InvalidStructInfo))
}
}
fn size(&self) -> usize {
let mut size = 15;
size += self.sub_tasks.size();
size += self.neighbors.size();
size
}
}
pub trait SubTaskAssignmentT: Debug + Send {
fn as_uxas_messages_uxnative_sub_task_assignment(&self) -> Option<&SubTaskAssignment> { None }
fn as_mut_uxas_messages_uxnative_sub_task_assignment(&mut self) -> Option<&mut SubTaskAssignment> { None }
fn sub_tasks(&self) -> &Vec<Box<::afrl::cmasi::task::TaskT>>;
fn sub_tasks_mut(&mut self) -> &mut Vec<Box<::afrl::cmasi::task::TaskT>>;
fn neighbors(&self) -> &Vec<Box<::afrl::cmasi::entity_state::EntityStateT>>;
fn neighbors_mut(&mut self) -> &mut Vec<Box<::afrl::cmasi::entity_state::EntityStateT>>;
}
impl Clone for Box<SubTaskAssignmentT> {
fn clone(&self) -> Box<SubTaskAssignmentT> {
if let Some(x) = SubTaskAssignmentT::as_uxas_messages_uxnative_sub_task_assignment(self.as_ref()) {
Box::new(x.clone())
} else {
unreachable!()
}
}
}
impl Default for Box<SubTaskAssignmentT> {
fn default() -> Box<SubTaskAssignmentT> { Box::new(SubTaskAssignment::default()) }
}
impl PartialEq for Box<SubTaskAssignmentT> {
fn eq(&self, other: &Box<SubTaskAssignmentT>) -> bool {
if let (Some(x), Some(y)) =
(SubTaskAssignmentT::as_uxas_messages_uxnative_sub_task_assignment(self.as_ref()),
SubTaskAssignmentT::as_uxas_messages_uxnative_sub_task_assignment(other.as_ref())) {
x == y
} else {
false
}
}
}
impl Lmcp for Box<SubTaskAssignmentT> {
fn ser(&self, buf: &mut[u8]) -> Result<usize, Error> {
if let Some(x) = SubTaskAssignmentT::as_uxas_messages_uxnative_sub_task_assignment(self.as_ref()) {
x.ser(buf)
} else {
unreachable!()
}
}
fn deser(buf: &[u8]) -> Result<(Box<SubTaskAssignmentT>, usize), Error> {
let (si, _) = StructInfo::deser(buf)?;
if si == SubTaskAssignment::struct_info() {
let (x, readb) = SubTaskAssignment::deser(buf)?;
Ok((Box::new(x), readb))
} else {
Err(error!(ErrorType::InvalidStructInfo))
}
}
fn size(&self) -> usize {
if let Some(x) = SubTaskAssignmentT::as_uxas_messages_uxnative_sub_task_assignment(self.as_ref()) {
x.size()
} else {
unreachable!()
}
}
}
impl SubTaskAssignmentT for SubTaskAssignment {
fn as_uxas_messages_uxnative_sub_task_assignment(&self) -> Option<&SubTaskAssignment> { Some(self) }
fn as_mut_uxas_messages_uxnative_sub_task_assignment(&mut self) -> Option<&mut SubTaskAssignment> { Some(self) }
fn sub_tasks(&self) -> &Vec<Box<::afrl::cmasi::task::TaskT>> { &self.sub_tasks }
fn sub_tasks_mut(&mut self) -> &mut Vec<Box<::afrl::cmasi::task::TaskT>> { &mut self.sub_tasks }
fn neighbors(&self) -> &Vec<Box<::afrl::cmasi::entity_state::EntityStateT>> { &self.neighbors }
fn neighbors_mut(&mut self) -> &mut Vec<Box<::afrl::cmasi::entity_state::EntityStateT>> { &mut self.neighbors }
}
#[cfg(test)]
pub mod tests {
use super::*;
use quickcheck::*;
impl Arbitrary for SubTaskAssignment {
fn arbitrary<G: Gen>(_g: &mut G) -> SubTaskAssignment {
SubTaskAssignment {
sub_tasks: Vec::<::afrl::cmasi::task::Task>::arbitrary(_g).into_iter().map(|x| Box::new(x) as Box<::afrl::cmasi::task::TaskT>).collect(),
neighbors: Vec::<::afrl::cmasi::entity_state::EntityState>::arbitrary(_g).into_iter().map(|x| Box::new(x) as Box<::afrl::cmasi::entity_state::EntityStateT>).collect(),
}
}
}
quickcheck! {
fn serializes(x: SubTaskAssignment) -> Result<TestResult, Error> {
use std::u16;
if x.sub_tasks.len() > (u16::MAX as usize) { return Ok(TestResult::discard()); }
if x.neighbors.len() > (u16::MAX as usize) { return Ok(TestResult::discard()); }
let mut buf: Vec<u8> = vec![0; x.size()];
let sx = x.ser(&mut buf)?;
Ok(TestResult::from_bool(sx == x.size()))
}
fn roundtrips(x: SubTaskAssignment) -> Result<TestResult, Error> {
use std::u16;
if x.sub_tasks.len() > (u16::MAX as usize) { return Ok(TestResult::discard()); }
if x.neighbors.len() > (u16::MAX as usize) { return Ok(TestResult::discard()); }
let mut buf: Vec<u8> = vec![0; x.size()];
let sx = x.ser(&mut buf)?;
let (y, sy) = SubTaskAssignment::deser(&buf)?;
Ok(TestResult::from_bool(sx == sy && x == y))
}
}
}
|
/*
* Datadog API V1 Collection
*
* Collection of all Datadog Public endpoints.
*
* The version of the OpenAPI document: 1.0
* Contact: support@datadoghq.com
* Generated by: https://openapi-generator.tech
*/
/// IpPrefixesWebhooks : Available prefix information for the Webhook endpoints.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct IpPrefixesWebhooks {
/// List of IPv4 prefixes.
#[serde(rename = "prefixes_ipv4", skip_serializing_if = "Option::is_none")]
pub prefixes_ipv4: Option<Vec<String>>,
/// List of IPv6 prefixes.
#[serde(rename = "prefixes_ipv6", skip_serializing_if = "Option::is_none")]
pub prefixes_ipv6: Option<Vec<String>>,
}
impl IpPrefixesWebhooks {
/// Available prefix information for the Webhook endpoints.
pub fn new() -> IpPrefixesWebhooks {
IpPrefixesWebhooks {
prefixes_ipv4: None,
prefixes_ipv6: None,
}
}
}
|
//! Utilities for cleaning strings.
use std::iter::FromIterator;
use std::borrow::Cow;
use unicode_normalization::*;
/// Normalize Unicode character representations in a string.
pub fn norm_unicode<'a>(s: &'a str) -> Cow<'a, str> {
if is_nfd_quick(s.chars()) == IsNormalized::Yes {
s.into()
} else {
String::from_iter(s.nfd()).into()
}
}
#[test]
fn test_nu_empty() {
let text = "";
let res = norm_unicode(&text);
assert_eq!(res.as_ref(), "");
}
#[test]
fn test_nu_basic() {
let text = "foo";
let res = norm_unicode(&text);
assert_eq!(res.as_ref(), "foo");
}
#[test]
fn test_nu_metal() {
let text = "metäl";
let res = norm_unicode(&text);
assert_eq!(res.as_ref(), "meta\u{0308}l");
}
|
extern crate futures;
extern crate hyper;
extern crate serde_json;
extern crate stq_http;
extern crate tokio_core;
extern crate users_lib;
mod client_test;
|
#[doc = "Register `TR3` reader"]
pub type R = crate::R<TR3_SPEC>;
#[doc = "Register `TR3` writer"]
pub type W = crate::W<TR3_SPEC>;
#[doc = "Field `LT3` reader - LT3"]
pub type LT3_R = crate::FieldReader;
#[doc = "Field `LT3` writer - LT3"]
pub type LT3_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 8, O>;
#[doc = "Field `HT3` reader - HT3"]
pub type HT3_R = crate::FieldReader;
#[doc = "Field `HT3` writer - HT3"]
pub type HT3_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 8, O>;
impl R {
#[doc = "Bits 0:7 - LT3"]
#[inline(always)]
pub fn lt3(&self) -> LT3_R {
LT3_R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 16:23 - HT3"]
#[inline(always)]
pub fn ht3(&self) -> HT3_R {
HT3_R::new(((self.bits >> 16) & 0xff) as u8)
}
}
impl W {
#[doc = "Bits 0:7 - LT3"]
#[inline(always)]
#[must_use]
pub fn lt3(&mut self) -> LT3_W<TR3_SPEC, 0> {
LT3_W::new(self)
}
#[doc = "Bits 16:23 - HT3"]
#[inline(always)]
#[must_use]
pub fn ht3(&mut self) -> HT3_W<TR3_SPEC, 16> {
HT3_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "watchdog threshold register 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`tr3::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`tr3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct TR3_SPEC;
impl crate::RegisterSpec for TR3_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`tr3::R`](R) reader structure"]
impl crate::Readable for TR3_SPEC {}
#[doc = "`write(|w| ..)` method takes [`tr3::W`](W) writer structure"]
impl crate::Writable for TR3_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets TR3 to value 0x0fff_0000"]
impl crate::Resettable for TR3_SPEC {
const RESET_VALUE: Self::Ux = 0x0fff_0000;
}
|
use super::{api::*, util::*};
use crate::{Error, PrefixContext};
/// Compile and use a procedural macro
#[poise::command(
prefix_command,
track_edits,
broadcast_typing,
explanation_fn = "procmacro_help"
)]
pub async fn procmacro(
ctx: PrefixContext<'_>,
flags: poise::KeyValueArgs,
macro_code: poise::CodeBlock,
usage_code: poise::CodeBlock,
) -> Result<(), Error> {
let macro_code = macro_code.code;
let usage_code = maybe_wrap(&usage_code.code, ResultHandling::None);
let (flags, flag_parse_errors) = parse_flags(flags);
let generated_code = format!(
"{}{}{}{}{}{}{}",
r#"const MACRO_CODE: &str = r#####""#,
macro_code,
"\"",
r#"#####;
const USAGE_CODE: &str = r#####""#,
usage_code,
"\"",
r#"#####;
pub fn cmd_run(cmd: &str) {
let status = std::process::Command::new("/bin/sh")
.args(&["-c", cmd])
.status()
.unwrap();
if !status.success() {
std::process::exit(-1);
}
}
pub fn cmd_stdout(cmd: &str) -> String {
let output = std::process::Command::new("/bin/sh")
.args(&["-c", cmd])
.output()
.unwrap();
String::from_utf8(output.stdout).unwrap()
}
fn main() -> std::io::Result<()> {
use std::io::Write as _;
std::env::set_current_dir(cmd_stdout("mktemp -d").trim())?;
cmd_run("cargo init -q --name procmacro --lib");
std::fs::write("src/lib.rs", MACRO_CODE)?;
std::fs::write("src/main.rs", USAGE_CODE)?;
std::fs::OpenOptions::new()
.write(true)
.append(true)
.open("Cargo.toml")?
.write_all(b"[lib]\nproc-macro = true")?;
cmd_run("cargo c -q --bin procmacro");
Ok(())
}"#
);
let mut result: PlayResult = ctx
.data
.http
.post("https://play.rust-lang.org/execute")
.json(&PlaygroundRequest {
code: &generated_code,
// These flags only apply to the glue code
channel: Channel::Stable,
crate_type: CrateType::Binary,
edition: Edition::E2018,
mode: Mode::Debug,
tests: false,
})
.send()
.await?
.json()
.await?;
// funky
result.stderr = format_play_eval_stderr(
&format_play_eval_stderr(&result.stderr, flags.warn),
flags.warn,
);
send_reply(ctx, result, &generated_code, &flags, &flag_parse_errors).await
}
pub fn procmacro_help() -> String {
generic_help(GenericHelp {
command: "procmacro",
desc: "Compile and use a procedural macro by providing two snippets: one for the \
proc-macro code, and one for the usage code which can refer to the proc-macro crate as \
`procmacro`",
mode_and_channel: false,
warn: true,
example_code: "
#[proc_macro]
pub fn foo(_: proc_macro::TokenStream) -> proc_macro::TokenStream {
r#\"compile_error!(\"Fish is on fire\")\"#.parse().unwrap()
}
``\u{200B}` ``\u{200B}`
procmacro::foo!();
",
})
}
|
//! Module contains sdl thread local static initialization
use sdl2::{self, Sdl};
use std::cell::RefCell;
thread_local! (pub static SDL_CONTEXT: RefCell<Sdl> = RefCell::new(
sdl2::init().expect("SDL init failed")));
|
use cao_lang::prelude::Value;
use serde::{Deserialize, Serialize};
use std::convert::TryFrom;
#[derive(Debug, Serialize, Clone, Copy, Deserialize)]
#[serde(rename_all = "camelCase")]
#[repr(u8)]
pub enum Resource {
Empty = 0,
Energy = 1,
}
impl Default for Resource {
fn default() -> Self {
Resource::Empty
}
}
impl TryFrom<Value> for Resource {
type Error = Value;
fn try_from(s: Value) -> Result<Resource, Value> {
match s {
Value::Integer(i) => {
if i < 0 {
return Err(s);
}
match i {
1 => Ok(Resource::Energy),
_ => Err(s),
}
}
_ => Err(s),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResourceComponent(pub Resource);
impl Default for ResourceComponent {
fn default() -> Self {
Self(Resource::Energy)
}
}
|
mod area_allowance;
mod max_distance;
mod shift_time;
mod tour_size;
|
use crate::MssqlProvider;
use std::{env::var, ffi::OsStr};
use storm::{provider::ProviderFactory, BoxFuture, Error, Result};
use tiberius::Config;
pub struct MssqlFactory(pub Config);
impl MssqlFactory {
pub fn from_env<K>(var_name: K) -> Result<Self>
where
K: AsRef<OsStr>,
{
Ok(Self(Config::from_ado_string(
&var(var_name).map_err(Error::std)?,
)?))
}
}
impl ProviderFactory for MssqlFactory {
type Provider = MssqlProvider;
fn create_provider(&self) -> BoxFuture<'_, Result<Self::Provider>> {
Box::pin(async move { Ok(MssqlProvider::new(self.0.clone())) })
}
}
|
#[derive(PartialEq, Eq, Debug, Hash)]
pub struct BitMatrix {
rows: usize,
columns: usize,
data: Vec<bool>,
}
impl BitMatrix {
pub fn shape(data: Vec<bool>, rows: usize, columns: usize) -> BitMatrix {
if rows * columns != data.len() {
panic!(
"wrong size of data: {} values cannot be reshaped to a {} by {} matrix",
data.len(),
rows,
columns
);
}
BitMatrix {
rows: rows,
columns: columns,
data: data,
}
}
pub fn column_vector(data: Vec<bool>) -> BitMatrix {
BitMatrix {
rows: data.len(),
columns: 1,
data: data,
}
}
pub fn row_vector(data: Vec<bool>) -> BitMatrix {
BitMatrix {
rows: 1,
columns: data.len(),
data: data,
}
}
fn set(&mut self, row: usize, column: usize, value: bool) {
debug_assert!(
row < self.rows,
"row out of bounds: the row length is {}, but the row index is {}",
self.rows,
row
);
debug_assert!(
column < self.columns,
"column out of bounds: the column length is {}, but the column index is {}",
self.columns,
column
);
self.data[self.columns * row + column] = value;
}
pub fn get(&self, row: usize, column: usize) -> bool {
debug_assert!(
row < self.rows,
"row out of bounds: the row length is {}, but the row index is {}",
self.rows,
row
);
debug_assert!(
column < self.columns,
"column out of bounds: the column length is {}, but the column index is {}",
self.columns,
column
);
self.data[self.columns * row + column]
}
pub fn flip(&mut self, row: usize, column: usize) {
debug_assert!(
row < self.rows,
"row out of bounds: the row length is {}, but the row index is {}",
self.rows,
row
);
debug_assert!(
column < self.columns,
"column out of bounds: the column length is {}, but the column index is {}",
self.columns,
column
);
self.data[self.columns * row + column] ^= true;
}
pub fn row_len(&self) -> usize {
self.rows
}
pub fn column_len(&self) -> usize {
self.columns
}
pub fn transpose(&self) -> BitMatrix {
let mut data = Vec::with_capacity(self.data.len());
for column in 0..self.column_len() {
for row in 0..self.row_len() {
data.push(self.get(row, column))
}
}
BitMatrix::shape(data, self.columns, self.rows)
}
pub fn dot(&self, other: &BitMatrix) -> BitMatrix {
debug_assert!(self.column_len() == other.row_len(), "size mismatch: a matrix with {} columns may not be multiplied to a matrix with {} rows", self.column_len(), other.row_len());
let data = vec![false; self.row_len() * other.column_len()];
let mut output = BitMatrix::shape(data, self.row_len(), other.column_len());
for row in 0..self.row_len() {
for column in 0..other.column_len() {
let mut val = false;
for i in 0..self.column_len() {
val = val ^ (self.get(row, i) & other.get(i, column))
}
output.set(row, column, val);
}
}
return output;
}
pub fn format(&self) -> String {
let mut visual = String::from("[");
for column in 0..self.column_len() {
if column != 0 {
visual.push('\n');
visual.push(' ');
}
for row in 0..self.row_len() {
if row != 0 {
visual.push(' ');
}
if self.get(row, column) {
visual.push('1');
} else {
visual.push('0');
}
}
}
visual.push(']');
return visual;
}
pub fn to_vec(self) -> Vec<bool> {
assert!(self.column_len() == 1 || self.row_len() == 1);
return self.data;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn access() {
let x = BitMatrix::shape(vec![false, true, false, true], 2, 2);
assert_eq!(x.get(0, 0), false);
assert_eq!(x.get(0, 1), true);
assert_eq!(x.get(1, 0), false);
assert_eq!(x.get(1, 1), true);
}
#[test]
#[should_panic]
fn error_access() {
let x = BitMatrix::shape(vec![false, true, false, true], 2, 2);
assert_eq!(x.get(2, 2), false);
}
#[test]
#[should_panic]
fn error_create() {
let x = BitMatrix::shape(vec![false, true, false, true], 2, 3);
}
#[test]
fn transpose() {
let x = BitMatrix::column_vector(vec![false, true, false]);
let y = x.transpose();
assert_eq!(x.get(0, 0), y.get(0, 0));
assert_eq!(x.get(1, 0), y.get(0, 1));
assert_eq!(x.get(2, 0), y.get(0, 2));
}
#[test]
fn matrix() {
let x = BitMatrix::column_vector(vec![true, false, true]);
let y = BitMatrix::column_vector(vec![true, true, false]).transpose();
let z = x.dot(&y);
assert_eq!(z.row_len(), 3);
assert_eq!(z.column_len(), 3);
assert_eq!(z.get(0, 0), true);
assert_eq!(z.get(1, 0), false);
assert_eq!(z.get(2, 0), true);
assert_eq!(z.get(0, 1), true);
assert_eq!(z.get(1, 1), false);
assert_eq!(z.get(2, 1), true);
assert_eq!(z.get(0, 2), false);
assert_eq!(z.get(1, 2), false);
assert_eq!(z.get(2, 2), false);
}
#[test]
fn multiply() {
let x = BitMatrix::shape(vec![true, false, false, true], 2, 2);
let y = BitMatrix::column_vector(vec![true, false]);
let z = x.dot(&y);
assert_eq!(z.row_len(), 2);
assert_eq!(z.column_len(), 1);
assert_eq!(z.get(0, 0), true);
assert_eq!(z.get(1, 0), false);
}
#[test]
fn big() {
let x = BitMatrix::shape(vec![true, false, false, false, true, false], 2, 3);
let y = BitMatrix::column_vector(vec![true, false, true]);
let z = x.dot(&y);
assert_eq!(z.row_len(), 2);
assert_eq!(z.column_len(), 1);
assert_eq!(z.get(0, 0), true);
assert_eq!(z.get(1, 0), false);
}
#[test]
fn dot() {
let x = BitMatrix::column_vector(vec![true, false, true]).transpose();
let y = BitMatrix::column_vector(vec![true, false, true]);
let z = x.dot(&y);
assert_eq!(z.row_len(), 1);
assert_eq!(z.column_len(), 1);
assert_eq!(z.get(0, 0), false);
}
}
|
use raylib::prelude::*;
pub use raylib::prelude::Vector3;
pub fn unsigned_angle_vector2(a: Vector2, b: Vector2) -> f32 {
let mut angle = a.angle_to(b).to_degrees().abs();
if angle > 180. { angle -= 180. }
angle
}
pub fn slerp(start: Vector2, end: Vector2, time: f32) -> Vector2 {
// https://en.wikipedia.org/wiki/Slerp
// slerp(p0, p1, t) = sin((1-t)a) / sin a * p0 + sin ta / sin a * p1
if (start - end).length_sqr() <= 0.01 { return start; }
let p0 = start;
let p1 = end;
let t = time;
let a = unsigned_angle_vector2(start, end).to_radians();
let sa = a.sin();
(p0 * (((1. - t) * a).sin() / sa) + p1 * ((t * a).sin() / sa)).normalized()
} |
extern crate ipfs_api;
use ipfs_api::IpfsApi;
use std::path::Path;
fn main() {
let mut ipfs = IpfsApi::default();
let add_info = ipfs.add(&[Path::new("wireshark_capture/moloch.txt"),
Path::new("Cargo.toml")])
.expect("Error adding");
for info in add_info {
ipfs.cat(&info.Hash).expect("Error catting");
}
ipfs.version().expect("Error getting version");
}
|
use boxcars::ParserBuilder;
macro_rules! run {
($test_name:ident, $replay:expr) => {
#[test]
fn $test_name() {
let data = include_bytes!($replay);
let parsed = ParserBuilder::new(&data[..])
.always_check_crc()
.must_parse_network_data()
.parse();
match parsed {
Ok(_replay) => { },
Err(ref e) => panic!(format!("{}", e))
}
}
};
}
run!(not_working_1, "../assets/not_working (1).replay");
run!(not_working_2, "../assets/not_working (2).replay");
run!(not_working_3, "../assets/not_working (3).replay");
run!(not_working_4, "../assets/not_working (4).replay"); |
mod physical_disk;
pub use physical_disk::PhysicalDisk;
mod file;
pub use file::File;
pub type Error = nt_native::Error;
impl From<Error> for crate::Error {
fn from(err: Error) -> Self {
Self::Platform(err)
}
}
|
// Copyright © 2015, Peter Atashian
// Licensed under the MIT License <LICENSE.md>
#![feature(io, old_io, os, std_misc)]
extern crate "winapi" as w;
extern crate "kernel32-sys" as k32;
pub mod file;
use std::error::FromError;
use std::ffi::OsString;
use std::fmt::{self, Display, Formatter};
use std::ptr::{null, null_mut};
use std::os::windows::prelude::*;
#[derive(Clone, Copy, Debug)]
pub struct Error {
code: w::DWORD,
}
impl Error {
fn last() -> Error {
Error { code: unsafe { k32::GetLastError() } }
}
}
impl FromError<Error> for std::old_io::IoError {
fn from_error(err: Error) -> std::old_io::IoError {
std::old_io::IoError::from_errno(err.code as i32, true)
}
}
impl FromError<Error> for std::io::Error {
fn from_error(err: Error) -> std::io::Error {
std::io::Error::from_os_error(err.code as i32)
}
}
impl Display for Error {
fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
let mut buf = [0; 0x1000];
let len = unsafe {
k32::FormatMessageW(w::FORMAT_MESSAGE_FROM_SYSTEM, null(), self.code, 0,
buf.as_mut_ptr(), buf.len() as w::DWORD, null_mut())
};
if len == 0 { return Err(fmt::Error) }
let s = OsString::from_wide(&buf[..len as usize]);
fmt.pad(&s.to_string_lossy())
}
}
/// Sleep for the given time, waking if an I/O callback occurs.
///
/// Returns `false` if the timeout elapsed, or `true` if a callback occurred.
pub fn sleep(millis: u32) -> bool {
unsafe { k32::SleepEx(millis, 1) != 0 }
}
#[cfg(test)]
mod test {
use Error;
use std::error::FromError;
#[test]
fn test_error() {
println!("{}", Error::last());
println!("{}", Error { code: 0 });
println!("{}", <::std::old_io::IoError>::from_error(Error::last()));
println!("{}", <::std::io::Error>::from_error(Error::last()));
}
}
|
pub mod cmark;
pub trait Generator {
fn generate(&self);
}
pub struct HTMLGenerator {
}
pub struct CopyGenerator {
}
pub trait Collector {
}
pub struct MDCollector {
}
pub struct DirCollector {
}
pub struct Watcher {
}
pub struct Router {
}
|
pub struct ZXSpecs {
// frequencies
pub freq_cpu: usize,
// first_pixel_read_clocks (contention start)
pub clocks_first_pixel: usize,
// row clocks
pub clocks_left_border: usize,
pub clocks_screen_row: usize,
pub clocks_right_border: usize,
pub clocks_retrace: usize,
pub clocks_line: usize,
// some ula clocks
pub clocks_ula_read_shift: usize,
pub clocks_ula_read_origin: usize,
pub clocks_ula_contention_origin: usize,
pub clocks_ula_beam_shift: usize,
// frame
pub clocks_frame: usize,
// lines metrics
pub lines_vsync: usize,
pub lines_top_border: usize,
pub lines_screen: usize,
pub lines_bottom_border: usize,
pub lines_all: usize,
// interrupt
pub interrupt_length: usize,
// contention
pub contention_offset: usize,
pub contention_pattern: [usize; 8],
pub rom_pages: u8,
}
/// Specs builder, used to make static valiables with machines specs
pub struct ZXSpecsBuilder {
specs: ZXSpecs,
}
impl ZXSpecsBuilder {
/// Returns new ZXSpecsBuilder
pub fn new() -> ZXSpecsBuilder {
ZXSpecsBuilder {
specs: ZXSpecs {
// frequencies
freq_cpu: 0,
// first_pixel_clocks
clocks_first_pixel: 0,
// row clocks
clocks_left_border: 0,
clocks_screen_row: 0,
clocks_right_border: 0,
clocks_retrace: 0,
clocks_line: 0,
// some ula clocks
clocks_ula_read_shift: 0,
clocks_ula_read_origin: 0,
clocks_ula_contention_origin: 0,
clocks_ula_beam_shift: 0,
// frame clocks
clocks_frame: 0,
// lines metrics
lines_vsync: 0,
lines_top_border: 0,
lines_screen: 0,
lines_bottom_border: 0,
lines_all: 0,
// interrupt
interrupt_length: 0,
// contention
contention_offset: 0,
contention_pattern: [0; 8],
// memory
rom_pages: 0,
},
}
}
/// Builds new ZXSpecs
pub fn build(mut self) -> ZXSpecs {
self.specs.clocks_frame =
(self.specs.lines_all + self.specs.lines_vsync) * self.specs.clocks_line;
self.specs.clocks_ula_read_origin =
self.specs.clocks_first_pixel + self.specs.clocks_ula_read_shift;
self.specs.clocks_ula_contention_origin =
self.specs.clocks_first_pixel - self.specs.contention_offset;
self.specs
}
/// Changes CPU frequency
pub fn freq_cpu(mut self, value: usize) -> Self {
self.specs.freq_cpu = value;
self
}
/// Changes Clocks per left border, screen render, left border and retrace
pub fn clocks_row(
mut self,
lborder: usize,
screen: usize,
rborder: usize,
retrace: usize,
) -> Self {
self.specs.clocks_left_border = lborder;
self.specs.clocks_screen_row = screen;
self.specs.clocks_right_border = rborder;
self.specs.clocks_retrace = retrace;
self.specs.clocks_line = lborder + screen + rborder + retrace;
self
}
/// Changes first pixel clocks
pub fn clocks_first_pixel(mut self, value: usize) -> Self {
self.specs.clocks_first_pixel = value;
self
}
/// Changes shift of time, when ula reads data from memory
pub fn clocks_ula_read_shift(mut self, value: usize) -> Self {
self.specs.clocks_ula_read_shift = value;
self
}
/// Changes shift of electron beam pixel rendering
pub fn clocks_ula_beam_shift(mut self, value: usize) -> Self {
self.specs.clocks_ula_beam_shift = value;
self
}
/// Changes lines per top border, screen, bottom border and vsync
pub fn lines(mut self, tborder: usize, screen: usize, bborder: usize, vsync: usize) -> Self {
self.specs.lines_vsync = vsync;
self.specs.lines_top_border = tborder;
self.specs.lines_screen = screen;
self.specs.lines_bottom_border = bborder;
self.specs.lines_all = tborder + screen + bborder;
self
}
/// Changes contention pattern
pub fn contention(mut self, pattern: [usize; 8], offset: usize) -> Self {
self.specs.contention_pattern = pattern;
self.specs.contention_offset = offset;
self
}
/// changes interrupt length
pub fn interrupt_length(mut self, value: usize) -> Self {
self.specs.interrupt_length = value;
self
}
pub fn rom_pages(mut self, value: u8) -> Self {
self.specs.rom_pages = value;
self
}
}
|
//! For when you want to actually run the editor
use crate::{message::Message, pane_zone::PaneZone, theme::Theme, Field, Kind, ObjectStore};
use iced::{Element, Sandbox};
/// State of our actual editor.
pub struct AppState<K: Kind, C: ObjectStore<K>> {
/// Currently selected object
selected: Option<K::Key>,
/// Volatile container for our objects
container: C,
/// Appearance settings
theme: Theme,
}
impl<K: Kind, C: ObjectStore<K>> AppState<K, C> {
/// Get a reference to the app's theme.
pub fn theme(&self) -> &Theme {
&self.theme
}
/// Set the new selected object, if it exists. Otherwise, selection is cleared.
pub fn select(&mut self, selected: Option<K::Key>) {
self.selected = match selected {
Some(x) => match self.container.exists(&x) {
true => Some(x),
false => None,
},
None => None,
}
}
/// Get a reference to the currently selected object and its working values
pub fn selected(&self) -> Option<(&K::Key, &K, &<<K as Kind>::Field as Field>::WorkingValues)> {
self.selected
.as_ref()
.and_then(|x| self.container.get(x).map(|(v, w)| (x, v, w)))
}
/// Get a mutable reference to the currently selected object and its working values
pub fn selected_mut(
&mut self,
) -> Option<(&mut K, &mut <<K as Kind>::Field as Field>::WorkingValues)> {
match self.selected.as_ref() {
Some(k) => self.container.get_mut(k),
None => None,
}
}
/// Get the currently selected key
pub fn selected_key(&self) -> Option<&K::Key> {
self.selected.as_ref()
}
pub fn is_selected(&self, key: &K::Key) -> bool {
match self.selected.as_ref() {
Some(x) => x == key,
None => false,
}
}
/// Get a reference to the object container.
pub fn container(&self) -> &C {
&self.container
}
/// Get a mutable reference to the object container.
pub fn container_mut(&mut self) -> &mut C {
&mut self.container
}
/// Create a new object, and select it
pub fn new(&mut self) {
let k = self.container.add().clone();
self.select(Some(k));
}
}
/// The main editor window
pub struct App<K: Kind, C: ObjectStore<K>> {
/// Stores state for splitting & moving around panes
pane_zone: PaneZone<K, C>,
/// Stores our actual application state
app_state: AppState<K, C>,
}
impl<K: Kind, C: ObjectStore<K>> Sandbox for App<K, C> {
type Message = Message<K>;
fn new() -> Self {
let app_state = AppState {
selected: None,
theme: Theme::default(),
container: C::empty(),
};
Self {
pane_zone: PaneZone::new(),
app_state,
}
}
fn title(&self) -> String {
String::from("A cool application")
}
fn view(&mut self) -> Element<Self::Message> {
self.pane_zone.view(&self.app_state)
}
fn update(&mut self, message: Self::Message) {
match message {
Message::Nop => (),
Message::PaneMessage(msg) => {
self.pane_zone.update(msg);
}
Message::Select(x) => self.app_state.select(Some(x)),
Message::NewObject => self.app_state.new(),
Message::Mutate(vm, wm) => {
if let Some((v, w)) = self.app_state.selected_mut() {
vm.apply(v);
wm.apply(w);
}
}
}
}
}
|
use view::{View, ViewWrapper};
use vec::Vec2;
/// Simple wrapper view that asks for all the space it can get.
pub struct FullView<T: View> {
view: T,
}
impl<T: View> FullView<T> {
/// Wraps the given view into a new FullView.
pub fn new(view: T) -> Self {
FullView { view: view }
}
}
impl<T: View> ViewWrapper for FullView<T> {
wrap_impl!(&self.view);
fn wrap_get_min_size(&mut self, req: Vec2) -> Vec2 {
req
}
}
|
#[cfg(test)]
#[path = "../../../tests/unit/solver/mutation/decompose_search_test.rs"]
mod decompose_search_test;
use super::super::rand::prelude::SliceRandom;
use crate::algorithms::nsga2::Objective;
use crate::construction::heuristics::*;
use crate::solver::mutation::Mutation;
use crate::solver::population::{Greedy, Individual, Population};
use crate::solver::RefinementContext;
use crate::utils::parallel_into_collect;
use hashbrown::HashSet;
use std::cmp::Ordering;
use std::iter::{empty, once};
use std::sync::{Arc, RwLock};
/// A mutation which decomposes original solution into multiple partial solutions,
/// preforms search independently, and then merges partial solution back into one solution.
pub struct DecomposeSearch {
inner_mutation: Arc<dyn Mutation + Send + Sync>,
max_routes_range: (i32, i32),
repeat_count: usize,
}
impl DecomposeSearch {
/// Create a new instance of `DecomposeSearch`.
pub fn new(
inner_mutation: Arc<dyn Mutation + Send + Sync>,
max_routes_range: (usize, usize),
repeat_count: usize,
) -> Self {
let max_routes_range = (max_routes_range.0 as i32, max_routes_range.1 as i32);
Self { inner_mutation, max_routes_range, repeat_count }
}
}
impl Mutation for DecomposeSearch {
fn mutate(&self, refinement_ctx: &RefinementContext, insertion_ctx: &InsertionContext) -> InsertionContext {
decompose_individual(&refinement_ctx, insertion_ctx, self.max_routes_range)
.map(|contexts| self.refine_decomposed(refinement_ctx, insertion_ctx, contexts))
.unwrap_or_else(|| self.inner_mutation.mutate(refinement_ctx, insertion_ctx))
}
}
const GREEDY_ERROR: &str = "greedy population has no individuals";
impl DecomposeSearch {
fn refine_decomposed(
&self,
refinement_ctx: &RefinementContext,
original_individual: &Individual,
decomposed: Vec<(RefinementContext, HashSet<usize>)>,
) -> Individual {
// NOTE: validate decomposition
decomposed.iter().enumerate().for_each(|(outer_ix, (_, outer))| {
decomposed.iter().enumerate().filter(|(inner_idx, _)| outer_ix != *inner_idx).for_each(
|(_, (_, inner))| {
assert!(outer.intersection(&inner).next().is_none());
},
);
});
// do actual refinement independently for each decomposed context
let decomposed = parallel_into_collect(decomposed, |mut decomposed| {
(0..self.repeat_count).for_each(|_| {
let insertion_ctx = decomposed.0.population.select().next().expect(GREEDY_ERROR);
let insertion_ctx = self.inner_mutation.mutate(&decomposed.0, insertion_ctx);
decomposed.0.population.add(insertion_ctx);
});
decomposed
});
// merge evolution results into one individual
let mut individual = decomposed.into_iter().fold(
Individual::new_empty(refinement_ctx.problem.clone(), refinement_ctx.environment.clone()),
|individual, decomposed| merge_best(decomposed, original_individual, individual),
);
individual.restore();
finalize_insertion_ctx(&mut individual);
individual
}
}
fn create_population(individual: Individual) -> Box<dyn Population + Send + Sync> {
Box::new(Greedy::new(individual.problem.clone(), 1, Some(individual)))
}
fn create_multiple_individuals(
individual: &Individual,
max_routes_range: (i32, i32),
) -> Option<Vec<(Individual, HashSet<usize>)>> {
let mut route_groups_distances = group_routes_by_proximity(individual)?;
route_groups_distances.iter_mut().for_each(|route_distances| {
let random = &individual.environment.random;
let shuffle_count = random.uniform_int(2, (route_distances.len() as i32 / 4).max(2)) as usize;
route_distances.partial_shuffle(&mut random.get_rng(), shuffle_count);
});
// identify route groups and create individuals from them
let used_indices = RwLock::new(HashSet::new());
let individuals = route_groups_distances
.iter()
.enumerate()
.filter(|(outer_idx, _)| !used_indices.read().unwrap().contains(outer_idx))
.map(|(outer_idx, route_group_distance)| {
let group_size = individual.environment.random.uniform_int(max_routes_range.0, max_routes_range.1) as usize;
let route_group = once(outer_idx)
.chain(
route_group_distance
.iter()
.cloned()
.filter(|(inner_idx, _)| !used_indices.read().unwrap().contains(inner_idx))
.map(|(inner_idx, _)| inner_idx),
)
.take(group_size)
.collect::<HashSet<_>>();
route_group.iter().for_each(|idx| {
used_indices.write().unwrap().insert(*idx);
});
create_partial_individual(individual, route_group)
})
.chain(create_empty_individuals(individual))
.collect();
Some(individuals)
}
fn create_partial_individual(individual: &Individual, route_indices: HashSet<usize>) -> (Individual, HashSet<usize>) {
let solution = &individual.solution;
let routes = route_indices.iter().map(|idx| solution.routes[*idx].deep_copy()).collect::<Vec<_>>();
let actors = routes.iter().map(|route_ctx| route_ctx.route.actor.clone()).collect::<HashSet<_>>();
let registry = solution.registry.deep_slice(|actor| actors.contains(actor));
(
Individual {
problem: individual.problem.clone(),
solution: SolutionContext {
// NOTE we need to handle empty route indices case differently
required: if route_indices.is_empty() { solution.required.clone() } else { Default::default() },
ignored: if route_indices.is_empty() { solution.ignored.clone() } else { Default::default() },
unassigned: if route_indices.is_empty() { solution.unassigned.clone() } else { Default::default() },
locked: if route_indices.is_empty() {
let jobs = solution.routes.iter().flat_map(|rc| rc.route.tour.jobs()).collect::<HashSet<_>>();
solution.locked.iter().filter(|job| !jobs.contains(job)).cloned().collect()
} else {
let jobs = routes.iter().flat_map(|route_ctx| route_ctx.route.tour.jobs()).collect::<HashSet<_>>();
solution.locked.iter().filter(|job| jobs.contains(job)).cloned().collect()
},
routes,
registry,
state: Default::default(),
},
environment: individual.environment.clone(),
},
route_indices,
)
}
fn create_empty_individuals(individual: &Individual) -> Box<dyn Iterator<Item = (Individual, HashSet<usize>)>> {
// TODO split into more individuals if too many required jobs are present
// this might increase overall refinement speed
let solution = &individual.solution;
if solution.required.is_empty()
&& solution.unassigned.is_empty()
&& solution.ignored.is_empty()
&& solution.locked.is_empty()
{
Box::new(empty())
} else {
Box::new(once((
Individual {
problem: individual.problem.clone(),
solution: SolutionContext {
required: solution.required.clone(),
ignored: solution.ignored.clone(),
unassigned: solution.unassigned.clone(),
locked: solution.locked.clone(),
routes: Default::default(),
registry: solution.registry.deep_copy(),
state: Default::default(),
},
environment: individual.environment.clone(),
},
HashSet::default(),
)))
}
}
fn decompose_individual(
refinement_ctx: &RefinementContext,
individual: &Individual,
max_routes_range: (i32, i32),
) -> Option<Vec<(RefinementContext, HashSet<usize>)>> {
create_multiple_individuals(individual, max_routes_range)
.map(|individuals| {
individuals
.into_iter()
.map(|(individual, indices)| {
(
RefinementContext {
problem: refinement_ctx.problem.clone(),
population: create_population(individual),
state: Default::default(),
quota: refinement_ctx.quota.clone(),
environment: refinement_ctx.environment.clone(),
statistics: Default::default(),
},
indices,
)
})
.collect::<Vec<_>>()
})
.and_then(|contexts| if contexts.len() > 1 { Some(contexts) } else { None })
}
fn merge_best(
decomposed: (RefinementContext, HashSet<usize>),
original_individual: &Individual,
accumulated: Individual,
) -> Individual {
let (decomposed_ctx, route_indices) = decomposed;
let (decomposed_individual, _) = decomposed_ctx.population.ranked().next().expect(GREEDY_ERROR);
let (partial_individual, _) = create_partial_individual(original_individual, route_indices);
let objective = partial_individual.problem.objective.as_ref();
let source_solution = if objective.total_order(decomposed_individual, &partial_individual) == Ordering::Less {
&decomposed_individual.solution
} else {
&partial_individual.solution
};
let mut accumulated = accumulated;
let dest_solution = &mut accumulated.solution;
// NOTE theoretically, we can avoid deep copy here, but this would require extension in Population trait
dest_solution.routes.extend(source_solution.routes.iter().map(|route_ctx| route_ctx.deep_copy()));
dest_solution.ignored.extend(source_solution.ignored.iter().cloned());
dest_solution.required.extend(source_solution.required.iter().cloned());
dest_solution.locked.extend(source_solution.locked.iter().cloned());
dest_solution.unassigned.extend(source_solution.unassigned.iter().map(|(k, v)| (k.clone(), *v)));
source_solution.routes.iter().for_each(|route_ctx| {
dest_solution.registry.use_route(route_ctx);
});
accumulated
}
|
use super::{use_hook, Hook};
use std::rc::Rc;
/// This hook is an alternative to [`use_state`]. It is used to handle component's state and is used
/// when complex actions needs to be performed on said state.
///
/// For lazy initialization, consider using [`use_reducer_with_init`] instead.
///
/// # Example
/// ```rust
/// # use yew_functional::{function_component, use_reducer};
/// # use yew::prelude::*;
/// # use std::rc::Rc;
/// # use std::ops::DerefMut;
/// #
/// #[function_component(UseReducer)]
/// fn reducer() -> Html {
/// /// reducer's Action
/// enum Action {
/// Double,
/// Square,
/// }
///
/// /// reducer's State
/// struct CounterState {
/// counter: i32,
/// }
///
/// let (
/// counter, // the state
/// // function to update the state
/// // as the same suggests, it dispatches the values to the reducer function
/// dispatch
/// ) = use_reducer(
/// // the reducer function
/// |prev: Rc<CounterState>, action: Action| CounterState {
/// counter: match action {
/// Action::Double => prev.counter * 2,
/// Action::Square => prev.counter * prev.counter,
/// }
/// },
/// // initial state
/// CounterState { counter: 1 },
/// );
///
/// let double_onclick = {
/// let dispatch = Rc::clone(&dispatch);
/// Callback::from(move |_| dispatch(Action::Double))
/// };
/// let square_onclick = Callback::from(move |_| dispatch(Action::Square));
///
/// html! {
/// <>
/// <div id="result">{ counter.counter }</div>
///
/// <button onclick=double_onclick>{ "Double" }</button>
/// <button onclick=square_onclick>{ "Square" }</button>
/// </>
/// }
/// }
/// ```
pub fn use_reducer<Action: 'static, Reducer, State: 'static>(
reducer: Reducer,
initial_state: State,
) -> (Rc<State>, Rc<impl Fn(Action)>)
where
Reducer: Fn(Rc<State>, Action) -> State + 'static,
{
use_reducer_with_init(reducer, initial_state, |a| a)
}
/// [`use_reducer`] but with init argument.
///
/// This is useful for lazy initialization where it is beneficial not to perform expensive
/// computation up-front
///
/// # Example
/// ```rust
/// # use yew_functional::{function_component, use_reducer_with_init};
/// # use yew::prelude::*;
/// # use std::rc::Rc;
/// #
/// #[function_component(UseReducerWithInit)]
/// fn reducer_with_init() -> Html {
/// struct CounterState {
/// counter: i32,
/// }
/// let (counter, dispatch) = use_reducer_with_init(
/// |prev: Rc<CounterState>, action: i32| CounterState {
/// counter: prev.counter + action,
/// },
/// 0,
/// |initial: i32| CounterState {
/// counter: initial + 10,
/// },
/// );
///
/// html! {
/// <>
/// <div id="result">{counter.counter}</div>
///
/// <button onclick=Callback::from(move |_| dispatch(10))>{"Increment by 10"}</button>
/// </>
/// }
/// }
/// ```
pub fn use_reducer_with_init<Action: 'static, Reducer, State: 'static, InitialState, InitFn>(
reducer: Reducer,
initial_state: InitialState,
init: InitFn,
) -> (Rc<State>, Rc<impl Fn(Action)>)
where
Reducer: Fn(Rc<State>, Action) -> State + 'static,
InitFn: Fn(InitialState) -> State,
{
struct UseReducerState<State> {
current_state: Rc<State>,
}
impl<T> Hook for UseReducerState<T> {}
let init = Box::new(init);
let reducer = Rc::new(reducer);
use_hook(
|internal_hook_change: &mut UseReducerState<State>, hook_callback| {
(
internal_hook_change.current_state.clone(),
Rc::new(move |action: Action| {
let reducer = reducer.clone();
hook_callback(
move |internal_hook_change: &mut UseReducerState<State>| {
internal_hook_change.current_state = Rc::new((reducer)(
internal_hook_change.current_state.clone(),
action,
));
true
},
false, // run pre render
);
}),
)
},
move || UseReducerState {
current_state: Rc::new(init(initial_state)),
},
)
}
|
use sdl2::ttf;
use sdl2::ttf::Sdl2TtfContext;
use std::collections::HashMap;
use std::marker::PhantomData;
pub struct Font {
context: Sdl2TtfContext,
}
impl Font {
pub fn new(context: Sdl2TtfContext) -> Font {
Font { context }
}
pub fn build(&self, path: &str, size: u16) -> Result<Text, String> {
let font = self.context.load_font(path, size)?;
Ok(Text { font })
}
}
pub struct Text<'ttf> {
font: ttf::Font<'ttf, 'static>,
}
impl<'ttf> Text<'ttf> {
pub fn draw(&self, string: &str, buf: &mut [u8]) -> Result<(), String> {
let font_surface = self
.font
.render(string)
.blended((0, 0, 255, 255))
.map_err(|e| e.to_string())?;
font_surface.with_lock(|data| {
for x in 0..font_surface.width() {
for y in 0..font_surface.height() {
let dst_idx = (((320 * y) + x) * 4) as usize;
let dst = buf.get_mut(dst_idx..dst_idx + 4);
let src_idx = (((font_surface.width() * y) + x) * 4) as usize;
let src = data.get(src_idx..src_idx + 4);
if let Some(dst) = dst {
if let Some(src) = src {
if src[1] == 0 && src[2] == 0 && src[3] == 0 {
continue;
}
dst.copy_from_slice(&[src[1], src[2], src[3], src[0]]);
}
}
}
}
});
Ok(())
}
}
|
use shred::{
Dispatcher, DispatcherBuilder, Read, ResourceId, RunningTime, System, SystemData, World, Write,
};
fn sleep_short() {
use std::{thread::sleep, time::Duration};
sleep(Duration::new(0, 1_000));
}
#[derive(Default)]
struct Res;
#[derive(Default)]
struct ResB;
#[cfg(feature = "shred-derive")]
#[derive(SystemData)]
struct DummyData<'a> {
_res: Read<'a, Res>,
}
#[cfg(not(feature = "shred-derive"))]
struct DummyData<'a> {
_res: Read<'a, Res>,
}
#[cfg(not(feature = "shred-derive"))]
impl<'a> SystemData<'a> for DummyData<'a> {
fn setup(world: &mut World) {
Read::<'_, Res>::setup(world);
}
fn fetch(world: &'a World) -> Self {
Self {
_res: Read::<'_, Res>::fetch(world),
}
}
fn reads() -> Vec<ResourceId> {
Read::<'_, Res>::reads()
}
fn writes() -> Vec<ResourceId> {
Read::<'_, Res>::writes()
}
}
#[cfg(feature = "shred-derive")]
#[derive(SystemData)]
struct DummyDataMut<'a> {
_res: Write<'a, Res>,
}
#[cfg(not(feature = "shred-derive"))]
struct DummyDataMut<'a> {
_res: Write<'a, Res>,
}
#[cfg(not(feature = "shred-derive"))]
impl<'a> SystemData<'a> for DummyDataMut<'a> {
fn setup(world: &mut World) {
Write::<'_, Res>::setup(world);
}
fn fetch(world: &'a World) -> Self {
Self {
_res: Write::<'_, Res>::fetch(world),
}
}
fn reads() -> Vec<ResourceId> {
Write::<'_, Res>::reads()
}
fn writes() -> Vec<ResourceId> {
Write::<'_, Res>::writes()
}
}
struct DummySys;
impl<'a> System<'a> for DummySys {
type SystemData = DummyData<'a>;
fn run(&mut self, _data: Self::SystemData) {
sleep_short()
}
}
struct DummySysMut;
impl<'a> System<'a> for DummySysMut {
type SystemData = DummyDataMut<'a>;
fn run(&mut self, _data: Self::SystemData) {
sleep_short()
}
}
struct Whatever<'a>(&'a i32);
impl<'a, 'b> System<'a> for Whatever<'b> {
type SystemData = ();
fn run(&mut self, _: Self::SystemData) {
println!("{}", self.0);
}
}
#[test]
fn dispatch_builder() {
DispatcherBuilder::new()
.with(DummySys, "a", &[])
.with(DummySys, "b", &["a"])
.with(DummySys, "c", &["a"])
.build();
}
#[test]
#[should_panic(expected = "No such system registered")]
fn dispatch_builder_invalid() {
DispatcherBuilder::new()
.with(DummySys, "a", &[])
.with(DummySys, "b", &["z"])
.build();
}
#[test]
fn dispatch_basic() {
let mut world = World::empty();
world.insert(Res);
let number = 5;
let mut d: Dispatcher = DispatcherBuilder::new()
.with(DummySys, "a", &[])
.with(DummySys, "b", &["a"])
.with(Whatever(&number), "w", &[])
.build();
d.dispatch(&world);
}
#[test]
fn dispatch_ww_block() {
let mut world = World::empty();
world.insert(Res);
let mut d: Dispatcher = DispatcherBuilder::new()
.with(DummySysMut, "a", &[])
.with(DummySysMut, "b", &[])
.build();
d.dispatch(&world);
}
#[test]
fn dispatch_rw_block() {
let mut world = World::empty();
world.insert(Res);
let mut d: Dispatcher = DispatcherBuilder::new()
.with(DummySys, "a", &[])
.with(DummySysMut, "b", &[])
.build();
d.dispatch(&world);
}
#[test]
fn dispatch_rw_block_rev() {
let mut world = World::empty();
world.insert(Res);
let mut d: Dispatcher = DispatcherBuilder::new()
.with(DummySysMut, "a", &[])
.with(DummySys, "b", &[])
.build();
d.dispatch(&world);
}
#[test]
fn dispatch_sequential() {
let mut world = World::empty();
world.insert(Res);
let mut d: Dispatcher = DispatcherBuilder::new()
.with(DummySysMut, "a", &[])
.with(DummySys, "b", &[])
.build();
d.dispatch_seq(&world);
}
#[cfg(feature = "parallel")]
#[test]
fn dispatch_async() {
let mut res = World::empty();
res.insert(Res);
let mut d = DispatcherBuilder::new()
.with(DummySysMut, "a", &[])
.with(DummySys, "b", &[])
.build_async(res);
d.dispatch();
d.wait();
}
#[cfg(feature = "parallel")]
#[test]
fn dispatch_async_res() {
let mut world = World::empty();
world.insert(Res);
let mut d = DispatcherBuilder::new()
.with(DummySysMut, "a", &[])
.with(DummySys, "b", &[])
.build_async(world);
d.dispatch();
let res = d.world_mut();
res.insert(ResB);
}
#[test]
fn dispatch_stage_group() {
let mut world = World::empty();
world.insert(Res);
world.insert(ResB);
struct ReadingFromResB;
impl<'a> System<'a> for ReadingFromResB {
type SystemData = Read<'a, ResB>;
fn run(&mut self, _: Self::SystemData) {
sleep_short()
}
fn running_time(&self) -> RunningTime {
RunningTime::Short
}
}
struct WritingToResB;
impl<'a> System<'a> for WritingToResB {
type SystemData = Write<'a, ResB>;
fn run(&mut self, _: Self::SystemData) {
sleep_short()
}
fn running_time(&self) -> RunningTime {
RunningTime::VeryShort
}
}
let mut d: Dispatcher = DispatcherBuilder::new()
.with(DummySys, "read_a", &[])
.with(ReadingFromResB, "read_b", &[])
.with(WritingToResB, "write_b", &[])
.build();
d.dispatch(&world);
}
|
use async_executor::Executor;
use log::*;
use std::net::SocketAddr;
use std::sync::{Arc, Weak};
use crate::net::error::{NetError, NetResult};
use crate::net::protocols::{ProtocolAddress, ProtocolPing};
use crate::net::sessions::Session;
use crate::net::{Acceptor, AcceptorPtr};
use crate::net::{ChannelPtr, P2p};
use crate::system::{StoppableTask, StoppableTaskPtr};
/// Defines inbound connections session.
pub struct InboundSession {
p2p: Weak<P2p>,
acceptor: AcceptorPtr,
accept_task: StoppableTaskPtr,
}
impl InboundSession {
/// Create a new inbound session.
pub fn new(p2p: Weak<P2p>) -> Arc<Self> {
let acceptor = Acceptor::new();
Arc::new(Self {
p2p,
acceptor,
accept_task: StoppableTask::new(),
})
}
/// Starts the inbound session. Begins by accepting connections and fails if
/// the address is not configured. Then runs the channel subscription
/// loop.
pub fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> NetResult<()> {
match self.p2p().settings().inbound {
Some(accept_addr) => {
self.clone()
.start_accept_session(accept_addr, executor.clone())?;
}
None => {
info!("Not configured for accepting incoming connections.");
return Ok(());
}
}
self.accept_task.clone().start(
self.clone().channel_sub_loop(executor.clone()),
// Ignore stop handler
|_| async {},
NetError::ServiceStopped,
executor,
);
Ok(())
}
/// Stops the inbound session.
pub async fn stop(&self) {
self.acceptor.stop().await;
self.accept_task.stop().await;
}
/// Start accepting connections for inbound session.
fn start_accept_session(
self: Arc<Self>,
accept_addr: SocketAddr,
executor: Arc<Executor<'_>>,
) -> NetResult<()> {
info!("Starting inbound session on {}", accept_addr);
let result = self.acceptor.clone().start(accept_addr, executor);
if let Err(err) = result {
error!("Error starting listener: {}", err);
}
result
}
/// Wait for all new channels created by the acceptor and call
/// setup_channel() on them.
async fn channel_sub_loop(self: Arc<Self>, executor: Arc<Executor<'_>>) -> NetResult<()> {
let channel_sub = self.acceptor.clone().subscribe().await;
loop {
let channel = channel_sub.receive().await?;
// Spawn a detached task to process the channel
// This will just perform the channel setup then exit.
executor
.spawn(self.clone().setup_channel(channel, executor.clone()))
.detach();
}
}
/// Registers the channel. First performs a network handshake and starts the
/// channel. Then starts sending keep-alive and address messages across the
/// channel.
async fn setup_channel(
self: Arc<Self>,
channel: ChannelPtr,
executor: Arc<Executor<'_>>,
) -> NetResult<()> {
info!("Connected inbound [{}]", channel.address());
self.clone()
.register_channel(channel.clone(), executor.clone())
.await?;
self.attach_protocols(channel, executor).await
}
/// Starts sending keep-alive and address messages across the channels.
async fn attach_protocols(
self: Arc<Self>,
channel: ChannelPtr,
executor: Arc<Executor<'_>>,
) -> NetResult<()> {
let settings = self.p2p().settings().clone();
let hosts = self.p2p().hosts().clone();
let protocol_ping = ProtocolPing::new(channel.clone(), settings.clone());
let protocol_addr = ProtocolAddress::new(channel, hosts).await;
protocol_ping.start(executor.clone()).await;
protocol_addr.start(executor).await;
Ok(())
}
}
impl Session for InboundSession {
fn p2p(&self) -> Arc<P2p> {
self.p2p.upgrade().unwrap()
}
}
|
#![doc = "generated by AutoRust 0.1.0"]
#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(unused_imports)]
use super::{models, API_VERSION};
#[non_exhaustive]
#[derive(Debug, thiserror :: Error)]
#[allow(non_camel_case_types)]
pub enum Error {
#[error(transparent)]
SecurityConnectors_List(#[from] security_connectors::list::Error),
#[error(transparent)]
SecurityConnectors_ListByResourceGroup(#[from] security_connectors::list_by_resource_group::Error),
#[error(transparent)]
SecurityConnectors_Get(#[from] security_connectors::get::Error),
#[error(transparent)]
SecurityConnectors_CreateOrUpdate(#[from] security_connectors::create_or_update::Error),
#[error(transparent)]
SecurityConnectors_Update(#[from] security_connectors::update::Error),
#[error(transparent)]
SecurityConnectors_Delete(#[from] security_connectors::delete::Error),
#[error(transparent)]
MdeOnboardings_List(#[from] mde_onboardings::list::Error),
#[error(transparent)]
MdeOnboardings_Get(#[from] mde_onboardings::get::Error),
#[error(transparent)]
CustomAssessmentAutomations_Get(#[from] custom_assessment_automations::get::Error),
#[error(transparent)]
CustomAssessmentAutomations_Create(#[from] custom_assessment_automations::create::Error),
#[error(transparent)]
CustomAssessmentAutomations_Delete(#[from] custom_assessment_automations::delete::Error),
#[error(transparent)]
CustomAssessmentAutomations_ListByResourceGroup(#[from] custom_assessment_automations::list_by_resource_group::Error),
#[error(transparent)]
CustomAssessmentAutomations_ListBySubscription(#[from] custom_assessment_automations::list_by_subscription::Error),
#[error(transparent)]
CustomEntityStoreAssignments_Get(#[from] custom_entity_store_assignments::get::Error),
#[error(transparent)]
CustomEntityStoreAssignments_Create(#[from] custom_entity_store_assignments::create::Error),
#[error(transparent)]
CustomEntityStoreAssignments_Delete(#[from] custom_entity_store_assignments::delete::Error),
#[error(transparent)]
CustomEntityStoreAssignments_ListByResourceGroup(#[from] custom_entity_store_assignments::list_by_resource_group::Error),
#[error(transparent)]
CustomEntityStoreAssignments_ListBySubscription(#[from] custom_entity_store_assignments::list_by_subscription::Error),
#[error(transparent)]
SoftwareInventories_ListByExtendedResource(#[from] software_inventories::list_by_extended_resource::Error),
#[error(transparent)]
SoftwareInventories_ListBySubscription(#[from] software_inventories::list_by_subscription::Error),
#[error(transparent)]
SoftwareInventories_Get(#[from] software_inventories::get::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentScans_Get(#[from] sql_vulnerability_assessment_scans::get::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentScans_List(#[from] sql_vulnerability_assessment_scans::list::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentScanResults_Get(#[from] sql_vulnerability_assessment_scan_results::get::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentScanResults_List(#[from] sql_vulnerability_assessment_scan_results::list::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentBaselineRules_Get(#[from] sql_vulnerability_assessment_baseline_rules::get::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentBaselineRules_CreateOrUpdate(#[from] sql_vulnerability_assessment_baseline_rules::create_or_update::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentBaselineRules_Delete(#[from] sql_vulnerability_assessment_baseline_rules::delete::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentBaselineRules_List(#[from] sql_vulnerability_assessment_baseline_rules::list::Error),
#[error(transparent)]
SqlVulnerabilityAssessmentBaselineRules_Add(#[from] sql_vulnerability_assessment_baseline_rules::add::Error),
#[error(transparent)]
SecureScores_List(#[from] secure_scores::list::Error),
#[error(transparent)]
SecureScores_Get(#[from] secure_scores::get::Error),
#[error(transparent)]
SecureScoreControls_ListBySecureScore(#[from] secure_score_controls::list_by_secure_score::Error),
#[error(transparent)]
SecureScoreControls_List(#[from] secure_score_controls::list::Error),
#[error(transparent)]
SecureScoreControlDefinitions_List(#[from] secure_score_control_definitions::list::Error),
#[error(transparent)]
SecureScoreControlDefinitions_ListBySubscription(#[from] secure_score_control_definitions::list_by_subscription::Error),
#[error(transparent)]
Connectors_List(#[from] connectors::list::Error),
#[error(transparent)]
Connectors_Get(#[from] connectors::get::Error),
#[error(transparent)]
Connectors_CreateOrUpdate(#[from] connectors::create_or_update::Error),
#[error(transparent)]
Connectors_Delete(#[from] connectors::delete::Error),
#[error(transparent)]
Automations_List(#[from] automations::list::Error),
#[error(transparent)]
Automations_ListByResourceGroup(#[from] automations::list_by_resource_group::Error),
#[error(transparent)]
Automations_Get(#[from] automations::get::Error),
#[error(transparent)]
Automations_CreateOrUpdate(#[from] automations::create_or_update::Error),
#[error(transparent)]
Automations_Delete(#[from] automations::delete::Error),
#[error(transparent)]
Automations_Validate(#[from] automations::validate::Error),
#[error(transparent)]
SubAssessments_ListAll(#[from] sub_assessments::list_all::Error),
#[error(transparent)]
SubAssessments_List(#[from] sub_assessments::list::Error),
#[error(transparent)]
SubAssessments_Get(#[from] sub_assessments::get::Error),
#[error(transparent)]
RegulatoryComplianceStandards_List(#[from] regulatory_compliance_standards::list::Error),
#[error(transparent)]
RegulatoryComplianceStandards_Get(#[from] regulatory_compliance_standards::get::Error),
#[error(transparent)]
RegulatoryComplianceControls_List(#[from] regulatory_compliance_controls::list::Error),
#[error(transparent)]
RegulatoryComplianceControls_Get(#[from] regulatory_compliance_controls::get::Error),
#[error(transparent)]
RegulatoryComplianceAssessments_List(#[from] regulatory_compliance_assessments::list::Error),
#[error(transparent)]
RegulatoryComplianceAssessments_Get(#[from] regulatory_compliance_assessments::get::Error),
#[error(transparent)]
Pricings_List(#[from] pricings::list::Error),
#[error(transparent)]
Pricings_Get(#[from] pricings::get::Error),
#[error(transparent)]
Pricings_Update(#[from] pricings::update::Error),
#[error(transparent)]
SecurityContacts_List(#[from] security_contacts::list::Error),
#[error(transparent)]
SecurityContacts_Get(#[from] security_contacts::get::Error),
#[error(transparent)]
SecurityContacts_Create(#[from] security_contacts::create::Error),
#[error(transparent)]
SecurityContacts_Update(#[from] security_contacts::update::Error),
#[error(transparent)]
SecurityContacts_Delete(#[from] security_contacts::delete::Error),
#[error(transparent)]
WorkspaceSettings_List(#[from] workspace_settings::list::Error),
#[error(transparent)]
WorkspaceSettings_Get(#[from] workspace_settings::get::Error),
#[error(transparent)]
WorkspaceSettings_Create(#[from] workspace_settings::create::Error),
#[error(transparent)]
WorkspaceSettings_Update(#[from] workspace_settings::update::Error),
#[error(transparent)]
WorkspaceSettings_Delete(#[from] workspace_settings::delete::Error),
#[error(transparent)]
AutoProvisioningSettings_List(#[from] auto_provisioning_settings::list::Error),
#[error(transparent)]
AutoProvisioningSettings_Get(#[from] auto_provisioning_settings::get::Error),
#[error(transparent)]
AutoProvisioningSettings_Create(#[from] auto_provisioning_settings::create::Error),
#[error(transparent)]
Compliances_List(#[from] compliances::list::Error),
#[error(transparent)]
Compliances_Get(#[from] compliances::get::Error),
#[error(transparent)]
AdvancedThreatProtection_Get(#[from] advanced_threat_protection::get::Error),
#[error(transparent)]
AdvancedThreatProtection_Create(#[from] advanced_threat_protection::create::Error),
#[error(transparent)]
DeviceSecurityGroups_List(#[from] device_security_groups::list::Error),
#[error(transparent)]
DeviceSecurityGroups_Get(#[from] device_security_groups::get::Error),
#[error(transparent)]
DeviceSecurityGroups_CreateOrUpdate(#[from] device_security_groups::create_or_update::Error),
#[error(transparent)]
DeviceSecurityGroups_Delete(#[from] device_security_groups::delete::Error),
#[error(transparent)]
Settings_List(#[from] settings::list::Error),
#[error(transparent)]
Settings_Get(#[from] settings::get::Error),
#[error(transparent)]
Settings_Update(#[from] settings::update::Error),
#[error(transparent)]
InformationProtectionPolicies_Get(#[from] information_protection_policies::get::Error),
#[error(transparent)]
InformationProtectionPolicies_CreateOrUpdate(#[from] information_protection_policies::create_or_update::Error),
#[error(transparent)]
InformationProtectionPolicies_List(#[from] information_protection_policies::list::Error),
#[error(transparent)]
IoTSecuritySolutions_List(#[from] io_t_security_solutions::list::Error),
#[error(transparent)]
IoTSecuritySolutionsResourceGroup_List(#[from] io_t_security_solutions_resource_group::list::Error),
#[error(transparent)]
IotSecuritySolution_Get(#[from] iot_security_solution::get::Error),
#[error(transparent)]
IotSecuritySolution_Create(#[from] iot_security_solution::create::Error),
#[error(transparent)]
IotSecuritySolution_Update(#[from] iot_security_solution::update::Error),
#[error(transparent)]
IotSecuritySolution_Delete(#[from] iot_security_solution::delete::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalytics_GetAll(#[from] io_t_security_solutions_analytics::get_all::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalytics_GetDefault(#[from] io_t_security_solutions_analytics::get_default::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalyticsAggregatedAlerts_List(#[from] io_t_security_solutions_analytics_aggregated_alerts::list::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalyticsAggregatedAlert_Get(#[from] io_t_security_solutions_analytics_aggregated_alert::get::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalyticsAggregatedAlert_Dismiss(#[from] io_t_security_solutions_analytics_aggregated_alert::dismiss::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalyticsRecommendation_Get(#[from] io_t_security_solutions_analytics_recommendation::get::Error),
#[error(transparent)]
IoTSecuritySolutionsAnalyticsRecommendations_List(#[from] io_t_security_solutions_analytics_recommendations::list::Error),
#[error(transparent)]
Operations_List(#[from] operations::list::Error),
#[error(transparent)]
Locations_List(#[from] locations::list::Error),
#[error(transparent)]
Locations_Get(#[from] locations::get::Error),
#[error(transparent)]
Tasks_List(#[from] tasks::list::Error),
#[error(transparent)]
Tasks_ListByHomeRegion(#[from] tasks::list_by_home_region::Error),
#[error(transparent)]
Tasks_GetSubscriptionLevelTask(#[from] tasks::get_subscription_level_task::Error),
#[error(transparent)]
Tasks_UpdateSubscriptionLevelTaskState(#[from] tasks::update_subscription_level_task_state::Error),
#[error(transparent)]
Tasks_ListByResourceGroup(#[from] tasks::list_by_resource_group::Error),
#[error(transparent)]
Tasks_GetResourceGroupLevelTask(#[from] tasks::get_resource_group_level_task::Error),
#[error(transparent)]
Tasks_UpdateResourceGroupLevelTaskState(#[from] tasks::update_resource_group_level_task_state::Error),
#[error(transparent)]
Alerts_List(#[from] alerts::list::Error),
#[error(transparent)]
Alerts_ListByResourceGroup(#[from] alerts::list_by_resource_group::Error),
#[error(transparent)]
Alerts_ListSubscriptionLevelAlertsByRegion(#[from] alerts::list_subscription_level_alerts_by_region::Error),
#[error(transparent)]
Alerts_ListResourceGroupLevelAlertsByRegion(#[from] alerts::list_resource_group_level_alerts_by_region::Error),
#[error(transparent)]
Alerts_GetSubscriptionLevelAlert(#[from] alerts::get_subscription_level_alert::Error),
#[error(transparent)]
Alerts_GetResourceGroupLevelAlerts(#[from] alerts::get_resource_group_level_alerts::Error),
#[error(transparent)]
Alerts_UpdateSubscriptionLevelAlertStateToDismiss(#[from] alerts::update_subscription_level_alert_state_to_dismiss::Error),
#[error(transparent)]
Alerts_UpdateSubscriptionLevelAlertStateToReactivate(#[from] alerts::update_subscription_level_alert_state_to_reactivate::Error),
#[error(transparent)]
Alerts_UpdateResourceGroupLevelAlertStateToDismiss(#[from] alerts::update_resource_group_level_alert_state_to_dismiss::Error),
#[error(transparent)]
Alerts_UpdateResourceGroupLevelAlertStateToReactivate(#[from] alerts::update_resource_group_level_alert_state_to_reactivate::Error),
#[error(transparent)]
DiscoveredSecuritySolutions_List(#[from] discovered_security_solutions::list::Error),
#[error(transparent)]
DiscoveredSecuritySolutions_ListByHomeRegion(#[from] discovered_security_solutions::list_by_home_region::Error),
#[error(transparent)]
DiscoveredSecuritySolutions_Get(#[from] discovered_security_solutions::get::Error),
#[error(transparent)]
JitNetworkAccessPolicies_List(#[from] jit_network_access_policies::list::Error),
#[error(transparent)]
JitNetworkAccessPolicies_ListByRegion(#[from] jit_network_access_policies::list_by_region::Error),
#[error(transparent)]
JitNetworkAccessPolicies_ListByResourceGroup(#[from] jit_network_access_policies::list_by_resource_group::Error),
#[error(transparent)]
JitNetworkAccessPolicies_ListByResourceGroupAndRegion(#[from] jit_network_access_policies::list_by_resource_group_and_region::Error),
#[error(transparent)]
JitNetworkAccessPolicies_Get(#[from] jit_network_access_policies::get::Error),
#[error(transparent)]
JitNetworkAccessPolicies_CreateOrUpdate(#[from] jit_network_access_policies::create_or_update::Error),
#[error(transparent)]
JitNetworkAccessPolicies_Delete(#[from] jit_network_access_policies::delete::Error),
#[error(transparent)]
JitNetworkAccessPolicies_Initiate(#[from] jit_network_access_policies::initiate::Error),
#[error(transparent)]
AdaptiveApplicationControls_List(#[from] adaptive_application_controls::list::Error),
#[error(transparent)]
AdaptiveApplicationControls_Get(#[from] adaptive_application_controls::get::Error),
#[error(transparent)]
AdaptiveApplicationControls_Put(#[from] adaptive_application_controls::put::Error),
#[error(transparent)]
AdaptiveApplicationControls_Delete(#[from] adaptive_application_controls::delete::Error),
#[error(transparent)]
ExternalSecuritySolutions_List(#[from] external_security_solutions::list::Error),
#[error(transparent)]
ExternalSecuritySolutions_ListByHomeRegion(#[from] external_security_solutions::list_by_home_region::Error),
#[error(transparent)]
ExternalSecuritySolutions_Get(#[from] external_security_solutions::get::Error),
#[error(transparent)]
Topology_List(#[from] topology::list::Error),
#[error(transparent)]
Topology_ListByHomeRegion(#[from] topology::list_by_home_region::Error),
#[error(transparent)]
Topology_Get(#[from] topology::get::Error),
#[error(transparent)]
AllowedConnections_List(#[from] allowed_connections::list::Error),
#[error(transparent)]
AllowedConnections_ListByHomeRegion(#[from] allowed_connections::list_by_home_region::Error),
#[error(transparent)]
AllowedConnections_Get(#[from] allowed_connections::get::Error),
#[error(transparent)]
AdaptiveNetworkHardenings_ListByExtendedResource(#[from] adaptive_network_hardenings::list_by_extended_resource::Error),
#[error(transparent)]
AdaptiveNetworkHardenings_Get(#[from] adaptive_network_hardenings::get::Error),
#[error(transparent)]
AdaptiveNetworkHardenings_Enforce(#[from] adaptive_network_hardenings::enforce::Error),
#[error(transparent)]
AlertsSuppressionRules_List(#[from] alerts_suppression_rules::list::Error),
#[error(transparent)]
AlertsSuppressionRules_Get(#[from] alerts_suppression_rules::get::Error),
#[error(transparent)]
AlertsSuppressionRules_Update(#[from] alerts_suppression_rules::update::Error),
#[error(transparent)]
AlertsSuppressionRules_Delete(#[from] alerts_suppression_rules::delete::Error),
#[error(transparent)]
IngestionSettings_List(#[from] ingestion_settings::list::Error),
#[error(transparent)]
IngestionSettings_Get(#[from] ingestion_settings::get::Error),
#[error(transparent)]
IngestionSettings_Create(#[from] ingestion_settings::create::Error),
#[error(transparent)]
IngestionSettings_Delete(#[from] ingestion_settings::delete::Error),
#[error(transparent)]
IngestionSettings_ListTokens(#[from] ingestion_settings::list_tokens::Error),
#[error(transparent)]
IngestionSettings_ListConnectionStrings(#[from] ingestion_settings::list_connection_strings::Error),
}
pub mod security_connectors {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::SecurityConnectorsList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/securityConnectors",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityConnectorsList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
) -> std::result::Result<models::SecurityConnectorsList, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/securityConnectors",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityConnectorsList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
security_connector_name: &str,
) -> std::result::Result<models::SecurityConnector, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/securityConnectors/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
security_connector_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityConnector =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
security_connector_name: &str,
security_connector: &models::SecurityConnector,
) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/securityConnectors/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
security_connector_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(security_connector).map_err(create_or_update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityConnector = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityConnector = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SecurityConnector),
Created201(models::SecurityConnector),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
security_connector_name: &str,
security_connector: &models::SecurityConnector,
) -> std::result::Result<models::SecurityConnector, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/securityConnectors/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
security_connector_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PATCH);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(security_connector).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityConnector =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
security_connector_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/securityConnectors/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
security_connector_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod mde_onboardings {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::MdeOnboardingDataList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/mdeOnboardings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MdeOnboardingDataList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::MdeOnboardingData, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/mdeOnboardings/default",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MdeOnboardingData =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod custom_assessment_automations {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
custom_assessment_automation_name: &str,
) -> std::result::Result<models::CustomAssessmentAutomation, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customAssessmentAutomations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
custom_assessment_automation_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomAssessmentAutomation =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
custom_assessment_automation_name: &str,
custom_assessment_automation_body: &models::CustomAssessmentAutomationRequest,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customAssessmentAutomations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
custom_assessment_automation_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(custom_assessment_automation_body).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::CustomAssessmentAutomation =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Created201(rsp_value))
}
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomAssessmentAutomation =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Ok200(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Created201(models::CustomAssessmentAutomation),
Ok200(models::CustomAssessmentAutomation),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
custom_assessment_automation_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customAssessmentAutomations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
custom_assessment_automation_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
) -> std::result::Result<models::CustomAssessmentAutomationsListResult, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customAssessmentAutomations",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomAssessmentAutomationsListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_subscription(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::CustomAssessmentAutomationsListResult, list_by_subscription::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/customAssessmentAutomations",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list_by_subscription::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_subscription::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_subscription::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_subscription::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomAssessmentAutomationsListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_subscription::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_subscription {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod custom_entity_store_assignments {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
custom_entity_store_assignment_name: &str,
) -> std::result::Result<models::CustomEntityStoreAssignment, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customEntityStoreAssignments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
custom_entity_store_assignment_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomEntityStoreAssignment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
custom_entity_store_assignment_name: &str,
custom_entity_store_assignment_request_body: &models::CustomEntityStoreAssignmentRequest,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customEntityStoreAssignments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
custom_entity_store_assignment_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(custom_entity_store_assignment_request_body).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::CustomEntityStoreAssignment =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Created201(rsp_value))
}
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomEntityStoreAssignment =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Ok200(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Created201(models::CustomEntityStoreAssignment),
Ok200(models::CustomEntityStoreAssignment),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
custom_entity_store_assignment_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customEntityStoreAssignments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
custom_entity_store_assignment_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
) -> std::result::Result<models::CustomEntityStoreAssignmentsListResult, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourcegroups/{}/providers/Microsoft.Security/customEntityStoreAssignments",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomEntityStoreAssignmentsListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_subscription(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::CustomEntityStoreAssignmentsListResult, list_by_subscription::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/customEntityStoreAssignments",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list_by_subscription::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_subscription::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_subscription::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_subscription::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomEntityStoreAssignmentsListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_subscription::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_subscription {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod software_inventories {
use super::{models, API_VERSION};
pub async fn list_by_extended_resource(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
resource_namespace: &str,
resource_type: &str,
resource_name: &str,
) -> std::result::Result<models::SoftwaresList, list_by_extended_resource::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/{}/{}/{}/providers/Microsoft.Security/softwareInventories",
operation_config.base_path(),
subscription_id,
resource_group_name,
resource_namespace,
resource_type,
resource_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_extended_resource::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_extended_resource::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_extended_resource::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_extended_resource::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SoftwaresList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_extended_resource::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_extended_resource::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_extended_resource::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_extended_resource {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_subscription(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::SoftwaresList, list_by_subscription::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/softwareInventories",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list_by_subscription::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_subscription::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_subscription::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_subscription::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SoftwaresList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_subscription::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_subscription {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
resource_namespace: &str,
resource_type: &str,
resource_name: &str,
software_name: &str,
) -> std::result::Result<models::Software, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/{}/{}/{}/providers/Microsoft.Security/softwareInventories/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
resource_namespace,
resource_type,
resource_name,
software_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Software =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod sql_vulnerability_assessment_scans {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
scan_id: &str,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<models::Scan, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/scans/{}",
operation_config.base_path(),
resource_id,
scan_id
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Scan =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list(
operation_config: &crate::OperationConfig,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<models::Scans, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/scans",
operation_config.base_path(),
resource_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Scans =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod sql_vulnerability_assessment_scan_results {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
scan_id: &str,
scan_result_id: &str,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<models::ScanResult, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/scans/{}/scanResults/{}",
operation_config.base_path(),
resource_id,
scan_id,
scan_result_id
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ScanResult =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list(
operation_config: &crate::OperationConfig,
scan_id: &str,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<models::ScanResults, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/scans/{}/scanResults",
operation_config.base_path(),
resource_id,
scan_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ScanResults =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod sql_vulnerability_assessment_baseline_rules {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
rule_id: &str,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<models::RuleResults, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/baselineRules/{}",
operation_config.base_path(),
resource_id,
rule_id
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RuleResults =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
rule_id: &str,
workspace_id: &str,
resource_id: &str,
body: Option<&models::RuleResultsInput>,
) -> std::result::Result<models::RuleResults, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/baselineRules/{}",
operation_config.base_path(),
resource_id,
rule_id
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = if let Some(body) = body {
req_builder = req_builder.header("content-type", "application/json");
azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?
} else {
bytes::Bytes::from_static(azure_core::EMPTY_BODY)
};
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RuleResults = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
rule_id: &str,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/baselineRules/{}",
operation_config.base_path(),
resource_id,
rule_id
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list(
operation_config: &crate::OperationConfig,
workspace_id: &str,
resource_id: &str,
) -> std::result::Result<models::RulesResults, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/baselineRules",
operation_config.base_path(),
resource_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RulesResults =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn add(
operation_config: &crate::OperationConfig,
workspace_id: &str,
resource_id: &str,
body: Option<&models::RulesResultsInput>,
) -> std::result::Result<models::RulesResults, add::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/sqlVulnerabilityAssessments/default/baselineRules",
operation_config.base_path(),
resource_id
);
let mut url = url::Url::parse(url_str).map_err(add::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(add::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
url.query_pairs_mut().append_pair("workspaceId", workspace_id);
let req_body = if let Some(body) = body {
req_builder = req_builder.header("content-type", "application/json");
azure_core::to_json(body).map_err(add::Error::SerializeError)?
} else {
bytes::Bytes::from_static(azure_core::EMPTY_BODY)
};
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(add::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(add::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RulesResults =
serde_json::from_slice(rsp_body).map_err(|source| add::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| add::Error::DeserializeError(source, rsp_body.clone()))?;
Err(add::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod add {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod secure_scores {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::SecureScoresList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/secureScores",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecureScoresList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
secure_score_name: &str,
) -> std::result::Result<models::SecureScoreItem, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/secureScores/{}",
operation_config.base_path(),
subscription_id,
secure_score_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecureScoreItem =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod secure_score_controls {
use super::{models, API_VERSION};
pub async fn list_by_secure_score(
operation_config: &crate::OperationConfig,
subscription_id: &str,
secure_score_name: &str,
expand: Option<&str>,
) -> std::result::Result<models::SecureScoreControlList, list_by_secure_score::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/secureScores/{}/secureScoreControls",
operation_config.base_path(),
subscription_id,
secure_score_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_secure_score::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_secure_score::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(expand) = expand {
url.query_pairs_mut().append_pair("$expand", expand);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_secure_score::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_secure_score::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecureScoreControlList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_secure_score::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_secure_score::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_secure_score::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_secure_score {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
expand: Option<&str>,
) -> std::result::Result<models::SecureScoreControlList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/secureScoreControls",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(expand) = expand {
url.query_pairs_mut().append_pair("$expand", expand);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecureScoreControlList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod secure_score_control_definitions {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
) -> std::result::Result<models::SecureScoreControlDefinitionList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/providers/Microsoft.Security/secureScoreControlDefinitions",
operation_config.base_path(),
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecureScoreControlDefinitionList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_subscription(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::SecureScoreControlDefinitionList, list_by_subscription::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/secureScoreControlDefinitions",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list_by_subscription::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_subscription::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_subscription::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_subscription::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecureScoreControlDefinitionList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_subscription::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_subscription::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_subscription {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod connectors {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::ConnectorSettingList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/connectors",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectorSettingList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
connector_name: &str,
) -> std::result::Result<models::ConnectorSetting, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/connectors/{}",
operation_config.base_path(),
subscription_id,
connector_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectorSetting =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
connector_name: &str,
connector_setting: &models::ConnectorSetting,
) -> std::result::Result<models::ConnectorSetting, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/connectors/{}",
operation_config.base_path(),
subscription_id,
connector_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(connector_setting).map_err(create_or_update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectorSetting = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
connector_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/connectors/{}",
operation_config.base_path(),
subscription_id,
connector_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod automations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::AutomationList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/automations",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AutomationList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
) -> std::result::Result<models::AutomationList, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/automations",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AutomationList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
automation_name: &str,
) -> std::result::Result<models::Automation, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/automations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
automation_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Automation =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
automation_name: &str,
automation: &models::Automation,
) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/automations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
automation_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(automation).map_err(create_or_update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Automation = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::Automation = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Automation),
Created201(models::Automation),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
automation_name: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/automations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
automation_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn validate(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
automation_name: &str,
automation: &models::Automation,
) -> std::result::Result<models::AutomationValidationStatus, validate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/automations/{}/validate",
operation_config.base_path(),
subscription_id,
resource_group_name,
automation_name
);
let mut url = url::Url::parse(url_str).map_err(validate::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(validate::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(automation).map_err(validate::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(validate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(validate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AutomationValidationStatus =
serde_json::from_slice(rsp_body).map_err(|source| validate::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| validate::Error::DeserializeError(source, rsp_body.clone()))?;
Err(validate::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod validate {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod sub_assessments {
use super::{models, API_VERSION};
pub async fn list_all(
operation_config: &crate::OperationConfig,
scope: &str,
) -> std::result::Result<models::SecuritySubAssessmentList, list_all::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/subAssessments",
operation_config.base_path(),
scope
);
let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_all::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_all::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecuritySubAssessmentList =
serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_all::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_all {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list(
operation_config: &crate::OperationConfig,
scope: &str,
assessment_name: &str,
) -> std::result::Result<models::SecuritySubAssessmentList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/assessments/{}/subAssessments",
operation_config.base_path(),
scope,
assessment_name
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecuritySubAssessmentList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
scope: &str,
assessment_name: &str,
sub_assessment_name: &str,
) -> std::result::Result<models::SecuritySubAssessment, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/assessments/{}/subAssessments/{}",
operation_config.base_path(),
scope,
assessment_name,
sub_assessment_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecuritySubAssessment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod regulatory_compliance_standards {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
filter: Option<&str>,
) -> std::result::Result<models::RegulatoryComplianceStandardList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/regulatoryComplianceStandards",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RegulatoryComplianceStandardList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
regulatory_compliance_standard_name: &str,
) -> std::result::Result<models::RegulatoryComplianceStandard, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/regulatoryComplianceStandards/{}",
operation_config.base_path(),
subscription_id,
regulatory_compliance_standard_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RegulatoryComplianceStandard =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod regulatory_compliance_controls {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
regulatory_compliance_standard_name: &str,
filter: Option<&str>,
) -> std::result::Result<models::RegulatoryComplianceControlList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/regulatoryComplianceStandards/{}/regulatoryComplianceControls",
operation_config.base_path(),
subscription_id,
regulatory_compliance_standard_name
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RegulatoryComplianceControlList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
regulatory_compliance_standard_name: &str,
regulatory_compliance_control_name: &str,
) -> std::result::Result<models::RegulatoryComplianceControl, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/regulatoryComplianceStandards/{}/regulatoryComplianceControls/{}",
operation_config.base_path(),
subscription_id,
regulatory_compliance_standard_name,
regulatory_compliance_control_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RegulatoryComplianceControl =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod regulatory_compliance_assessments {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
regulatory_compliance_standard_name: &str,
regulatory_compliance_control_name: &str,
filter: Option<&str>,
) -> std::result::Result<models::RegulatoryComplianceAssessmentList, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Security/regulatoryComplianceStandards/{}/regulatoryComplianceControls/{}/regulatoryComplianceAssessments" , operation_config . base_path () , subscription_id , regulatory_compliance_standard_name , regulatory_compliance_control_name) ;
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RegulatoryComplianceAssessmentList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
regulatory_compliance_standard_name: &str,
regulatory_compliance_control_name: &str,
regulatory_compliance_assessment_name: &str,
) -> std::result::Result<models::RegulatoryComplianceAssessment, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Security/regulatoryComplianceStandards/{}/regulatoryComplianceControls/{}/regulatoryComplianceAssessments/{}" , operation_config . base_path () , subscription_id , regulatory_compliance_standard_name , regulatory_compliance_control_name , regulatory_compliance_assessment_name) ;
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RegulatoryComplianceAssessment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod pricings {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::PricingList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/pricings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PricingList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
pricing_name: &str,
) -> std::result::Result<models::Pricing, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/pricings/{}",
operation_config.base_path(),
subscription_id,
pricing_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Pricing =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
pricing_name: &str,
pricing: &models::Pricing,
) -> std::result::Result<models::Pricing, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/pricings/{}",
operation_config.base_path(),
subscription_id,
pricing_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(pricing).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Pricing =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod security_contacts {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::SecurityContactList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/securityContacts",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityContactList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
security_contact_name: &str,
) -> std::result::Result<models::SecurityContact, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/securityContacts/{}",
operation_config.base_path(),
subscription_id,
security_contact_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityContact =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
security_contact_name: &str,
security_contact: &models::SecurityContact,
) -> std::result::Result<models::SecurityContact, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/securityContacts/{}",
operation_config.base_path(),
subscription_id,
security_contact_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(security_contact).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityContact =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
security_contact_name: &str,
security_contact: &models::SecurityContact,
) -> std::result::Result<models::SecurityContact, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/securityContacts/{}",
operation_config.base_path(),
subscription_id,
security_contact_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PATCH);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(security_contact).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityContact =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
security_contact_name: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/securityContacts/{}",
operation_config.base_path(),
subscription_id,
security_contact_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod workspace_settings {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::WorkspaceSettingList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/workspaceSettings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WorkspaceSettingList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
workspace_setting_name: &str,
) -> std::result::Result<models::WorkspaceSetting, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/workspaceSettings/{}",
operation_config.base_path(),
subscription_id,
workspace_setting_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WorkspaceSetting =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
workspace_setting_name: &str,
workspace_setting: &models::WorkspaceSetting,
) -> std::result::Result<models::WorkspaceSetting, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/workspaceSettings/{}",
operation_config.base_path(),
subscription_id,
workspace_setting_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(workspace_setting).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WorkspaceSetting =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
workspace_setting_name: &str,
workspace_setting: &models::WorkspaceSetting,
) -> std::result::Result<models::WorkspaceSetting, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/workspaceSettings/{}",
operation_config.base_path(),
subscription_id,
workspace_setting_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PATCH);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(workspace_setting).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WorkspaceSetting =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
workspace_setting_name: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/workspaceSettings/{}",
operation_config.base_path(),
subscription_id,
workspace_setting_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod auto_provisioning_settings {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::AutoProvisioningSettingList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/autoProvisioningSettings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AutoProvisioningSettingList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
setting_name: &str,
) -> std::result::Result<models::AutoProvisioningSetting, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/autoProvisioningSettings/{}",
operation_config.base_path(),
subscription_id,
setting_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AutoProvisioningSetting =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
setting_name: &str,
setting: &models::AutoProvisioningSetting,
) -> std::result::Result<models::AutoProvisioningSetting, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/autoProvisioningSettings/{}",
operation_config.base_path(),
subscription_id,
setting_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(setting).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AutoProvisioningSetting =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod compliances {
use super::{models, API_VERSION};
pub async fn list(operation_config: &crate::OperationConfig, scope: &str) -> std::result::Result<models::ComplianceList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/compliances",
operation_config.base_path(),
scope
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ComplianceList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
scope: &str,
compliance_name: &str,
) -> std::result::Result<models::Compliance, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/compliances/{}",
operation_config.base_path(),
scope,
compliance_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Compliance =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod advanced_threat_protection {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_id: &str,
setting_name: &str,
) -> std::result::Result<models::AdvancedThreatProtectionSetting, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/advancedThreatProtectionSettings/{}",
operation_config.base_path(),
resource_id,
setting_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AdvancedThreatProtectionSetting =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
resource_id: &str,
setting_name: &str,
advanced_threat_protection_setting: &models::AdvancedThreatProtectionSetting,
) -> std::result::Result<models::AdvancedThreatProtectionSetting, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/advancedThreatProtectionSettings/{}",
operation_config.base_path(),
resource_id,
setting_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(advanced_threat_protection_setting).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AdvancedThreatProtectionSetting =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod device_security_groups {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
resource_id: &str,
) -> std::result::Result<models::DeviceSecurityGroupList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/deviceSecurityGroups",
operation_config.base_path(),
resource_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DeviceSecurityGroupList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
resource_id: &str,
device_security_group_name: &str,
) -> std::result::Result<models::DeviceSecurityGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/deviceSecurityGroups/{}",
operation_config.base_path(),
resource_id,
device_security_group_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DeviceSecurityGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
resource_id: &str,
device_security_group_name: &str,
device_security_group: &models::DeviceSecurityGroup,
) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/deviceSecurityGroups/{}",
operation_config.base_path(),
resource_id,
device_security_group_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(device_security_group).map_err(create_or_update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DeviceSecurityGroup = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::DeviceSecurityGroup = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DeviceSecurityGroup),
Created201(models::DeviceSecurityGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
resource_id: &str,
device_security_group_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/deviceSecurityGroups/{}",
operation_config.base_path(),
resource_id,
device_security_group_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod settings {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::SettingsList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/settings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SettingsList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
setting_name: &str,
) -> std::result::Result<models::Setting, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/settings/{}",
operation_config.base_path(),
subscription_id,
setting_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Setting =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
setting_name: &str,
setting: &models::Setting,
) -> std::result::Result<models::Setting, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/settings/{}",
operation_config.base_path(),
subscription_id,
setting_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(setting).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Setting =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod information_protection_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
scope: &str,
information_protection_policy_name: &str,
) -> std::result::Result<models::InformationProtectionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/informationProtectionPolicies/{}",
operation_config.base_path(),
scope,
information_protection_policy_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::InformationProtectionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
scope: &str,
information_protection_policy_name: &str,
information_protection_policy: &models::InformationProtectionPolicy,
) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/informationProtectionPolicies/{}",
operation_config.base_path(),
scope,
information_protection_policy_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(information_protection_policy).map_err(create_or_update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::InformationProtectionPolicy = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::InformationProtectionPolicy = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::InformationProtectionPolicy),
Created201(models::InformationProtectionPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list(
operation_config: &crate::OperationConfig,
scope: &str,
) -> std::result::Result<models::InformationProtectionPolicyList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/{}/providers/Microsoft.Security/informationProtectionPolicies",
operation_config.base_path(),
scope
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::InformationProtectionPolicyList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
filter: Option<&str>,
) -> std::result::Result<models::IoTSecuritySolutionsList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/iotSecuritySolutions",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionsList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions_resource_group {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
filter: Option<&str>,
) -> std::result::Result<models::IoTSecuritySolutionsList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionsList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod iot_security_solution {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
) -> std::result::Result<models::IoTSecuritySolutionModel, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
solution_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionModel =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
iot_security_solution_data: &models::IoTSecuritySolutionModel,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
solution_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(iot_security_solution_data).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionModel =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionModel =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::IoTSecuritySolutionModel),
Created201(models::IoTSecuritySolutionModel),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
update_iot_security_solution_data: &models::UpdateIotSecuritySolutionData,
) -> std::result::Result<models::IoTSecuritySolutionModel, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
solution_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PATCH);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(update_iot_security_solution_data).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionModel =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
solution_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions_analytics {
use super::{models, API_VERSION};
pub async fn get_all(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
) -> std::result::Result<models::IoTSecuritySolutionAnalyticsModelList, get_all::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels",
operation_config.base_path(),
subscription_id,
resource_group_name,
solution_name
);
let mut url = url::Url::parse(url_str).map_err(get_all::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get_all::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get_all::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_all::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionAnalyticsModelList =
serde_json::from_slice(rsp_body).map_err(|source| get_all::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get_all::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get_all::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get_all {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get_default(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
) -> std::result::Result<models::IoTSecuritySolutionAnalyticsModel, get_default::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels/default",
operation_config.base_path(),
subscription_id,
resource_group_name,
solution_name
);
let mut url = url::Url::parse(url_str).map_err(get_default::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get_default::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get_default::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_default::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecuritySolutionAnalyticsModel =
serde_json::from_slice(rsp_body).map_err(|source| get_default::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get_default::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get_default::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get_default {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions_analytics_aggregated_alerts {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
top: Option<i64>,
) -> std::result::Result<models::IoTSecurityAggregatedAlertList, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels/default/aggregatedAlerts" , operation_config . base_path () , subscription_id , resource_group_name , solution_name) ;
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(top) = top {
url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecurityAggregatedAlertList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions_analytics_aggregated_alert {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
aggregated_alert_name: &str,
) -> std::result::Result<models::IoTSecurityAggregatedAlert, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels/default/aggregatedAlerts/{}" , operation_config . base_path () , subscription_id , resource_group_name , solution_name , aggregated_alert_name) ;
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecurityAggregatedAlert =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn dismiss(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
aggregated_alert_name: &str,
) -> std::result::Result<(), dismiss::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels/default/aggregatedAlerts/{}/dismiss" , operation_config . base_path () , subscription_id , resource_group_name , solution_name , aggregated_alert_name) ;
let mut url = url::Url::parse(url_str).map_err(dismiss::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(dismiss::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(dismiss::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(dismiss::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| dismiss::Error::DeserializeError(source, rsp_body.clone()))?;
Err(dismiss::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod dismiss {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions_analytics_recommendation {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
aggregated_recommendation_name: &str,
) -> std::result::Result<models::IoTSecurityAggregatedRecommendation, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels/default/aggregatedRecommendations/{}" , operation_config . base_path () , subscription_id , resource_group_name , solution_name , aggregated_recommendation_name) ;
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecurityAggregatedRecommendation =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod io_t_security_solutions_analytics_recommendations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
solution_name: &str,
top: Option<i64>,
) -> std::result::Result<models::IoTSecurityAggregatedRecommendationList, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/iotSecuritySolutions/{}/analyticsModels/default/aggregatedRecommendations" , operation_config . base_path () , subscription_id , resource_group_name , solution_name) ;
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(top) = top {
url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IoTSecurityAggregatedRecommendationList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod operations {
use super::{models, API_VERSION};
pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<models::OperationList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!("{}/providers/Microsoft.Security/operations", operation_config.base_path(),);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::OperationList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod locations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::AscLocationList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AscLocationList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
) -> std::result::Result<models::AscLocation, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AscLocation =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod tasks {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
filter: Option<&str>,
) -> std::result::Result<models::SecurityTaskList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/tasks",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityTaskList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_home_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
filter: Option<&str>,
) -> std::result::Result<models::SecurityTaskList, list_by_home_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/tasks",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_home_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_home_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_home_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_home_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityTaskList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_home_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_home_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get_subscription_level_task(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
task_name: &str,
) -> std::result::Result<models::SecurityTask, get_subscription_level_task::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/tasks/{}",
operation_config.base_path(),
subscription_id,
asc_location,
task_name
);
let mut url = url::Url::parse(url_str).map_err(get_subscription_level_task::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get_subscription_level_task::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(get_subscription_level_task::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_subscription_level_task::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityTask = serde_json::from_slice(rsp_body)
.map_err(|source| get_subscription_level_task::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| get_subscription_level_task::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get_subscription_level_task::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get_subscription_level_task {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update_subscription_level_task_state(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
task_name: &str,
task_update_action_type: &str,
) -> std::result::Result<(), update_subscription_level_task_state::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/tasks/{}/{}",
operation_config.base_path(),
subscription_id,
asc_location,
task_name,
task_update_action_type
);
let mut url = url::Url::parse(url_str).map_err(update_subscription_level_task_state::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_subscription_level_task_state::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_subscription_level_task_state::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_subscription_level_task_state::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| update_subscription_level_task_state::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update_subscription_level_task_state::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update_subscription_level_task_state {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
filter: Option<&str>,
) -> std::result::Result<models::SecurityTaskList, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/tasks",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityTaskList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get_resource_group_level_task(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
task_name: &str,
) -> std::result::Result<models::SecurityTask, get_resource_group_level_task::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/tasks/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
task_name
);
let mut url = url::Url::parse(url_str).map_err(get_resource_group_level_task::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get_resource_group_level_task::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(get_resource_group_level_task::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_resource_group_level_task::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SecurityTask = serde_json::from_slice(rsp_body)
.map_err(|source| get_resource_group_level_task::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| get_resource_group_level_task::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get_resource_group_level_task::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get_resource_group_level_task {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update_resource_group_level_task_state(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
task_name: &str,
task_update_action_type: &str,
) -> std::result::Result<(), update_resource_group_level_task_state::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/tasks/{}/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
task_name,
task_update_action_type
);
let mut url = url::Url::parse(url_str).map_err(update_resource_group_level_task_state::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_resource_group_level_task_state::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_resource_group_level_task_state::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_resource_group_level_task_state::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| update_resource_group_level_task_state::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update_resource_group_level_task_state::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update_resource_group_level_task_state {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod alerts {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
filter: Option<&str>,
select: Option<&str>,
expand: Option<&str>,
auto_dismiss_rule_name: Option<&str>,
) -> std::result::Result<models::AlertList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/alerts",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
if let Some(select) = select {
url.query_pairs_mut().append_pair("$select", select);
}
if let Some(expand) = expand {
url.query_pairs_mut().append_pair("$expand", expand);
}
if let Some(auto_dismiss_rule_name) = auto_dismiss_rule_name {
url.query_pairs_mut().append_pair("autoDismissRuleName", auto_dismiss_rule_name);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
filter: Option<&str>,
select: Option<&str>,
expand: Option<&str>,
auto_dismiss_rule_name: Option<&str>,
) -> std::result::Result<models::AlertList, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/alerts",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
if let Some(select) = select {
url.query_pairs_mut().append_pair("$select", select);
}
if let Some(expand) = expand {
url.query_pairs_mut().append_pair("$expand", expand);
}
if let Some(auto_dismiss_rule_name) = auto_dismiss_rule_name {
url.query_pairs_mut().append_pair("autoDismissRuleName", auto_dismiss_rule_name);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_subscription_level_alerts_by_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
filter: Option<&str>,
select: Option<&str>,
expand: Option<&str>,
auto_dismiss_rule_name: Option<&str>,
) -> std::result::Result<models::AlertList, list_subscription_level_alerts_by_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/alerts",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_subscription_level_alerts_by_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_subscription_level_alerts_by_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
if let Some(select) = select {
url.query_pairs_mut().append_pair("$select", select);
}
if let Some(expand) = expand {
url.query_pairs_mut().append_pair("$expand", expand);
}
if let Some(auto_dismiss_rule_name) = auto_dismiss_rule_name {
url.query_pairs_mut().append_pair("autoDismissRuleName", auto_dismiss_rule_name);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_subscription_level_alerts_by_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_subscription_level_alerts_by_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertList = serde_json::from_slice(rsp_body)
.map_err(|source| list_subscription_level_alerts_by_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_subscription_level_alerts_by_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_subscription_level_alerts_by_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_subscription_level_alerts_by_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_resource_group_level_alerts_by_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
resource_group_name: &str,
filter: Option<&str>,
select: Option<&str>,
expand: Option<&str>,
auto_dismiss_rule_name: Option<&str>,
) -> std::result::Result<models::AlertList, list_resource_group_level_alerts_by_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/alerts",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_resource_group_level_alerts_by_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_resource_group_level_alerts_by_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(filter) = filter {
url.query_pairs_mut().append_pair("$filter", filter);
}
if let Some(select) = select {
url.query_pairs_mut().append_pair("$select", select);
}
if let Some(expand) = expand {
url.query_pairs_mut().append_pair("$expand", expand);
}
if let Some(auto_dismiss_rule_name) = auto_dismiss_rule_name {
url.query_pairs_mut().append_pair("autoDismissRuleName", auto_dismiss_rule_name);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_resource_group_level_alerts_by_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_resource_group_level_alerts_by_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertList = serde_json::from_slice(rsp_body)
.map_err(|source| list_resource_group_level_alerts_by_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_resource_group_level_alerts_by_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_resource_group_level_alerts_by_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_resource_group_level_alerts_by_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get_subscription_level_alert(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
alert_name: &str,
) -> std::result::Result<models::Alert, get_subscription_level_alert::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/alerts/{}",
operation_config.base_path(),
subscription_id,
asc_location,
alert_name
);
let mut url = url::Url::parse(url_str).map_err(get_subscription_level_alert::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get_subscription_level_alert::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(get_subscription_level_alert::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_subscription_level_alert::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Alert = serde_json::from_slice(rsp_body)
.map_err(|source| get_subscription_level_alert::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| get_subscription_level_alert::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get_subscription_level_alert::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get_subscription_level_alert {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get_resource_group_level_alerts(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
alert_name: &str,
resource_group_name: &str,
) -> std::result::Result<models::Alert, get_resource_group_level_alerts::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/alerts/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
alert_name
);
let mut url = url::Url::parse(url_str).map_err(get_resource_group_level_alerts::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get_resource_group_level_alerts::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(get_resource_group_level_alerts::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_resource_group_level_alerts::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Alert = serde_json::from_slice(rsp_body)
.map_err(|source| get_resource_group_level_alerts::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| get_resource_group_level_alerts::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get_resource_group_level_alerts::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get_resource_group_level_alerts {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update_subscription_level_alert_state_to_dismiss(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
alert_name: &str,
) -> std::result::Result<(), update_subscription_level_alert_state_to_dismiss::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/alerts/{}/dismiss",
operation_config.base_path(),
subscription_id,
asc_location,
alert_name
);
let mut url = url::Url::parse(url_str).map_err(update_subscription_level_alert_state_to_dismiss::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_subscription_level_alert_state_to_dismiss::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_subscription_level_alert_state_to_dismiss::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_subscription_level_alert_state_to_dismiss::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body).map_err(|source| {
update_subscription_level_alert_state_to_dismiss::Error::DeserializeError(source, rsp_body.clone())
})?;
Err(update_subscription_level_alert_state_to_dismiss::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update_subscription_level_alert_state_to_dismiss {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update_subscription_level_alert_state_to_reactivate(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
alert_name: &str,
) -> std::result::Result<(), update_subscription_level_alert_state_to_reactivate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/alerts/{}/reactivate",
operation_config.base_path(),
subscription_id,
asc_location,
alert_name
);
let mut url = url::Url::parse(url_str).map_err(update_subscription_level_alert_state_to_reactivate::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_subscription_level_alert_state_to_reactivate::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_subscription_level_alert_state_to_reactivate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_subscription_level_alert_state_to_reactivate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body).map_err(|source| {
update_subscription_level_alert_state_to_reactivate::Error::DeserializeError(source, rsp_body.clone())
})?;
Err(update_subscription_level_alert_state_to_reactivate::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update_subscription_level_alert_state_to_reactivate {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update_resource_group_level_alert_state_to_dismiss(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
alert_name: &str,
resource_group_name: &str,
) -> std::result::Result<(), update_resource_group_level_alert_state_to_dismiss::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/alerts/{}/dismiss",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
alert_name
);
let mut url = url::Url::parse(url_str).map_err(update_resource_group_level_alert_state_to_dismiss::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_resource_group_level_alert_state_to_dismiss::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_resource_group_level_alert_state_to_dismiss::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_resource_group_level_alert_state_to_dismiss::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body).map_err(|source| {
update_resource_group_level_alert_state_to_dismiss::Error::DeserializeError(source, rsp_body.clone())
})?;
Err(update_resource_group_level_alert_state_to_dismiss::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update_resource_group_level_alert_state_to_dismiss {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update_resource_group_level_alert_state_to_reactivate(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
alert_name: &str,
resource_group_name: &str,
) -> std::result::Result<(), update_resource_group_level_alert_state_to_reactivate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/alerts/{}/reactivate",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
alert_name
);
let mut url = url::Url::parse(url_str).map_err(update_resource_group_level_alert_state_to_reactivate::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_resource_group_level_alert_state_to_reactivate::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_resource_group_level_alert_state_to_reactivate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_resource_group_level_alert_state_to_reactivate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body).map_err(|source| {
update_resource_group_level_alert_state_to_reactivate::Error::DeserializeError(source, rsp_body.clone())
})?;
Err(update_resource_group_level_alert_state_to_reactivate::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update_resource_group_level_alert_state_to_reactivate {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod discovered_security_solutions {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::DiscoveredSecuritySolutionList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/discoveredSecuritySolutions",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DiscoveredSecuritySolutionList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_home_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
) -> std::result::Result<models::DiscoveredSecuritySolutionList, list_by_home_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/discoveredSecuritySolutions",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_home_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_home_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_home_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_home_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DiscoveredSecuritySolutionList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_home_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_home_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
discovered_security_solution_name: &str,
) -> std::result::Result<models::DiscoveredSecuritySolution, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/discoveredSecuritySolutions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
discovered_security_solution_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DiscoveredSecuritySolution =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod jit_network_access_policies {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::JitNetworkAccessPoliciesList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/jitNetworkAccessPolicies",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessPoliciesList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
) -> std::result::Result<models::JitNetworkAccessPoliciesList, list_by_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/jitNetworkAccessPolicies",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessPoliciesList =
serde_json::from_slice(rsp_body).map_err(|source| list_by_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list_by_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
) -> std::result::Result<models::JitNetworkAccessPoliciesList, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/jitNetworkAccessPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessPoliciesList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_resource_group_and_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
) -> std::result::Result<models::JitNetworkAccessPoliciesList, list_by_resource_group_and_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/jitNetworkAccessPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_and_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group_and_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_resource_group_and_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_and_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessPoliciesList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_and_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_and_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_resource_group_and_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_resource_group_and_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
jit_network_access_policy_name: &str,
) -> std::result::Result<models::JitNetworkAccessPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/jitNetworkAccessPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
jit_network_access_policy_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
jit_network_access_policy_name: &str,
body: &models::JitNetworkAccessPolicy,
) -> std::result::Result<models::JitNetworkAccessPolicy, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/jitNetworkAccessPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
jit_network_access_policy_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create_or_update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessPolicy = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create_or_update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
jit_network_access_policy_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/jitNetworkAccessPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
jit_network_access_policy_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn initiate(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
jit_network_access_policy_name: &str,
jit_network_access_policy_initiate_type: &str,
body: &models::JitNetworkAccessPolicyInitiateRequest,
) -> std::result::Result<models::JitNetworkAccessRequest, initiate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/jitNetworkAccessPolicies/{}/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
jit_network_access_policy_name,
jit_network_access_policy_initiate_type
);
let mut url = url::Url::parse(url_str).map_err(initiate::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(initiate::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(body).map_err(initiate::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(initiate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(initiate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::JitNetworkAccessRequest =
serde_json::from_slice(rsp_body).map_err(|source| initiate::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| initiate::Error::DeserializeError(source, rsp_body.clone()))?;
Err(initiate::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod initiate {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod adaptive_application_controls {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
include_path_recommendations: Option<bool>,
summary: Option<bool>,
) -> std::result::Result<models::AppWhitelistingGroups, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/applicationWhitelistings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(include_path_recommendations) = include_path_recommendations {
url.query_pairs_mut()
.append_pair("includePathRecommendations", include_path_recommendations.to_string().as_str());
}
if let Some(summary) = summary {
url.query_pairs_mut().append_pair("summary", summary.to_string().as_str());
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AppWhitelistingGroups =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
group_name: &str,
) -> std::result::Result<models::AppWhitelistingGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/applicationWhitelistings/{}",
operation_config.base_path(),
subscription_id,
asc_location,
group_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AppWhitelistingGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn put(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
group_name: &str,
body: &models::AppWhitelistingPutGroupData,
) -> std::result::Result<models::AppWhitelistingGroup, put::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/applicationWhitelistings/{}",
operation_config.base_path(),
subscription_id,
asc_location,
group_name
);
let mut url = url::Url::parse(url_str).map_err(put::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(put::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(body).map_err(put::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(put::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(put::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AppWhitelistingGroup =
serde_json::from_slice(rsp_body).map_err(|source| put::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| put::Error::DeserializeError(source, rsp_body.clone()))?;
Err(put::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod put {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
group_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/applicationWhitelistings/{}",
operation_config.base_path(),
subscription_id,
asc_location,
group_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(delete::Response::Accepted202),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
Accepted202,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod external_security_solutions {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::ExternalSecuritySolutionList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/externalSecuritySolutions",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ExternalSecuritySolutionList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_home_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
) -> std::result::Result<models::ExternalSecuritySolutionList, list_by_home_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/ExternalSecuritySolutions",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_home_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_home_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_home_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_home_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ExternalSecuritySolutionList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_home_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_home_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
external_security_solutions_name: &str,
) -> std::result::Result<models::ExternalSecuritySolution, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/ExternalSecuritySolutions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
external_security_solutions_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ExternalSecuritySolution =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod topology {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::TopologyList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/topologies",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TopologyList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_home_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
) -> std::result::Result<models::TopologyList, list_by_home_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/topologies",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_home_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_home_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_home_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_home_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TopologyList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_home_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_home_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
topology_resource_name: &str,
) -> std::result::Result<models::TopologyResource, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/topologies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
topology_resource_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TopologyResource =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod allowed_connections {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::AllowedConnectionsList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/allowedConnections",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AllowedConnectionsList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_by_home_region(
operation_config: &crate::OperationConfig,
subscription_id: &str,
asc_location: &str,
) -> std::result::Result<models::AllowedConnectionsList, list_by_home_region::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/locations/{}/allowedConnections",
operation_config.base_path(),
subscription_id,
asc_location
);
let mut url = url::Url::parse(url_str).map_err(list_by_home_region::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_home_region::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_by_home_region::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_home_region::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AllowedConnectionsList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_home_region::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_home_region::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_home_region {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
asc_location: &str,
connection_type: &str,
) -> std::result::Result<models::AllowedConnectionsResource, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Security/locations/{}/allowedConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
asc_location,
connection_type
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AllowedConnectionsResource =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod adaptive_network_hardenings {
use super::{models, API_VERSION};
pub async fn list_by_extended_resource(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
resource_namespace: &str,
resource_type: &str,
resource_name: &str,
) -> std::result::Result<models::AdaptiveNetworkHardeningsList, list_by_extended_resource::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/{}/{}/{}/providers/Microsoft.Security/adaptiveNetworkHardenings",
operation_config.base_path(),
subscription_id,
resource_group_name,
resource_namespace,
resource_type,
resource_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_extended_resource::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_extended_resource::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_extended_resource::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_extended_resource::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AdaptiveNetworkHardeningsList = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_extended_resource::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_extended_resource::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_extended_resource::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_extended_resource {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
resource_namespace: &str,
resource_type: &str,
resource_name: &str,
adaptive_network_hardening_resource_name: &str,
) -> std::result::Result<models::AdaptiveNetworkHardening, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/{}/{}/{}/providers/Microsoft.Security/adaptiveNetworkHardenings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
resource_namespace,
resource_type,
resource_name,
adaptive_network_hardening_resource_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AdaptiveNetworkHardening =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn enforce(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
resource_namespace: &str,
resource_type: &str,
resource_name: &str,
adaptive_network_hardening_resource_name: &str,
adaptive_network_hardening_enforce_action: &str,
body: &models::AdaptiveNetworkHardeningEnforceRequest,
) -> std::result::Result<enforce::Response, enforce::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/{}/{}/{}/providers/Microsoft.Security/adaptiveNetworkHardenings/{}/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
resource_namespace,
resource_type,
resource_name,
adaptive_network_hardening_resource_name,
adaptive_network_hardening_enforce_action
);
let mut url = url::Url::parse(url_str).map_err(enforce::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(enforce::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(body).map_err(enforce::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(enforce::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(enforce::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(enforce::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(enforce::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| enforce::Error::DeserializeError(source, rsp_body.clone()))?;
Err(enforce::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod enforce {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod alerts_suppression_rules {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
alert_type: Option<&str>,
) -> std::result::Result<models::AlertsSuppressionRulesList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/alertsSuppressionRules",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(alert_type) = alert_type {
url.query_pairs_mut().append_pair("AlertType", alert_type);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertsSuppressionRulesList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
alerts_suppression_rule_name: &str,
) -> std::result::Result<models::AlertsSuppressionRule, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/alertsSuppressionRules/{}",
operation_config.base_path(),
subscription_id,
alerts_suppression_rule_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertsSuppressionRule =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
alerts_suppression_rule_name: &str,
alerts_suppression_rule: &models::AlertsSuppressionRule,
) -> std::result::Result<models::AlertsSuppressionRule, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/alertsSuppressionRules/{}",
operation_config.base_path(),
subscription_id,
alerts_suppression_rule_name
);
let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(alerts_suppression_rule).map_err(update::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AlertsSuppressionRule =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Err(update::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
alerts_suppression_rule_name: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/alertsSuppressionRules/{}",
operation_config.base_path(),
subscription_id,
alerts_suppression_rule_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
pub mod ingestion_settings {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::IngestionSettingList, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/ingestionSettings",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IngestionSettingList =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
ingestion_setting_name: &str,
) -> std::result::Result<models::IngestionSetting, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/ingestionSettings/{}",
operation_config.base_path(),
subscription_id,
ingestion_setting_name
);
let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(get::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IngestionSetting =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Err(get::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn create(
operation_config: &crate::OperationConfig,
subscription_id: &str,
ingestion_setting_name: &str,
ingestion_setting: &models::IngestionSetting,
) -> std::result::Result<models::IngestionSetting, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/ingestionSettings/{}",
operation_config.base_path(),
subscription_id,
ingestion_setting_name
);
let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(create::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(ingestion_setting).map_err(create::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IngestionSetting =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Err(create::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn delete(
operation_config: &crate::OperationConfig,
subscription_id: &str,
ingestion_setting_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/ingestionSettings/{}",
operation_config.base_path(),
subscription_id,
ingestion_setting_name
);
let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::DELETE);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(delete::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
Err(delete::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_tokens(
operation_config: &crate::OperationConfig,
subscription_id: &str,
ingestion_setting_name: &str,
) -> std::result::Result<models::IngestionSettingToken, list_tokens::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/ingestionSettings/{}/listTokens",
operation_config.base_path(),
subscription_id,
ingestion_setting_name
);
let mut url = url::Url::parse(url_str).map_err(list_tokens::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_tokens::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_tokens::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_tokens::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IngestionSettingToken =
serde_json::from_slice(rsp_body).map_err(|source| list_tokens::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError =
serde_json::from_slice(rsp_body).map_err(|source| list_tokens::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_tokens::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_tokens {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
pub async fn list_connection_strings(
operation_config: &crate::OperationConfig,
subscription_id: &str,
ingestion_setting_name: &str,
) -> std::result::Result<models::ConnectionStrings, list_connection_strings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Security/ingestionSettings/{}/listConnectionStrings",
operation_config.base_path(),
subscription_id,
ingestion_setting_name
);
let mut url = url::Url::parse(url_str).map_err(list_connection_strings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_connection_strings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_connection_strings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_connection_strings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectionStrings = serde_json::from_slice(rsp_body)
.map_err(|source| list_connection_strings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
let rsp_value: models::CloudError = serde_json::from_slice(rsp_body)
.map_err(|source| list_connection_strings::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_connection_strings::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_connection_strings {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse {
status_code: http::StatusCode,
value: models::CloudError,
},
#[error("Failed to parse request URL: {0}")]
ParseUrlError(url::ParseError),
#[error("Failed to build request: {0}")]
BuildRequestError(http::Error),
#[error("Failed to execute request: {0}")]
ExecuteRequestError(azure_core::HttpError),
#[error("Failed to serialize request body: {0}")]
SerializeError(serde_json::Error),
#[error("Failed to deserialize response: {0}, body: {1:?}")]
DeserializeError(serde_json::Error, bytes::Bytes),
#[error("Failed to get access token: {0}")]
GetTokenError(azure_core::Error),
}
}
}
|
#[allow(unused_imports)]
use super::util::prelude::*;
use super::super::ImageData;
use super::util::{Pack, PackDepth};
use super::BlockMut;
use super::BlockRef;
use super::CanvasTexture;
block! {
[pub Drawing(constructor, pack)]
(local_drawing_texture): BlockMut<CanvasTexture>;
(drawed_texture): BlockMut<CanvasTexture>;
}
impl Drawing {
pub fn local_drawing_texture(&self) -> BlockRef<CanvasTexture> {
self.local_drawing_texture.as_ref()
}
pub fn local_drawing_texture_mut(&self) -> BlockMut<CanvasTexture> {
self.local_drawing_texture.clone()
}
pub fn drawed_texture(&self) -> BlockRef<CanvasTexture> {
self.drawed_texture.as_ref()
}
pub fn drawed_texture_mut(&self) -> BlockMut<CanvasTexture> {
self.drawed_texture.clone()
}
}
block! {
[pub Fill(constructor, pack)]
color: crate::libs::color::Pallet = crate::libs::color::Pallet::gray(0);
}
block! {
[pub Image(constructor, pack)]
data: BlockRef<ImageData> = BlockRef::<ImageData>::none();
}
impl Image {
pub fn data(&self) -> BlockRef<ImageData> {
self.data.as_ref()
}
pub fn set_data(&mut self, data: BlockRef<ImageData>) {
self.data = data;
}
}
pub enum Layer {
Drawing(Drawing),
Fill(Fill),
Image(Image),
LayerGroup(BlockMut<LayerGroup>),
}
#[async_trait(?Send)]
impl Pack for Layer {
async fn pack(&self, pack_depth: PackDepth) -> JsValue {
match self {
Self::Drawing(data) => (object! {
"type": "Drawing",
"data": data.pack(pack_depth).await
})
.into(),
Self::Fill(data) => (object! {
"type": "Fill",
"data": data.pack(pack_depth).await
})
.into(),
Self::Image(data) => (object! {
"type": "Image",
"data": data.pack(pack_depth).await
})
.into(),
Self::LayerGroup(data) => (object! {
"type": "LayerGroup",
"data": data.pack(pack_depth).await
})
.into(),
}
}
async fn unpack(data: &JsValue, arena: ArenaMut) -> Option<Box<Self>> {
let data = data.dyn_ref::<crate::libs::js_object::Object>()?;
let data_type = data.get("type")?.as_string()?;
let data = data.get("data")?;
match data_type.as_str() {
"Drawing" => Drawing::unpack(&data, ArenaMut::clone(&arena))
.await
.map(|data| Box::new(Self::Drawing(*data))),
"Fill" => Fill::unpack(&data, ArenaMut::clone(&arena))
.await
.map(|data| Box::new(Self::Fill(*data))),
"Image" => Image::unpack(&data, ArenaMut::clone(&arena))
.await
.map(|data| Box::new(Self::Image(*data))),
"LayerGroup" => BlockMut::<LayerGroup>::unpack(&data, ArenaMut::clone(&arena))
.await
.map(|data| Box::new(Self::LayerGroup(*data))),
_ => None,
}
}
}
block! {
[pub LayerGroup(constructor, pack)]
layers: Vec<Layer> = vec![];
local_selecting_layer_idx: usize = 0;
}
impl LayerGroup {}
|
use std::cell::RefCell;
use std::path::PathBuf;
use std::rc::Rc;
use anyhow::{Context, Result};
pub use error::CfgError;
pub use file::global_cfg_directory;
pub use file::load_local_cfg;
pub use file::FileCfg;
pub use global::GlobalCfg;
pub use local::LocalCfg;
pub use local::LocalSetupCfg;
pub use local::{ArrayVar, ArrayVars, VarCase, VarName, Vars};
pub use setup::Setup;
pub use setup::SetupCfg;
pub use setup::SetupsCfg;
use crate::cfg::file::{load_or_new_global_cfg, new_local_cfg};
use crate::cfg::global::GlobalProjectCfg;
mod error;
mod file;
mod global;
mod local;
mod setup;
#[derive(Debug)]
pub struct Cfg {
local_cfg: FileCfg<LocalCfg>,
global_cfg: FileCfg<GlobalCfg>,
}
impl Cfg {
pub fn load_local(global_dir: PathBuf, local_dir: PathBuf) -> Result<Self> {
let local_cfg = load_local_cfg(&local_dir).context("fail to load local cfg file")?;
Cfg::new(global_dir, local_cfg)
}
pub fn create_local(global_dir: PathBuf, local_dir: PathBuf) -> Result<Self> {
let local_cfg = new_local_cfg(&local_dir).context("fail to create local cfg file")?;
Cfg::new(global_dir, local_cfg)
}
pub fn new(global_dir: PathBuf, local_cfg: FileCfg<LocalCfg>) -> Result<Self> {
let global_cfg =
load_or_new_global_cfg(&global_dir).context("fail to load global cfg file")?;
Ok(Self {
local_cfg,
global_cfg,
})
}
pub fn save(&self) -> Result<()> {
self.local_cfg.save()?;
self.global_cfg.save()?;
Ok(())
}
pub fn add_local_setup_cfg(&mut self, setup: LocalSetupCfg) {
let local_cfg = self.local_cfg.borrow_mut();
local_cfg.add_setup(setup);
}
pub fn sync_local_to_global(&mut self) -> Result<()> {
let global_cfg = self.global_cfg.borrow_mut();
global_cfg
.sync_local_project(&self.local_cfg)
.context("fail to sync local project cfg to global")?;
Ok(())
}
/**
* Local cfg and Global cfg must be synchronised before.
**/
pub fn current_project(&self) -> Result<Rc<RefCell<GlobalProjectCfg>>> {
let local_cfg_file = self.local_cfg.file()?;
let global_cfg = self.global_cfg.borrow();
global_cfg
.get_project_by_file(local_cfg_file)
.context(format!("fail to get project {:?}", local_cfg_file))
}
/**
* Local cfg and Global cfg must be synchronised before.
**/
pub fn current_setups(&self) -> Result<Vec<Setup>> {
let global_project = self.current_project()?;
let local_setups = self.local_cfg.borrow().get_setups();
let local_cfg_path = self.local_cfg.file()?;
let setups: Vec<_> = local_setups
.borrow()
.iter()
.filter_map(|local_setup| {
if let Some(global_setup) = global_project
.borrow()
.get_setup(local_setup.borrow().name())
{
if let Ok(setup) = Setup::new_fill(local_cfg_path, &local_setup, &global_setup)
{
return Some(setup);
}
}
None
})
.collect();
Ok(setups)
}
pub fn current_setup(&self, name: &String) -> Result<Setup> {
for setup in self.current_setups()? {
if setup.name()? == *name {
return Ok(setup);
}
}
bail!(CfgError::SetupNotFound(name.to_owned()))
}
}
#[cfg(test)]
mod main_test {
use std::path::PathBuf;
use cli_integration_test::IntegrationTestEnvironment;
use predicates::path::{exists, is_file};
use predicates::prelude::*;
use predicates::str::contains;
use crate::cfg::Cfg;
pub const HOME: &'static str = "home";
pub const PROJECT: &'static str = "project";
pub fn init_env() -> IntegrationTestEnvironment {
let mut e = IntegrationTestEnvironment::new("cfg");
e.add_dir(HOME);
e.add_dir(PROJECT);
e.setup();
e
}
#[test]
fn create_cfg() {
let e = init_env();
let local_cfg = e.path().unwrap().join(PROJECT).join("short.yaml");
let global_cfg = e.path().unwrap().join(HOME).join(".short/cfg.yaml");
let cfg = Cfg::create_local(
e.path().unwrap().join(HOME),
e.path().unwrap().join(PROJECT),
)
.unwrap();
assert!(!exists().eval(&local_cfg));
assert!(!exists().eval(&global_cfg));
cfg.save().unwrap();
assert!(exists().eval(&local_cfg));
assert!(exists().eval(&global_cfg));
}
#[test]
fn create_sync_global_cfg() {
let mut e = init_env();
let local_cfg = PathBuf::from(PROJECT).join("short.yaml");
let global_cfg = PathBuf::from(HOME).join(".short/cfg.yaml");
let abs_local_cfg = e.path().unwrap().join(&local_cfg);
let abs_global_cfg = e.path().unwrap().join(&global_cfg);
e.add_file(
&local_cfg,
r#"
setups:
setup_1:
file: ./run.sh
"#,
);
e.setup();
let mut cfg = Cfg::load_local(
e.path().unwrap().join(HOME),
e.path().unwrap().join(PROJECT),
)
.unwrap();
cfg.sync_local_to_global().unwrap();
let setups = cfg.current_setups();
// Check content of setups
let dbg_setups = format!("{:#?}", setups);
assert!(contains("setup_1").count(2).eval(dbg_setups.as_str()));
// Check if global file do not exist before save
assert!(!is_file().eval(&abs_global_cfg));
cfg.save().unwrap();
// Check if global file do not exist after save
assert!(is_file().eval(&abs_global_cfg));
// Check the content of global file
let global_cfg_str = e.read_file(&global_cfg);
assert!(
contains(format!("{}", &abs_local_cfg.to_string_lossy())).eval(global_cfg_str.as_str())
);
assert!(contains("setup_1").eval(global_cfg_str.as_str()));
}
#[test]
fn load_and_mutate_cfg() {
let mut e = init_env();
let local_cfg = PathBuf::from(PROJECT).join("short.yaml");
let global_cfg = PathBuf::from(HOME).join(".short/cfg.yaml");
let abs_local_cfg = e.path().unwrap().join(&local_cfg);
let _abs_global_cfg = e.path().unwrap().join(&global_cfg);
e.add_file(
&local_cfg,
r#"
setups:
setup_1:
file: ./run.sh
setup_2:
file: ./run.sh
"#,
);
e.add_file(
&global_cfg,
format!(
r#"
projects:
- file: '{}'
setups:
setup_1:
private_env_dir: /private/env/dir
"#,
abs_local_cfg.to_string_lossy()
),
);
e.setup();
let cfg = Cfg::load_local(
e.path().unwrap().join(HOME),
e.path().unwrap().join(PROJECT),
)
.unwrap();
let setup_1 = cfg.current_setup(&"setup_1".into()).unwrap();
setup_1
.global_setup()
.unwrap()
.borrow_mut()
.set_private_env_dir("/private/env/dir2".into())
.unwrap();
cfg.save().unwrap();
// Check the content of global file
let global_cfg_str = e.read_file(&global_cfg);
assert!(contains("/private/env/dir2")
.count(1)
.eval(global_cfg_str.as_str()));
// Rename setup_1 to setup_3
setup_1.rename(&"setup_3".into()).unwrap();
cfg.save().unwrap();
let global_cfg_str = e.read_file(&global_cfg);
assert!(contains("setup_1").count(0).eval(global_cfg_str.as_str()));
assert!(contains("setup_3").count(1).eval(global_cfg_str.as_str()));
let local_cfg_str = e.read_file(&local_cfg);
assert!(contains("setup_1").count(0).eval(local_cfg_str.as_str()));
assert!(contains("setup_3").count(1).eval(local_cfg_str.as_str()));
}
#[test]
fn load_envs_public_and_private() {
const ENVDIR: &'static str = "private_env";
let mut e = init_env();
let local_cfg = PathBuf::from(PROJECT).join("short.yaml");
let global_cfg = PathBuf::from(HOME).join(".short/cfg.yaml");
let env_example = PathBuf::from(PROJECT).join(".example");
let env_dev = PathBuf::from(ENVDIR).join(".dev");
let env_prod = PathBuf::from(ENVDIR).join(".prod");
let abs_local_cfg = e.path().unwrap().join(&local_cfg);
let _abs_global_cfg = e.path().unwrap().join(&global_cfg);
let abs_env_example = e.path().unwrap().join(env_example);
let abs_env_dev = e.path().unwrap().join(env_dev);
let abs_env_prod = e.path().unwrap().join(env_prod);
e.add_file(
&local_cfg,
r#"
setups:
setup_1:
file: ./run.sh
array_vars: {}
"#,
);
e.add_file(
&abs_env_example,
r#"
ENV= example
VAR2= value2
VAR3= "example"
"#,
);
e.add_file(
&global_cfg,
format!(
r#"
projects:
- file: '{}'
setups:
setup_1:
private_env_dir: {}
"#,
abs_local_cfg.to_string_lossy(),
e.path().unwrap().join(ENVDIR).to_string_lossy(),
),
);
e.add_file(
&abs_env_prod,
r#"
ENV=prod
"#,
);
e.add_file(
&abs_env_dev,
r#"
ENV=dev
"#,
);
e.setup();
let cfg = Cfg::load_local(
e.path().unwrap().join(HOME),
e.path().unwrap().join(PROJECT),
)
.unwrap();
let setup_1 = cfg.current_setup(&"setup_1".into()).unwrap();
let env_public = setup_1.envs_public();
assert!(env_public.iter().count().eq(&1));
let env_private = setup_1.envs_private();
assert!(env_private.iter().count().eq(&2));
}
}
|
//! define the error enum for the result of regressions
use ndarray_linalg::error::LinalgError;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum RegressionError {
#[error("Inconsistent input: {0}")]
BadInput(String),
#[error("Invalid response data: {0}")]
InvalidY(String),
#[error("Linear algebra")]
LinalgError {
#[from]
source: LinalgError,
},
#[error("Underconstrained data")]
Underconstrained,
#[error("Colinear data (X^T * X is not invertible)")]
ColinearData,
#[error("Maximum iterations ({0}) reached")]
MaxIter(usize),
}
pub type RegressionResult<T> = Result<T, RegressionError>;
|
extern crate proc_macro;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use std::iter::FromIterator;
#[proc_macro_attribute]
pub fn type_code(args: TokenStream, input: TokenStream) -> TokenStream {
let args = syn::parse_macro_input!(args as syn::AttributeArgs);
let input = syn::parse_macro_input!(input as syn::ItemEnum);
if args.len() != 1 {
panic!("The type_code attribute expects a single integer literal argument");
}
let bits = &args[0];
let name = &input.ident;
let mut variants = Vec::new();
let mut decodes = Vec::new();
let mut encodes = Vec::new();
let mut enumerator = 0;
for variant in input.variants.iter() {
let camel = &variant.ident;
let camel_name = camel.to_string();
if let Some((_, syn::Expr::Lit(value))) = &variant.discriminant {
if let syn::Lit::Int(value) = &value.lit {
enumerator = value.base10_parse::<u32>().unwrap();
}
}
let snake = syn::Ident::new(&to_snake(&camel_name), camel.span());
variants.push(quote!(
#camel(#camel<'a>),
));
decodes.push(quote!(
#enumerator => Self::#camel(table.file.#snake(table.reader).row(code.1)),
));
encodes.push(quote!(
Self::#camel(value) => ((value.row.index + 1) << #bits) | #enumerator,
));
enumerator += 1;
}
let variants = TokenStream2::from_iter(variants);
let decodes = TokenStream2::from_iter(decodes);
let encodes = TokenStream2::from_iter(encodes);
let output = quote!(
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum #name<'a> {
#variants
}
impl<'a> #name<'a> {
pub(crate) fn decode(table: &'a Table, code: u32) -> ParseResult<Self> {
let code = (code & ((1 << #bits) - 1), (code >> #bits) - 1);
Ok(match code.0 {
#decodes
_ => return Err(ParseError::InvalidFile),
})
}
pub fn encode(&self) -> u32 {
match &self {
#encodes
}
}
}
);
output.into()
}
fn to_snake(camel: &str) -> String {
let mut result = String::new();
for c in camel.chars() {
if c.is_uppercase() {
if !result.is_empty() {
result.push('_');
}
for c in c.to_lowercase() {
result.push(c);
}
} else {
result.push(c);
}
}
result
}
|
use anyhow::*;
use ncollide3d::pipeline::CollisionObjectSlabHandle;
use std::{collections::HashMap, path::Path};
use crate::{
render::{
binding, model, state, texture,
traits::{Binding, DrawModel},
Layouts,
},
transform,
};
use legion::IntoQuery;
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct ModelIdent(pub String);
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct MaterialIdent(pub String);
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct CollisionGroup(usize);
pub struct Collider(Option<CollisionObjectSlabHandle>);
pub struct World {
pub models: HashMap<ModelIdent, model::Model>,
materials: HashMap<MaterialIdent, model::Material>,
world: legion::World,
collision_world: ncollide3d::world::CollisionWorld<f32, legion::Entity>,
}
impl World {
pub fn new() -> Self {
Self {
models: HashMap::new(),
materials: HashMap::new(),
world: legion::World::new(legion::WorldOptions::default()),
collision_world: ncollide3d::world::CollisionWorld::new(0.01),
}
}
pub fn load_model<P: AsRef<Path>, M: Into<String>>(
&mut self,
state: &state::WgpuState,
layouts: &Layouts,
name: M,
path: P,
) -> Result<()> {
self.models.insert(
ModelIdent(name.into()),
model::Model::load(state, &layouts.material, path)?,
);
Ok(())
}
#[allow(unused)]
pub fn load_material_raw(
&mut self,
state: &state::WgpuState,
name: &str,
diffuse_texture: texture::Texture,
normal_texture: texture::Texture,
material_layout: &wgpu::BindGroupLayout,
) {
self.materials.insert(
MaterialIdent(name.into()),
model::Material::new(
&state,
name,
diffuse_texture,
normal_texture,
material_layout,
),
);
}
pub fn push_entity<T>(&mut self, components: T) -> Result<legion::Entity>
where
Option<T>: legion::storage::IntoComponentSource,
{
let entity = self.world.push(components);
self.world
.entry(entity)
.unwrap()
.add_component(Collider(None));
if let Some(mut entry) = self.world.entry(entity) {
let isometry = entry.get_component::<transform::Transform>()?.isometry();
let scale = entry.get_component::<transform::Transform>()?.scale();
let collision_groups = entry
.get_component::<ncollide3d::pipeline::object::CollisionGroups>()
.ok()
.cloned();
let model_ident = entry.get_component::<ModelIdent>()?;
let model = self.models.get(model_ident).context("Cannot find model")?;
let collider_group = entry.get_component_mut::<Collider>()?;
collider_group.0.replace(
self.collision_world
.add(
isometry,
ncollide3d::shape::ShapeHandle::new(model.geometry.scaled(scale)),
collision_groups
.unwrap_or(ncollide3d::pipeline::object::CollisionGroups::new())
.clone(),
ncollide3d::pipeline::object::GeometricQueryType::Contacts(0.0, 0.0),
entity,
)
.0,
);
}
Ok(entity)
}
pub fn update_entity_world_transform(&mut self, entity: legion::Entity) -> Result<()> {
if let Some(entry) = self.world.entry(entity) {
let transform = entry.get_component::<transform::Transform>()?;
let model_ident = entry.get_component::<ModelIdent>()?;
let model = self.models.get(model_ident).context("Cannot find model")?;
let collider = entry
.get_component::<Collider>()?
.0
.context("Cannot find collider")?;
let collision_object = self
.collision_world
.get_mut(collider)
.context("No collision object in world")?;
collision_object.set_position(transform.isometry());
collision_object.set_shape(ncollide3d::shape::ShapeHandle::new(
model.geometry.scaled(transform.scale()),
));
}
Ok(())
}
pub fn entry(&mut self, entity: legion::Entity) -> Option<legion::world::Entry> {
self.world.entry(entity)
}
pub fn update_collision_world(&mut self) {
self.collision_world.update();
}
pub fn raycast(
&self,
ray: &ncollide3d::query::Ray<f32>,
max_toi: f32,
) -> Option<legion::Entity> {
Some(
self.collision_world
.first_interference_with_ray(
ray,
max_toi,
&ncollide3d::pipeline::CollisionGroups::new(),
)?
.co
.data()
.clone(),
)
}
fn ensure_models_and_materials(&self) -> Result<()> {
let mut models = <&ModelIdent>::query();
let mut materials = <&MaterialIdent>::query();
let models_not_found = models
.iter(&self.world)
.map(|model| (model.clone(), self.models.contains_key(model)))
.filter(|(_, exists)| !exists)
.collect::<Vec<_>>();
let materials_not_found = materials
.iter(&self.world)
.map(|material| (material.clone(), self.materials.contains_key(material)))
.filter(|(_, exists)| !exists)
.collect::<Vec<_>>();
match (models_not_found.len() > 0, materials_not_found.len() > 0) {
(true, false) => Err(anyhow!(
"Could not find models: {:?}",
models_not_found
.iter()
.map(|(model, _)| &model.0)
.collect::<Vec<_>>(),
)),
(false, true) => Err(anyhow!(format!(
"Could not find materials: {:?}",
materials_not_found
.iter()
.map(|(material, _)| &material.0)
.collect::<Vec<_>>()
))),
(true, true) => Err(anyhow!(format!(
"Could not find models: {:?}\nCould not find materials: {:?}",
models_not_found
.iter()
.map(|(model, _)| &model.0)
.collect::<Vec<_>>(),
materials_not_found
.iter()
.map(|(material, _)| &material.0)
.collect::<Vec<_>>()
))),
(false, false) => Ok(()),
}
}
pub fn render<'a>(
&'a mut self,
state: &state::WgpuState,
render_pass: &mut wgpu::RenderPass<'a>,
uniforms: &'a binding::BufferGroup,
light: &'a binding::BufferGroup,
) -> Result<()> {
if let Err(e) = self.ensure_models_and_materials() {
return Err(e);
}
let mut models = <(
&mut transform::Transform,
&ModelIdent,
Option<&MaterialIdent>,
)>::query();
for (transform, model, material) in models.iter_mut(&mut self.world) {
render_pass.bind_buffer(1, transform.buffer(state));
match material {
Some(material) => {
render_pass.draw_model_with_material(
&self.models.get(model).expect("Model not found"),
&self.materials.get(material).expect("Material not found"),
&uniforms,
&light,
);
}
None => {
render_pass.draw_model(
&self.models.get(model).expect("Model not found"),
&uniforms,
&light,
);
}
}
}
Ok(())
}
}
|
pub mod amazon_aws;
pub mod http_bin;
pub mod if_config;
pub mod prelude;
use std::net::IpAddr;
use anyhow::Result;
use async_trait::async_trait;
use reqwest::Client;
pub use amazon_aws::AmazonAws;
pub use http_bin::HttpBin;
pub use if_config::IfConfig;
#[async_trait]
pub trait IpAddrClient {
fn get_url(&self) -> String;
async fn fetch(&self, request: &Client) -> Result<IpAddr>;
}
|
pub(crate) trait MakingString {
/// stringifies given data structure whether struct or enum.
fn stringify(&self) -> String;
}
|
use futures_util::stream::TryStreamExt;
use std::str;
use lazy_static::lazy_static;
use mongodb::{bson::doc, Client};
use regex::Regex;
use serde::{Deserialize, Serialize};
lazy_static! {
static ref RE: Regex = Regex::new(r"[^.a-zA-Z0-9-]").unwrap();
}
#[derive(Debug, PartialEq)]
pub enum Error {
Write(String),
Database(String),
Multi(Vec<Error>),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
match self {
Error::Write(s) => write!(f, "write: {}", s),
Error::Database(s) => write!(f, "database: {}", s),
Error::Multi(ee) => write!(f, "multi: {:?}", ee),
}
}
}
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Media {
#[serde(rename = "_id")]
pub filename: String,
#[serde(rename = "type")]
pub typ: String,
pub tags: Vec<String>,
}
pub struct Images {
client: Client,
db: String,
}
impl Images {
pub async fn open(mongo_uri: &str, db: &str) -> Result<Images> {
let client = match Client::with_uri_str(mongo_uri).await {
Ok(client) => client,
Err(err) => return Err(Error::Database(err.to_string())),
};
Ok(Self {
client,
db: db.to_string(),
})
}
fn sanitize(id: &str) -> String {
RE.replace_all(id, "-").to_string()
}
pub async fn list(&mut self, skip: u64, limit: i64, search: &str) -> Result<Vec<Media>> {
let mut limit = limit;
if !(0..=1000).contains(&limit) {
limit = 10;
}
let opts = mongodb::options::FindOptions::builder()
.sort(doc! {"_id": 1})
.skip(skip)
.limit(limit)
.build();
let mut filter = doc! {};
if !search.is_empty() {
filter = doc! {
"$text": doc! {
"$search": search,
},
};
}
let mut cursor = match self
.client
.database(&self.db)
.collection::<Media>("media")
.find(filter, Some(opts))
.await
{
Ok(cursor) => cursor,
Err(e) => return Err(Error::Database(e.to_string())),
};
let mut mm = vec![];
loop {
let m = match cursor.try_next().await {
Ok(r) => r,
Err(e) => return Err(Error::Database(e.to_string())),
};
match m {
Some(m) => mm.push(m),
None => break,
};
}
Ok(mm)
}
pub async fn remove(&mut self, id: &str) -> Result<()> {
// sanitize.
let id = Images::sanitize(id);
match self
.client
.database(&self.db)
.collection::<Media>("media")
.delete_one(doc! {"_id": id.clone()}, None)
.await
{
Ok(_) => Ok(()),
Err(e) => Err(Error::Database(e.to_string())),
}
}
pub async fn get(&mut self, id: &str) -> Result<Option<Media>> {
// sanitize.
let id = Images::sanitize(id);
match self
.client
.database(&self.db)
.collection::<Media>("media")
.find_one(doc! {"_id": id.clone()}, None)
.await
{
Ok(result) => Ok(result),
Err(e) => Err(Error::Database(e.to_string())),
}
}
pub async fn put(&mut self, m: &mut Media) -> Result<()> {
// Insert into media.
let id = Images::sanitize(&m.filename);
m.filename = id.clone();
match self
.client
.database(&self.db)
.collection::<Media>("media")
.insert_one(m, None)
.await
{
Ok(_) => (),
Err(e) => return Err(Error::Database(e.to_string())),
};
Ok(())
}
}
#[cfg(test)]
mod tests {
use crate::*;
#[test]
fn sanitize() {
assert_eq!(Images::sanitize("foo/1.jpg"), "foo-1.jpg".to_string());
assert_eq!(Images::sanitize("foo-1.jpg"), "foo-1.jpg".to_string());
assert_eq!(Images::sanitize("foo/../1.jpg"), "foo-..-1.jpg".to_string());
}
}
|
use crate::goodreads::*;
use crate::io::object::ThreadObjectWriter;
use crate::prelude::*;
use crate::util::logging::data_progress;
use serde::de::DeserializeOwned;
#[derive(clap::Subcommand, Debug)]
pub enum GRScan {
/// Scan GoodReads works.
Works(ScanInput),
/// Scan GoodReads books.
Books(ScanInput),
/// Scan GoodReads genres.
Genres(ScanInput),
/// Scan GoodReads authors.
Authors(ScanInput),
/// Scan GoodReads interactions.
Interactions(InterInput),
}
#[derive(Args, Debug)]
pub struct ScanInput {
/// Input file
#[arg(name = "INPUT")]
infile: PathBuf,
}
/// Input options for an interaction scan
#[derive(Args, Debug)]
pub struct InterInput {
/// Book ID mapping file (only for CSV input)
#[arg(name = "MAP", long = "book-map")]
book_map: Option<PathBuf>,
/// Run in CSV mode
#[arg(long = "csv")]
csv_mode: bool,
#[command(flatten)]
scan: ScanInput,
}
fn scan_gr<R, W>(path: &Path, proc: W) -> Result<()>
where
W: ObjectWriter<R> + DataSink + Send + 'static,
R: DeserializeOwned + Send + Sync + 'static,
{
let outs: Vec<_> = proc
.output_files()
.iter()
.map(|p| p.to_path_buf())
.collect();
info!("reading data from {}", path.display());
let pb = data_progress(0);
let read = LineProcessor::open_gzip(path, pb.clone())?;
let mut writer = ThreadObjectWriter::new(proc);
read.process_json(&mut writer)?;
pb.finish_and_clear();
writer.finish()?;
for out in outs {
let outf = out.as_path();
info!(
"output {} is {}",
outf.display(),
friendly::bytes(file_size(outf)?)
);
}
Ok(())
}
impl GRScan {
pub fn exec(&self) -> Result<()> {
match self {
GRScan::Works(opts) => {
info!("scanning GoodReads works");
scan_gr(&opts.infile, work::WorkWriter::open()?)?;
}
GRScan::Books(opts) => {
info!("scanning GoodReads books");
scan_gr(&opts.infile, book::BookWriter::open()?)?;
}
GRScan::Genres(opts) => {
info!("scanning GoodReads book genres");
scan_gr(&opts.infile, genres::BookGenreWriter::open()?)?;
}
GRScan::Authors(opts) => {
info!("scanning GoodReads book genres");
scan_gr(&opts.infile, author::AuthorWriter::open()?)?;
}
GRScan::Interactions(opts) => {
if opts.csv_mode {
info!("scanning simplified GoodReads interactions");
let books = opts.book_map.as_ref();
let books = books.ok_or_else(|| anyhow!("book map required for CSV mode"))?;
simple_interaction::scan_interaction_csv(books, &opts.scan.infile)?;
} else {
info!("scanning GoodReads interactions");
scan_gr(&opts.scan.infile, interaction::IntWriter::open()?)?;
}
}
};
Ok(())
}
}
|
#[doc = "Reader of register CONN_PARAM_ACC_WIN_WIDEN"]
pub type R = crate::R<u32, super::CONN_PARAM_ACC_WIN_WIDEN>;
#[doc = "Writer for register CONN_PARAM_ACC_WIN_WIDEN"]
pub type W = crate::W<u32, super::CONN_PARAM_ACC_WIN_WIDEN>;
#[doc = "Register CONN_PARAM_ACC_WIN_WIDEN `reset()`'s with value 0"]
impl crate::ResetValue for super::CONN_PARAM_ACC_WIN_WIDEN {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `ACC_WINDOW_WIDEN`"]
pub type ACC_WINDOW_WIDEN_R = crate::R<u16, u16>;
#[doc = "Write proxy for field `ACC_WINDOW_WIDEN`"]
pub struct ACC_WINDOW_WIDEN_W<'a> {
w: &'a mut W,
}
impl<'a> ACC_WINDOW_WIDEN_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !0x03ff) | ((value as u32) & 0x03ff);
self.w
}
}
impl R {
#[doc = "Bits 0:9 - HW uses this register to load the accumulated window windeing value from the connection memory. This can be used by firmware as a failsafe option when the hardware load is disabled. In all other conditions, this register should not be updated by firmware."]
#[inline(always)]
pub fn acc_window_widen(&self) -> ACC_WINDOW_WIDEN_R {
ACC_WINDOW_WIDEN_R::new((self.bits & 0x03ff) as u16)
}
}
impl W {
#[doc = "Bits 0:9 - HW uses this register to load the accumulated window windeing value from the connection memory. This can be used by firmware as a failsafe option when the hardware load is disabled. In all other conditions, this register should not be updated by firmware."]
#[inline(always)]
pub fn acc_window_widen(&mut self) -> ACC_WINDOW_WIDEN_W {
ACC_WINDOW_WIDEN_W { w: self }
}
}
|
use crate::{
inspector::{
editors::{
Layout, PropertyEditorBuildContext, PropertyEditorDefinition, PropertyEditorInstance,
PropertyEditorMessageContext,
},
InspectorError,
},
message::{
FieldKind, MessageDirection, PropertyChanged, TextBoxMessage, UiMessage, UiMessageData,
},
text_box::TextBoxBuilder,
widget::WidgetBuilder,
Thickness, VerticalAlignment,
};
use std::any::TypeId;
#[derive(Debug)]
pub struct StringPropertyEditorDefinition;
impl PropertyEditorDefinition for StringPropertyEditorDefinition {
fn value_type_id(&self) -> TypeId {
TypeId::of::<String>()
}
fn create_instance(
&self,
ctx: PropertyEditorBuildContext,
) -> Result<PropertyEditorInstance, InspectorError> {
let value = ctx.property_info.cast_value::<String>()?;
Ok(PropertyEditorInstance {
title: Default::default(),
editor: TextBoxBuilder::new(WidgetBuilder::new().with_margin(Thickness::uniform(1.0)))
.with_text(value)
.with_vertical_text_alignment(VerticalAlignment::Center)
.build(ctx.build_context),
})
}
fn create_message(
&self,
ctx: PropertyEditorMessageContext,
) -> Result<Option<UiMessage>, InspectorError> {
let value = ctx.property_info.cast_value::<String>()?;
Ok(Some(TextBoxMessage::text(
ctx.instance,
MessageDirection::ToWidget,
value.clone(),
)))
}
fn translate_message(
&self,
name: &str,
owner_type_id: TypeId,
message: &UiMessage,
) -> Option<PropertyChanged> {
if message.direction() == MessageDirection::FromWidget {
if let UiMessageData::TextBox(TextBoxMessage::Text(value)) = message.data() {
return Some(PropertyChanged {
owner_type_id,
name: name.to_string(),
value: FieldKind::object(value.clone()),
});
}
}
None
}
fn layout(&self) -> Layout {
Layout::Horizontal
}
}
|
use std::io;
use std::io::prelude;
use std::io::BufRead;
fn main()
{
print_single_line("name ?");
let for_name = read_line_iter();
print_single_line("sur?:");
let sur = read_line_buffer();
print!("Hello {} {} ", for_name, sur);
}
fn print_single_line(text: &str)
{
println!("{}", text);
//io::stdout().flush().unwrap();
}
fn read_line_iter() -> String
{
let stdin = io::stdin();
let input = stdin.lock().lines().next();
input.expect("no line").expect("Fail").trim().to_string()
}
fn read_line_buffer() -> String
{
let mut input = String::new();
io::stdin().read_line(&mut input).expect("Fail");
input.trim().to_string()fda
} |
// Copyright © 2017, ACM@UIUC
//
// This file is part of the Groot Project.
//
// The Groot Project is open source software, released under the
// University of Illinois/NCSA Open Source License. You should have
// received a copy of this license in a file with the distribution.
extern crate iron;
use iron::prelude::*;
use iron::{Handler};
use iron::status;
use std::collections::HashMap;
pub struct Router {
// Routes here are simply matched with the url path.
routes: HashMap<String, Box<Handler>>
}
impl Router {
pub fn new() -> Self {
Router { routes: HashMap::new() }
}
pub fn AddRoute<H>(&mut self, path: String, handler: H) where H: Handler {
self.routes.insert(path, Box::new(handler));
}
}
impl Handler for Router {
fn handle(&self, req: &mut Request) -> IronResult<Response> {
match self.routes.get(&req.url.path().join("/")) {
Some(handler) => handler.handle(req),
None => Ok(Response::with(status::NotFound))
}
}
} |
use crate::Error;
use ark_std::rand::{CryptoRng, Rng, SeedableRng};
use ark_std::{
cfg_chunks,
fmt::{Debug, Formatter, Result as FmtResult},
marker::PhantomData,
vec,
vec::Vec,
};
#[cfg(feature = "parallel")]
use rayon::prelude::*;
use super::pedersen;
use crate::variable_length_crh::VariableLengthCRH;
use ark_ec::{
twisted_edwards_extended::GroupProjective as TEProjective, ModelParameters, ProjectiveCurve,
TEModelParameters,
};
use ark_ff::{Field, PrimeField, UniformRand};
pub mod constraints;
type ConstraintF<P> = <<P as ModelParameters>::BaseField as Field>::BasePrimeField;
pub const WINDOW_SIZE: usize = 64;
pub const CHUNK_SIZE: usize = 3;
pub struct VariableLengthBoweHopwoodParameters<P: TEModelParameters> {
pub seed: Vec<u8>,
#[doc(hidden)]
pub _params: PhantomData<P>,
}
impl<P: TEModelParameters> Clone for VariableLengthBoweHopwoodParameters<P> {
fn clone(&self) -> Self {
Self {
seed: self.seed.clone(),
_params: PhantomData,
}
}
}
impl<P: TEModelParameters> Default for VariableLengthBoweHopwoodParameters<P> {
fn default() -> Self {
Self {
seed: vec![0u8; 32],
_params: PhantomData,
}
}
}
impl<P: TEModelParameters> VariableLengthBoweHopwoodParameters<P> {
pub fn get_generators<RO: Rng + CryptoRng + SeedableRng>(
&self,
pos: usize,
) -> Vec<Vec<TEProjective<P>>> {
let mut seed = RO::Seed::default();
let seed_as_mut = seed.as_mut();
seed_as_mut[..self.seed.len()].clone_from_slice(&self.seed[..]);
let mut rng = RO::from_seed(seed);
let num_windows = (pos + WINDOW_SIZE - 1) / WINDOW_SIZE;
let mut generators = Vec::new();
for _ in 0..num_windows {
let mut generators_for_segment = Vec::new();
let mut base = TEProjective::rand(&mut rng);
for _ in 0..WINDOW_SIZE {
generators_for_segment.push(base);
for _ in 0..4 {
base.double_in_place();
}
}
generators.push(generators_for_segment);
}
generators
}
}
pub struct VariableLengthBoweHopwoodCompressedCRH<
RO: Rng + CryptoRng + SeedableRng,
P: TEModelParameters,
> where
P::BaseField: PrimeField<BasePrimeField = P::BaseField>,
{
_rand: PhantomData<RO>,
_group: PhantomData<P>,
}
impl<RO: Rng + CryptoRng + SeedableRng, P: TEModelParameters> VariableLengthCRH<ConstraintF<P>>
for VariableLengthBoweHopwoodCompressedCRH<RO, P>
where
P::BaseField: PrimeField<BasePrimeField = P::BaseField>,
{
type Output = ConstraintF<P>;
type Parameters = VariableLengthBoweHopwoodParameters<P>;
fn setup<R: Rng>(rng: &mut R) -> Result<Self::Parameters, Error> {
let mut seed = RO::Seed::default();
let seed_as_mut = seed.as_mut();
rng.fill_bytes(seed_as_mut);
Ok(Self::Parameters {
seed: seed_as_mut.to_vec(),
_params: PhantomData,
})
}
fn evaluate(parameters: &Self::Parameters, input: &[u8]) -> Result<Self::Output, Error> {
let mut padded_input = Vec::with_capacity(input.len());
let input = pedersen::bytes_to_bits(input);
padded_input.extend_from_slice(&input);
if input.len() % CHUNK_SIZE != 0 {
let current_length = input.len();
padded_input.extend_from_slice(&vec![false; CHUNK_SIZE - current_length % CHUNK_SIZE]);
}
assert_eq!(padded_input.len() % CHUNK_SIZE, 0);
assert_eq!(CHUNK_SIZE, 3);
// Compute sum of h_i^{sum of
// (1-2*c_{i,j,2})*(1+c_{i,j,0}+2*c_{i,j,1})*2^{4*(j-1)} for all j in segment}
// for all i. Described in section 5.4.1.7 in the Zcash protocol
// specification.
let generator = parameters.get_generators::<RO>(padded_input.len() / CHUNK_SIZE);
let result = cfg_chunks!(padded_input, WINDOW_SIZE * CHUNK_SIZE)
.zip(generator)
.map(|(segment_bits, segment_generators)| {
cfg_chunks!(segment_bits, CHUNK_SIZE)
.zip(segment_generators)
.map(|(chunk_bits, generator)| {
let mut encoded = generator;
if chunk_bits[0] {
encoded += generator;
}
if chunk_bits[1] {
encoded = encoded + &generator + &generator;
}
if chunk_bits[2] {
encoded = -encoded;
}
encoded
})
.sum::<TEProjective<P>>()
})
.sum::<TEProjective<P>>();
Ok(result.into_affine().x)
}
fn convert_output_to_field_elements(
output: Self::Output,
) -> Result<Vec<ConstraintF<P>>, Error> {
Ok(vec![output])
}
}
impl<P: TEModelParameters> Debug for VariableLengthBoweHopwoodParameters<P>
where
P::BaseField: PrimeField<BasePrimeField = P::BaseField>,
{
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
writeln!(f, "Bowe-Hopwood-Pedersen Hash Parameters {{")?;
writeln!(f, "\t Generator {:?}", self.seed)?;
writeln!(f, "}}")
}
}
#[cfg(test)]
mod test {
use crate::variable_length_crh::bowe_hopwood::VariableLengthBoweHopwoodCompressedCRH;
use crate::variable_length_crh::VariableLengthCRH;
use ark_ed_on_bls12_381::EdwardsParameters;
use ark_std::test_rng;
use rand_chacha::ChaChaRng;
type H = VariableLengthBoweHopwoodCompressedCRH<ChaChaRng, EdwardsParameters>;
#[test]
fn test_simple_bh() {
let rng = &mut test_rng();
let params = H::setup(rng).unwrap();
let _ = H::evaluate(¶ms, &[1, 2, 3]).unwrap();
}
}
|
extern crate cpal;
use std::sync::Arc;
use std::sync::Mutex;
mod synth;
use synth::nodes::*;
fn main() {
//Setup cpal
let device = cpal::default_output_device().expect("Failed to get default output device");
let format = device.default_output_format().expect("Failed to get default output format");
let event_loop = cpal::EventLoop::new();
let stream_id = event_loop.build_output_stream(&device, &format).unwrap();
event_loop.play_stream(stream_id.clone());
let sample_rate = format.sample_rate.0 as f32;
let mut sample_clock = 0f32;
/*let tree = Sum {
nodes: vec![
Box::new(Sinoid {
freq: 440.0,
offset: 0.0
}),
Box::new(Square {
freq: 440.0,
offset: 0.5
}),
]
};*/
let tree = WaveGenerator {
wave_type: WaveType::Sawtooth,
freq: 440.0,
offset: 0.0
};
let tree = Mutex::new (tree);
let tree = Arc::new (tree);
//Get 1 sample recursively
let mut next_value = (move |out_node: Arc<Mutex<dyn Node>>| {
move || {
sample_clock = (sample_clock + 1.0) % sample_rate;
let sample_position = sample_clock / sample_rate;
let context = SamplingContext {
clock: sample_position,
sample_rate
};
let out = out_node.lock().unwrap().sample (&context);
//println!("{}", out.min(1.0).max(-1.0));
out.min(1.0).max(-1.0)
}
}) (tree);
//Boilerplate shit
event_loop.run(move |_, data| {
match data {
cpal::StreamData::Output { buffer: cpal::UnknownTypeOutputBuffer::U16(mut buffer) } => {
for sample in buffer.chunks_mut(format.channels as usize) {
let value = ((next_value() * 0.5 + 0.5) * std::u16::MAX as f32) as u16;
for out in sample.iter_mut() {
*out = value;
}
}
},
cpal::StreamData::Output { buffer: cpal::UnknownTypeOutputBuffer::I16(mut buffer) } => {
for sample in buffer.chunks_mut(format.channels as usize) {
let value = (next_value() * std::i16::MAX as f32) as i16;
for out in sample.iter_mut() {
*out = value;
}
}
},
cpal::StreamData::Output { buffer: cpal::UnknownTypeOutputBuffer::F32(mut buffer) } => {
for sample in buffer.chunks_mut(format.channels as usize) {
let value = next_value();
for out in sample.iter_mut() {
*out = value;
}
}
},
_ => (),
}
});
}
|
#[doc = "Register `WCCR` reader"]
pub type R = crate::R<WCCR_SPEC>;
#[doc = "Register `WCCR` writer"]
pub type W = crate::W<WCCR_SPEC>;
#[doc = "Field `REFRESH` reader - REFRESH"]
pub type REFRESH_R = crate::FieldReader<u16>;
#[doc = "Field `REFRESH` writer - REFRESH"]
pub type REFRESH_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 16, O, u16>;
impl R {
#[doc = "Bits 0:15 - REFRESH"]
#[inline(always)]
pub fn refresh(&self) -> REFRESH_R {
REFRESH_R::new((self.bits & 0xffff) as u16)
}
}
impl W {
#[doc = "Bits 0:15 - REFRESH"]
#[inline(always)]
#[must_use]
pub fn refresh(&mut self) -> REFRESH_W<WCCR_SPEC, 0> {
REFRESH_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "WCCR\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`wccr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`wccr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct WCCR_SPEC;
impl crate::RegisterSpec for WCCR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`wccr::R`](R) reader structure"]
impl crate::Readable for WCCR_SPEC {}
#[doc = "`write(|w| ..)` method takes [`wccr::W`](W) writer structure"]
impl crate::Writable for WCCR_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets WCCR to value 0"]
impl crate::Resettable for WCCR_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use critical_section::{set_impl, Impl, RawRestoreState};
use crate::interrupt;
use crate::register::primask;
struct SingleCoreCriticalSection;
set_impl!(SingleCoreCriticalSection);
unsafe impl Impl for SingleCoreCriticalSection {
unsafe fn acquire() -> RawRestoreState {
let was_active = primask::read().is_active();
interrupt::disable();
was_active
}
unsafe fn release(was_active: RawRestoreState) {
// Only re-enable interrupts if they were enabled before the critical section.
if was_active {
interrupt::enable()
}
}
}
|
use core::{self, async, Async, Bytes, Pair, Sender};
use mio::{NonBlock, Token};
use mio::tcp::TcpListener;
use net::{Action, Stream};
use reactor::Notify;
use std::{fmt, mem};
// ## Implementation notes
//
// It's important that a listener is never dropped while in the Waiting
// state as the reactor may receive events with the token at a future time. As
// long as this is possible, the listener must stay in the slab
pub struct Listener {
io: NonBlock<TcpListener>,
state: State,
}
impl Listener {
pub fn of(io: NonBlock<TcpListener>) -> (Listener, core::Stream<Pair<Bytes>>) {
// Core Stream
let (tx, rx) = async::Pair::pair();
(Listener::new(io, tx), rx)
}
fn new(io: NonBlock<TcpListener>, tx: Sender<Pair<Bytes>>) -> Listener {
Listener {
io: io,
state: State::New { tx: tx },
}
}
pub fn io(&self) -> &NonBlock<TcpListener> {
&self.io
}
pub fn listen(&mut self, notify: &Notify, token: Token) -> Action {
let tx = self.state.new_to_waiting();
if tx.is_ready() {
if tx.is_err() {
return Action::remove();
} else {
return self.ready(tx);
}
}
self.wait(tx, notify, token);
Action::wait()
}
pub fn ready(&mut self, tx: Sender<Pair<Bytes>>) -> Action {
self.state.waiting_to_listening(tx);
Action::read()
}
pub fn accept(&mut self, notify: &Notify, token: Token) -> Option<(Stream, Action)> {
// Get the sender
let tx = self.state.listening_to_waiting();
// Accept a socket
let sock = match self.io.accept() {
Ok(Some(sock)) => sock,
Ok(None) => unimplemented!(),
Err(_) => panic!("[unimplemented] failed to accept socket"),
};
// Build the stream wrapper for the socket
let (stream, pair) = Stream::of(sock);
debug!("Listener::accept; ~ Sending socket to consumer");
// Send the sender / stream pair to the user
let busy = tx.send(pair);
match busy.poll() {
Ok(Ok(tx)) => {
Some((stream, self.ready(tx)))
}
Ok(Err(_)) => {
Some((stream, Action::remove()))
}
Err(busy) => {
self.wait(busy, notify, token);
Some((stream, Action::wait()))
}
}
}
fn wait<A>(&mut self, tx: A, notify: &Notify, token: Token)
where A: Async<Value=Sender<Pair<Bytes>>> {
// Wait for interest to be registered before attempting to accept
// from the socket
let notify = notify.clone();
tx.receive(move |res| {
debug!("Listener::wait; socket ready");
match res {
Ok(tx) => {
if notify.accept_interest(Some(tx), token) {
return;
}
}
Err(_) => {
// The consumer has dropped the stream and does not want
// any new sockets. The listener can be closed.
if notify.accept_interest(None, token) {
return;
}
}
}
panic!("[unimplemented] failed to notify reactor of ready listener");
});
}
}
enum State {
New { tx: Sender<Pair<Bytes>> },
Waiting,
Listening { tx: Sender<Pair<Bytes>> },
}
impl State {
fn new_to_waiting(&mut self) -> Sender<Pair<Bytes>> {
match mem::replace(self, State::Waiting) {
State::New { tx } => tx,
_ => panic!("unexpected state"),
}
}
fn waiting_to_listening(&mut self, tx: Sender<Pair<Bytes>>) {
match mem::replace(self, State::Listening { tx: tx }) {
State::Waiting => {},
_ => panic!("unexpected state"),
}
}
fn listening_to_waiting(&mut self) -> Sender<Pair<Bytes>> {
match mem::replace(self, State::Waiting) {
State::Listening { tx} => tx,
_ => panic!("unexpected state"),
}
}
}
impl fmt::Debug for Listener {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "eventual_io::Listener {{ ... }}")
}
}
|
#![deny(rust_2018_idioms, unused, unused_crate_dependencies, unused_import_braces, unused_lifetimes, unused_qualifications, warnings)]
#![forbid(unsafe_code)]
use {
std::{
env,
io,
},
serenity::{
model::prelude::*,
prelude::*,
},
sqlx::PgPool,
};
pub mod config;
pub mod ipc;
pub mod lang;
pub mod parse;
pub mod twitch;
pub mod user_list;
pub mod werewolf;
pub const GEFOLGE: GuildId = GuildId::new(355761290809180170);
pub const ADMIN: RoleId = RoleId::new(355776689051140099);
pub const QUIZMASTER: RoleId = RoleId::new(847443327069454378);
pub const MENSCH: RoleId = RoleId::new(386753710434287626);
pub const GUEST: RoleId = RoleId::new(784929665478557737);
pub const FENHL: UserId = UserId::new(86841168427495424);
/// `typemap` key for the PostgreSQL database connection.
pub struct Database;
impl TypeMapKey for Database {
type Value = PgPool;
}
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error(transparent)] ChannelIdParse(#[from] ChannelIdParseError),
#[error(transparent)] Env(#[from] env::VarError),
#[error(transparent)] Io(#[from] io::Error),
#[error(transparent)] Ipc(#[from] crate::ipc::Error),
#[error(transparent)] Json(#[from] serde_json::Error),
#[error(transparent)] QwwStartGame(#[from] quantum_werewolf::game::state::StartGameError),
#[error(transparent)] RoleIdParse(#[from] RoleIdParseError),
#[error(transparent)] Serenity(#[from] serenity::Error),
#[error(transparent)] Sql(#[from] sqlx::Error),
#[error(transparent)] Twitch(#[from] twitch_helix::Error),
#[error(transparent)] UserIdParse(#[from] UserIdParseError),
#[error(transparent)] Wheel(#[from] wheel::Error),
#[error("invalid game action: {0}")]
GameAction(String),
/// Returned if the config is not present in Serenity context.
#[error("config missing in Serenity context")]
MissingConfig,
/// Returned if a Serenity context was required outside of an event handler but the `ready` event has not been received yet.
#[error("Serenity context not available before ready event")]
MissingContext,
/// The reply to an IPC command did not end in a newline.
#[error("the reply to an IPC command did not end in a newline")]
MissingNewline,
#[error("Twitch returned unexpected user info")]
TwitchUserLookup,
}
|
pub mod chip8;
|
// ===============================================================================
// Authors: AFRL/RQQA
// Organization: Air Force Research Laboratory, Aerospace Systems Directorate, Power and Control Division
//
// Copyright (c) 2017 Government of the United State of America, as represented by
// the Secretary of the Air Force. No copyright is claimed in the United States under
// Title 17, U.S. Code. All Other Rights Reserved.
// ===============================================================================
// This file was auto-created by LmcpGen. Modifications will be overwritten.
pub mod graph_node;
pub mod graph_edge;
pub mod graph_region;
pub mod route_constraints;
pub mod route_request;
pub mod route_plan_request;
pub mod route_plan;
pub mod route_plan_response;
pub mod route_response;
pub mod egress_route_request;
pub mod egress_route_response;
pub mod road_points_constraints;
pub mod road_points_request;
pub mod road_points_response;
|
// https://adventofcode.com/2017/day/4
use std::io::{BufRead, BufReader};
use std::fs::File;
fn main() {
let f = BufReader::new(File::open("input.txt").expect("Opening input.txt failed"));
let lines: Vec<String> = f.lines()
.map(|l| l.expect("Reading lines failed"))
.collect();
// First star
let mut valid_first = 0;
for line in &lines {
// Get list of words without the last one
let mut words: Vec<&str> = line.split(' ').collect();
words.pop();
valid_first += 1;
// Try to find each word in the remaining line
let mut offset = 0;
for (i, word) in words.iter().enumerate() {
offset += words[i].len() + 1;
if line[offset..].find(word) != None {
// Word found in remaining phrase, phrase is invalid
valid_first -= 1;
break;
}
}
}
// Assert to facilitate further tweaks
assert_eq!(477, valid_first);
// Second star
let mut valid_second = 0;
'phrases: for line in &lines {
// Save lengths and character counts for each word in phrase
let mut counts: Vec<(usize, Vec<u32>)> = Vec::new();
for word in line.split(' ') {
let mut chars: Vec<u32> = vec![0; 26];
for c in word.chars() {
chars[(c as u8 - 'a' as u8) as usize] += 1;
}
counts.push((word.len(), chars));
}
// Check every word against remaining words
for (i, ref_count) in counts.iter().enumerate() {
'remaining_words: for count in &counts[(i + 1)..counts.len()] {
// Only check if lengths match
if ref_count.0 == count.0 {
for c in count.1.iter().zip(ref_count.1.iter()) {
if c.0 != c.1 {
// Words are not anagrams, check next word
continue 'remaining_words;
}
}
// Phrase is invalid, continue to next phrase
continue 'phrases;
}
}
}
// No matches found
valid_second += 1;
}
// Assert to facilitate further tweaks
assert_eq!(167, valid_second);
println!("{}, {} valid passpharases", valid_first, valid_second);
}
|
extern crate byteorder;
use byteorder::ReadBytesExt;
pub enum Context {
WorldReceive {
width: u32,
height: u32,
data: Option<Vec<u8>>,
player: Option<u32>,
},
PlayerReceive,
PlayerIdReceive,
MoveReceive,
}
pub struct Handler {
status: Option<u16>,
context: Option<Context>,
}
impl Handler {
pub fn new() -> Handler {
Handler {
status: None,
context: None,
}
}
pub fn handle_socket(
&mut self,
socket: &mut super::socket::Socket,
world: &mut super::super::world::world::World,
) {
let status_code: u16;
{
if self.status.is_none() {
let received = socket.retrieve();
if received.is_none() {
return;
}
self.status = Some(
std::io::Cursor::new(received.unwrap())
.read_u16::<byteorder::LittleEndian>()
.unwrap(),
);
}
status_code = self.status.unwrap();
}
self.handle_packet(status_code, socket, world);
}
fn handle_packet(
&mut self,
status: u16,
socket: &mut super::socket::Socket,
world: &mut super::super::world::world::World,
) {
match status {
1 => match self.context.as_mut() {
Some(context) => match context {
Context::WorldReceive {
width,
height,
data,
player,
} => match socket.retrieve() {
Some(received) => {
if data.is_none() {
*data = Some(received);
socket.receive(4);
} else if player.is_none() {
let player_count = std::io::Cursor::new(&received)
.read_u32::<byteorder::LittleEndian>()
.unwrap();
*player = Some(player_count);
socket.receive(player_count as usize * 19);
} else {
let mut players = vec![];
for index in 0..player.unwrap() as usize {
let offset = index * 19;
let id = std::io::Cursor::new(&received[offset..offset + 8])
.read_u64::<byteorder::LittleEndian>()
.unwrap();
let color = (
received[offset + 8],
received[offset + 9],
received[offset + 10],
);
let x =
std::io::Cursor::new(&received[offset + 11..offset + 15])
.read_i32::<byteorder::LittleEndian>()
.unwrap();
let y =
std::io::Cursor::new(&received[offset + 15..offset + 19])
.read_i32::<byteorder::LittleEndian>()
.unwrap();
world.add_player(id, color, x, y);
players.push((id, color, x, y));
}
world
.player_controller_mut()
.set_player_id(players.first().unwrap().0);
println!("players: {:?}", players);
world.init_map(super::super::world::map::Map::from_data(
*width,
*height,
data.take().unwrap(),
));
socket.receive(2);
self.status = None;
self.context = None;
}
}
None => {}
},
_ => unreachable!(),
},
None => match socket.retrieve() {
Some(received) => {
let width = std::io::Cursor::new(&received[0..4])
.read_u32::<byteorder::LittleEndian>()
.unwrap();
let height = std::io::Cursor::new(&received[4..8])
.read_u32::<byteorder::LittleEndian>()
.unwrap();
self.context = Some(Context::WorldReceive {
width,
height,
data: None,
player: None,
});
socket.receive((width * height) as usize);
}
None => {
socket.receive(8);
}
},
},
2 => match self.context.as_mut() {
Some(context) => match context {
Context::PlayerReceive => match socket.retrieve() {
Some(received) => {
let id = std::io::Cursor::new(&received[0..8])
.read_u64::<byteorder::LittleEndian>()
.unwrap();
let color = (received[8], received[9], received[10]);
let x = std::io::Cursor::new(&received[11..15])
.read_i32::<byteorder::LittleEndian>()
.unwrap();
let y = std::io::Cursor::new(&received[15..19])
.read_i32::<byteorder::LittleEndian>()
.unwrap();
world.add_player(id, color, x, y);
println!("new player income: {:?}", (id, color, x, y));
socket.receive(2);
self.status = None;
self.context = None;
}
None => {}
},
_ => unreachable!(),
},
None => {
socket.receive(19);
self.context = Some(Context::PlayerReceive);
}
},
3 => match self.context.as_mut() {
Some(context) => match context {
Context::PlayerIdReceive => match socket.retrieve() {
Some(received) => {
let id = std::io::Cursor::new(&received)
.read_u64::<byteorder::LittleEndian>()
.unwrap();
world.remove_player(id);
println!("player exit: {:?}", id);
socket.receive(2);
self.status = None;
self.context = None;
}
None => {}
},
_ => unreachable!(),
},
None => {
socket.receive(8);
self.context = Some(Context::PlayerIdReceive);
}
},
4 => match self.context.as_mut() {
Some(context) => match context {
Context::MoveReceive => match socket.retrieve() {
Some(received) => {
let id = std::io::Cursor::new(&received)
.read_u64::<byteorder::LittleEndian>()
.unwrap();
for player in world.players_mut().iter_mut() {
if player.id() != id {
continue;
}
match received[8] {
0 => {
player.y -= 1;
}
1 => {
player.y += 1;
}
2 => {
player.x -= 1;
}
3 => {
player.x += 1;
}
_ => {}
}
}
socket.receive(2);
self.status = None;
self.context = None;
}
None => {}
},
_ => unreachable!(),
},
None => {
socket.receive(9);
self.context = Some(Context::MoveReceive);
}
},
_ => {
socket.receive(2);
self.status = None;
self.context = None;
}
}
}
}
|
#[doc = "Reader of register SPINLOCK13"]
pub type R = crate::R<u32, super::SPINLOCK13>;
impl R {}
|
use super::SharableReceiver;
use std::net::{TcpListener, TcpStream};
use std::sync::{
mpsc::{self, Receiver, Sender, TryRecvError},
Arc,
};
use std::time::Duration;
const LISTENER_TIMEOUT_DUR: Duration = Duration::from_millis(15 * 1000);
pub struct Listener {
listener: Arc<TcpListener>,
tcp_sender: Sender<TcpStream>,
shutdown_receiver: SharableReceiver<bool>,
}
impl Listener {
pub fn new(
listener: TcpListener,
tcp_sender: Sender<TcpStream>,
shutdown_receiver: SharableReceiver<bool>,
) -> Listener {
Listener {
listener: Arc::new(listener),
tcp_sender,
shutdown_receiver,
}
}
pub fn handler(&self) -> (impl FnOnce() + Send, Receiver<bool>) {
let listener = Arc::clone(&self.listener);
let tcp_sender = self.tcp_sender.clone();
let shutdown_receiver = Arc::clone(&self.shutdown_receiver);
let (shutdown_sender, worker_shutdown_receiver): (Sender<bool>, Receiver<bool>) =
mpsc::channel();
let close = move || {
let mut running = true;
while running {
let shutdown_receiver = shutdown_receiver.lock().unwrap();
match shutdown_receiver.try_recv() {
Ok(_) => {
shutdown_sender.send(true).unwrap();
running = false;
continue;
}
Err(err) => match err {
TryRecvError::Empty => {}
TryRecvError::Disconnected => {
shutdown_sender.send(true).unwrap();
running = false;
}
},
}
match listener.accept() {
Ok((stream, _)) => {
stream.set_read_timeout(Some(LISTENER_TIMEOUT_DUR)).unwrap();
stream
.set_write_timeout(Some(LISTENER_TIMEOUT_DUR))
.unwrap();
tcp_sender.send(stream).unwrap();
}
Err(err) => match err.kind() {
std::io::ErrorKind::WouldBlock => continue,
_ => running = false,
},
}
}
};
(close, worker_shutdown_receiver)
}
}
|
//! # Jak czytać dokumentację API HTTP?
//!
//! Wszystkie funkcje które pełnią rolę endpointu mają w pierwszej linijce dokumentacji metodę i
//! adres endpointu. Aby dowiedzieć się co przyjmują należy zwrócić uwagę na argumenty funkcji.
//! Np. `Json<LoginData>` oznacza, że należy podać dane jako JSON zgodne z `LoginData`. `Data<T>`
//! oraz `HttpRequest` można zignorować, są to szczegóły implementacji serwera.
//!
//! Jeśli parametr jest "opakowany" w enum `Option<T>` oznacza, ze jest on opcjonalny. Np.
//! `Option<Auth>` oznacza, że nie trzeba podawać tokenu sesji, ale może brakować wtedy pewnej
//! funkcjonalności, jak zapisanie wyszukiwania do historii.
//!
//! Inne szczegóły będą raczej podane w tekście samej dokumentacji.
#[macro_use]
extern crate diesel;
use actix::{Addr, SyncArbiter};
use actix_web::web::PayloadConfig;
use actix_web::{middleware, web, App, HttpServer};
use diesel::prelude::{Connection, SqliteConnection};
use failure::ResultExt;
use log::error;
use parking_lot::Mutex;
use serde::Deserialize;
use std::collections::HashMap;
use std::sync::Arc;
use crate::db::models::User;
use db::DbExecutor;
use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
use std::path::PathBuf;
pub mod auth;
mod db;
mod init;
pub mod logs;
pub mod routes;
pub mod songs;
mod utils;
#[derive(Clone, Debug, Deserialize)]
pub struct Config {
pub populator: String,
pub scraper: String,
pub extractor: String,
pub bind_addr: String,
#[serde(default)]
pub tls_private_key_file: Option<PathBuf>,
#[serde(default)]
pub tls_cert_chain_file: Option<PathBuf>,
#[serde(default)]
pub tls_bind_addr: Option<String>,
pub db_path: String,
pub db_threads: usize,
pub max_song_size: usize,
#[serde(default)]
pub max_songs_to_train: Option<usize>,
}
pub struct Actors {
db: Addr<DbExecutor>,
}
fn main() -> Result<(), failure::Error> {
env_logger::init();
let config: Config =
toml::from_str(&std::fs::read_to_string("config.toml").context("config.toml is missing")?)?;
let connection = SqliteConnection::establish(&config.db_path).expect("Failed to open connection to db");
let _ = connection.transaction(|| {
init::init(&config, &connection).map_err(|e| {
error!("Failed to initzialize system: {}", e);
diesel::result::Error::RollbackTransaction
})
});
std::mem::drop(connection);
let _sys = actix::System::new("szaklon");
let sessions = Arc::new(Mutex::new(HashMap::<[u8; 32], User>::new()));
let database_url = config.db_path.clone();
let db_addr = SyncArbiter::start(config.db_threads, move || {
DbExecutor(
SqliteConnection::establish(&database_url).expect("Failed to open connection to db"),
)
});
let c = config.clone();
let mut srv_builder = HttpServer::new(move || {
App::new()
.wrap(middleware::Logger::default())
.wrap(middleware::cors::Cors::new())
.data(sessions.clone())
.data(c.clone())
.data(Actors {
db: db_addr.clone(),
})
.service(web::resource("/login").route(web::post().to_async(auth::login)))
.service(web::resource("/signup").route(web::post().to_async(auth::signup)))
.service(web::resource("/account").route(web::delete().to_async(auth::delete_account)))
.service(
web::resource("/account/{id}")
.route(web::delete().to_async(auth::delete_account_admin)),
)
.service(
web::resource("/recognize/{n}")
.data(PayloadConfig::new(c.max_song_size))
.route(web::post().to_async(songs::recognize)),
)
.service(web::resource("/history").route(web::get().to_async(songs::history)))
.service(web::resource("/history/all").route(web::get().to_async(songs::history_all)))
.service(web::resource("/popular/{n}").route(web::get().to_async(songs::popular)))
.service(web::resource("/songs").route(web::post().to_async(songs::songs)))
.service(web::resource("/edit_song").route(web::post().to_async(songs::edit_song)))
.service(web::resource("/add_song").route(web::post().to_async(songs::add_song)))
.service(web::resource("/genres").route(web::get().to_async(songs::genres)))
.service(web::resource("/artists").route(web::get().to_async(songs::artists)))
.service(web::resource("/users").route(web::get().to_async(auth::users)))
.service(web::resource("/check_session").route(web::get().to(auth::check_session)))
.service(web::resource("/logs").route(web::get().to_async(logs::logs)))
.route("/logout", web::post().to(auth::logout))
})
.bind(&config.bind_addr)?;
// Enable TLS if configured
if let (Some(key_path), Some(cert_path), Some(addr)) = (
config.tls_private_key_file,
config.tls_cert_chain_file,
config.tls_bind_addr,
) {
let mut tls_builder = SslAcceptor::mozilla_modern(SslMethod::tls()).unwrap();
tls_builder
.set_private_key_file(key_path, SslFiletype::PEM)
.unwrap();
tls_builder.set_certificate_chain_file(cert_path).unwrap();
srv_builder = srv_builder.bind_ssl(addr, tls_builder)?;
}
println!("Listinig on:");
for (addr, scheme) in srv_builder.addrs_with_scheme() {
println!("{}://{}", scheme, addr);
}
srv_builder.run()?;
Ok(())
}
|
pub fn is_leap_year(year: u64) -> bool {
let div_by = c_div_by(year);
match year {
_ if div_by(400) => true,
_ if div_by(100) => false,
_ if div_by(4) => true,
_ => false,
}
}
fn c_div_by(y: u64) -> impl Fn(u64) -> bool {
move |num| y % num == 0
}
|
use std::{fs::File, io::{BufRead, BufReader}, vec};
struct Password {
letter: char,
min_amount: u8,
max_amount: u8,
password: String,
}
fn main() {
let file = File::open("inputs/input-2.txt").unwrap();
let lines = BufReader::new(file).lines();
let mut passwords: Vec<Password> = vec![];
for line in lines {
let line = line.unwrap();
let left: Vec<&str> = line.split(": ").collect();
let password = left[1].to_string();
let right: Vec<&str> = left[0].split(" ").collect();
let letter = right[1].chars().collect::<Vec<char>>()[0];
let limits: Vec<&str> = right[0].split("-").collect();
let min_amount: u8 = limits[0].parse().unwrap();
let max_amount: u8 = limits[1].parse().unwrap();
let password = Password {
letter,
min_amount,
max_amount,
password,
};
passwords.push(password);
}
let mut total = 0;
for password in passwords.iter() {
let mut amount = 0;
for x in password.password.chars() {
if x == password.letter {
amount += 1
}
}
if (password.min_amount <= amount) && (amount <= password.max_amount) {
total += 1
}
}
let mut total2 = 0;
for password in passwords.iter() {
let mut amount = 0;
for (i, x) in password.password.chars().enumerate() {
if x == password.letter {
if i + 1 == password.min_amount as usize {
amount += 1
};
if i + 1 == password.max_amount as usize {
amount += 1
};
}
}
if amount == 1 {
total2 += 1
}
}
println!("part 1 {:?}", total);
println!("part 2 {:?}", total2);
}
|
#![allow(non_snake_case)]
extern crate glob;
extern crate cc;
extern crate bindgen;
use glob::glob;
use std::env;
use std::path::PathBuf;
fn main() {
let stark = glob("./libSTARK/libstark/src/**/*.cpp").unwrap().map(|e| e.unwrap()).into_iter();
let algebralib = glob("./libSTARK/algebra/algebralib/**/*.cpp").unwrap().map(|e| e.unwrap()).into_iter();
let FFT = glob("./libSTARK/algebra/FFT/**/*.cpp").unwrap().map(|e| e.unwrap()).into_iter();
let fsrs = glob("./libSTARK/fsrs/**/*.cpp").unwrap().map(|e| e.unwrap()).into_iter();
cc::Build::new()
.cpp(true)
.flag("-xc++")
.flag("-std=c++11")
.flag("-O3")
.flag("-g")
.flag("-w")
.flag("-Wall")
.flag("-fmessage-length=0")
.flag("-openmp")
.flag("-maes")
.flag("-msse4")
.flag("-mtune=native")
.flag("-Isrc")
.flag("-Xpreprocessor")
.flag("-pthread")
.flag("-lomp")
.static_flag(true)
.warnings(false)
.extra_warnings(false)
.files(stark)
.include("libSTARK/algebra/algebralib/headers")
.include("libSTARK/algebra/FFT/src")
.include("libSTARK/libstark/src")
.compile("stark");
cc::Build::new()
.cpp(true)
.flag("-xc++")
.flag("-std=c++11")
.flag("-O3")
.flag("-g")
.flag("-w")
.flag("-Wall")
.flag("-fmessage-length=0")
.flag("-openmp")
.flag("-maes")
.flag("-msse4")
.flag("-mtune=native")
.flag("-Isrc")
.flag("-Xpreprocessor")
.flag("-pthread")
.flag("-lomp")
.static_flag(true)
.warnings(false)
.extra_warnings(false)
.files(algebralib)
.include("libSTARK/algebra/algebralib/headers")
.include("libSTARK/algebra/FFT/src")
.include("libSTARK/libstark/src")
.compile("algebralib");
cc::Build::new()
.cpp(true)
.flag("-xc++")
.flag("-std=c++11")
.flag("-O3")
.flag("-g")
.flag("-w")
.flag("-Wall")
.flag("-fmessage-length=0")
.flag("-openmp")
.flag("-maes")
.flag("-msse4")
.flag("-mtune=native")
.flag("-Isrc")
.flag("-Xpreprocessor")
.flag("-pthread")
.flag("-lomp")
.flag("-mpclmul")
.static_flag(true)
.warnings(false)
.extra_warnings(false)
.files(FFT)
.include("libSTARK/algebra/algebralib/headers")
.include("libSTARK/algebra/FFT/src")
.include("libSTARK/libstark/src")
.compile("FFT");
cc::Build::new()
.cpp(true)
.flag("-xc++")
.flag("-std=c++11")
.flag("-O3")
.flag("-g")
.flag("-w")
.flag("-Wall")
.flag("-fmessage-length=0")
.flag("-openmp")
.flag("-maes")
.flag("-msse4")
.flag("-mtune=native")
.flag("-Isrc")
.flag("-Xpreprocessor")
.flag("-pthread")
.flag("-lomp")
.static_flag(true)
.warnings(false)
.extra_warnings(false)
.files(fsrs)
.include("libSTARK/algebra/algebralib/headers")
.include("libSTARK/algebra/FFT/src")
.include("libSTARK/libstark/src")
.compile("fsrs");
println!("cargo:rustc-link-lib=gomp");
let bindings = bindgen::builder()
.header("libSTARK/fsrs/Fsrs_wrapper.hpp")
.trust_clang_mangling(false)
.rustfmt_bindings(true)
.enable_cxx_namespaces()
.clang_arg(r"-xc++")
.clang_arg(r"-std=c++11")
.clang_arg("-Isrc")
.clang_arg("-IlibSTARK/algebra/algebralib/headers")
.clang_arg("-IlibSTARK/algebra/FFT/src")
.clang_arg("-IlibSTARK/libstark/src")
.whitelist_function("execute")
.derive_copy(false)
.layout_tests(false)
.generate()
.expect("Unable to generte bindings");
let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
bindings
.write_to_file(out_path.join("bindings.rs"))
.expect("Couldn't write bindings!");
}
|
// This file is part of rdma-core. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/rdma-core/master/COPYRIGHT. No part of rdma-core, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2016 The developers of rdma-core. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/rdma-core/master/COPYRIGHT.
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum ibv_wc_status
{
IBV_WC_SUCCESS = 0,
IBV_WC_LOC_LEN_ERR = 1,
IBV_WC_LOC_QP_OP_ERR = 2,
IBV_WC_LOC_EEC_OP_ERR = 3,
IBV_WC_LOC_PROT_ERR = 4,
IBV_WC_WR_FLUSH_ERR = 5,
IBV_WC_MW_BIND_ERR = 6,
IBV_WC_BAD_RESP_ERR = 7,
IBV_WC_LOC_ACCESS_ERR = 8,
IBV_WC_REM_INV_REQ_ERR = 9,
IBV_WC_REM_ACCESS_ERR = 10,
IBV_WC_REM_OP_ERR = 11,
IBV_WC_RETRY_EXC_ERR = 12,
IBV_WC_RNR_RETRY_EXC_ERR = 13,
IBV_WC_LOC_RDD_VIOL_ERR = 14,
IBV_WC_REM_INV_RD_REQ_ERR = 15,
IBV_WC_REM_ABORT_ERR = 16,
IBV_WC_INV_EECN_ERR = 17,
IBV_WC_INV_EEC_STATE_ERR = 18,
IBV_WC_FATAL_ERR = 19,
IBV_WC_RESP_TIMEOUT_ERR = 20,
IBV_WC_GENERAL_ERR = 21,
IBV_WC_TM_ERR = 22,
IBV_WC_TM_RNDV_INCOMPLETE = 23,
}
|
// std::cmp::PartialOrd;
use std::cmp::Ordering;
#[derive(Eq)]
struct Class {
size: u32,
section: u32,
grade: u32
}
// impl Eq for Class {}
impl PartialOrd for Class {
fn partial_cmp(&self, rhs: &Class) -> Option<Ordering> {
Some(self.cmp(rhs))
}
}
impl Ord for Class {
fn cmp(&self, rhs: &Class) -> Ordering {
self.size.cmp(&rhs.size)
}
}
impl PartialEq for Class {
fn eq(&self, rhs: &Class) -> bool {
self.size == rhs.size
}
}
fn main() {
let c1 = Class {
size: 1,
section: 1,
grade: 2
};
let c2 = Class {
size: 1,
section: 2,
grade: 2
};
let c3 = Class {
size: 2,
section: 2,
grade: 2
};
println!("{}", c1 == c2);
println!("{}", c1 < c2);
println!("{}", c2 < c3);
println!("{}", c1 <= c2);
println!("{}", c2 <= c3);
}
|
// Copyright 2017 pdb Developers
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
// DBI = "Debug Information"
use std::borrow::Cow;
use std::fmt;
use std::result;
use crate::common::*;
use crate::msf::*;
use crate::{FallibleIterator, SectionCharacteristics};
/// Provides access to the "DBI" stream inside the PDB.
///
/// This is only minimally implemented; it's really just so `PDB` can find the global symbol table.
///
/// # Example
///
/// ```
/// # use pdb::FallibleIterator;
/// #
/// # fn test() -> pdb::Result<usize> {
/// let file = std::fs::File::open("fixtures/self/foo.pdb")?;
/// let mut pdb = pdb::PDB::open(file)?;
///
/// let dbi = pdb.debug_information()?;
///
/// # let mut count: usize = 0;
/// let mut modules = dbi.modules()?;
/// while let Some(module) = modules.next()? {
/// println!("module name: {}, object file name: {}",
/// module.module_name(), module.object_file_name());
/// # count += 1;
/// }
///
/// # Ok(count)
/// # }
/// # assert!(test().expect("test") == 194);
#[derive(Debug)]
pub struct DebugInformation<'s> {
stream: Stream<'s>,
header: DBIHeader,
header_len: usize,
}
impl<'s> DebugInformation<'s> {
pub(crate) fn parse(stream: Stream<'s>) -> Result<Self> {
let mut buf = stream.parse_buffer();
let header = DBIHeader::parse_buf(&mut buf)?;
let header_len = buf.pos();
Ok(DebugInformation {
stream,
header,
header_len,
})
}
pub(crate) fn header(&self) -> DBIHeader {
self.header
}
/// Returns the target's machine type (architecture).
pub fn machine_type(&self) -> Result<MachineType> {
Ok(self.header.machine_type.into())
}
/// Returns this PDB's original `age`.
///
/// This number is written by the linker and should be equal to the image's `age` value. In
/// contrast, [`PDBInformation::age`] may be bumped by other tools and should be greater or
/// equal to the image's `age` value.
///
/// Old PDB files may not specify an age, in which case only [`PDBInformation::age`] should be
/// checked for matching the image.
///
/// [`PDBInformation::age`]: crate::PDBInformation::age
pub fn age(&self) -> Option<u32> {
match self.header.age {
0 => None,
age => Some(age),
}
}
/// Returns an iterator that can traverse the modules list in sequential order.
pub fn modules(&self) -> Result<ModuleIter<'_>> {
let mut buf = self.stream.parse_buffer();
// drop the header
buf.take(self.header_len)?;
let modules_buf = buf.take(self.header.module_list_size as usize)?;
Ok(ModuleIter {
buf: modules_buf.into(),
})
}
/// Returns an iterator that can traverse the section contributions list in sequential order.
pub fn section_contributions(&self) -> Result<DBISectionContributionIter<'_>> {
let mut buf = self.stream.parse_buffer();
// drop the header and modules list
buf.take(self.header_len + self.header.module_list_size as usize)?;
let contributions_buf = buf.take(self.header.section_contribution_size as usize)?;
DBISectionContributionIter::parse(contributions_buf.into())
}
}
/// The version of the PDB format.
///
/// This version type is used in multiple locations: the DBI header, and the PDBI header.
#[non_exhaustive]
#[derive(Debug, Copy, Clone)]
#[allow(missing_docs)]
pub enum HeaderVersion {
V41,
V50,
V60,
V70,
V110,
OtherValue(u32),
}
impl From<u32> for HeaderVersion {
#[allow(clippy::inconsistent_digit_grouping)]
fn from(v: u32) -> Self {
match v {
93_08_03 => Self::V41,
1996_03_07 => Self::V50,
1997_06_06 => Self::V60,
1999_09_03 => Self::V70,
2009_12_01 => Self::V110,
_ => Self::OtherValue(v),
}
}
}
/// A DBI header -- `NewDBIHdr`, really -- parsed from a stream.
///
/// Reference:
/// <https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.h#L124>
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)] // reason = "unused fields added for completeness"
pub(crate) struct DBIHeader {
pub signature: u32,
pub version: HeaderVersion,
pub age: u32,
pub gs_symbols_stream: StreamIndex,
/*
https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.h#L143-L155:
union {
struct {
USHORT usVerPdbDllMin : 8; // minor version and
USHORT usVerPdbDllMaj : 7; // major version and
USHORT fNewVerFmt : 1; // flag telling us we have rbld stored elsewhere (high bit of original major version)
} vernew; // that built this pdb last.
struct {
USHORT usVerPdbDllRbld: 4;
USHORT usVerPdbDllMin : 7;
USHORT usVerPdbDllMaj : 5;
} verold;
USHORT usVerAll;
};
*/
pub internal_version: u16,
pub ps_symbols_stream: StreamIndex,
// "build version of the pdb dll that built this pdb last."
pub pdb_dll_build_version: u16,
pub symbol_records_stream: StreamIndex,
// "rbld version of the pdb dll that built this pdb last."
pub pdb_dll_rbld_version: u16,
pub module_list_size: u32,
pub section_contribution_size: u32,
pub section_map_size: u32,
pub file_info_size: u32,
// "size of the Type Server Map substream"
pub type_server_map_size: u32,
// "index of MFC type server"
pub mfc_type_server_index: u32,
// "size of optional DbgHdr info appended to the end of the stream"
pub debug_header_size: u32,
// "number of bytes in EC substream, or 0 if EC no EC enabled Mods"
pub ec_substream_size: u32,
/*
https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.h#L187-L192:
USHORT fIncLink:1; // true if linked incrmentally (really just if ilink thunks are present)
USHORT fStripped:1; // true if PDB::CopyTo stripped the private data out
USHORT fCTypes:1; // true if this PDB is using CTypes.
USHORT unused:13; // reserved, must be 0.
*/
pub flags: u16,
pub machine_type: u16,
pub reserved: u32,
}
impl DBIHeader {
pub fn parse(stream: Stream<'_>) -> Result<Self> {
Self::parse_buf(&mut stream.parse_buffer())
}
fn parse_buf(buf: &mut ParseBuffer<'_>) -> Result<Self> {
let header = Self {
signature: buf.parse_u32()?,
version: From::from(buf.parse_u32()?),
age: buf.parse_u32()?,
gs_symbols_stream: buf.parse()?,
internal_version: buf.parse_u16()?,
ps_symbols_stream: buf.parse()?,
pdb_dll_build_version: buf.parse_u16()?,
symbol_records_stream: buf.parse()?,
pdb_dll_rbld_version: buf.parse_u16()?,
module_list_size: buf.parse_u32()?,
section_contribution_size: buf.parse_u32()?,
section_map_size: buf.parse_u32()?,
file_info_size: buf.parse_u32()?,
type_server_map_size: buf.parse_u32()?,
mfc_type_server_index: buf.parse_u32()?,
debug_header_size: buf.parse_u32()?,
ec_substream_size: buf.parse_u32()?,
flags: buf.parse_u16()?,
machine_type: buf.parse_u16()?,
reserved: buf.parse_u32()?,
};
if header.signature != u32::max_value() {
// this is likely a DBIHdr, not a NewDBIHdr
// it could be promoted:
// https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.cpp#L291-L313
// https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/langapi/include/pdb.h#L1180-L1184
// but that seems like a lot of work
return Err(Error::UnimplementedFeature("ancient DBI header"));
}
Ok(header)
}
}
/// The target machine's architecture.
/// Reference: <https://docs.microsoft.com/en-us/windows/desktop/debug/pe-format#machine-types>
#[non_exhaustive]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MachineType {
/// The contents of this field are assumed to be applicable to any machine type.
Unknown = 0x0,
/// Matsushita AM33
Am33 = 0x13,
/// x64
Amd64 = 0x8664,
/// ARM little endian
Arm = 0x1C0,
/// ARM64 little endian
Arm64 = 0xAA64,
/// ARM Thumb-2 little endian
ArmNT = 0x1C4,
/// EFI byte code
Ebc = 0xEBC,
/// Intel 386 or later processors and compatible processors
X86 = 0x14C,
/// Intel Itanium processor family
Ia64 = 0x200,
/// Mitsubishi M32R little endian
M32R = 0x9041,
/// MIPS16
Mips16 = 0x266,
/// MIPS with FPU
MipsFpu = 0x366,
/// MIPS16 with FPU
MipsFpu16 = 0x466,
/// Power PC little endian
PowerPC = 0x1F0,
/// Power PC with floating point support
PowerPCFP = 0x1F1,
/// MIPS little endian
R4000 = 0x166,
/// RISC-V 32-bit address space
RiscV32 = 0x5032,
/// RISC-V 64-bit address space
RiscV64 = 0x5064,
/// RISC-V 128-bit address space
RiscV128 = 0x5128,
/// Hitachi SH3
SH3 = 0x1A2,
/// Hitachi SH3 DSP
SH3DSP = 0x1A3,
/// Hitachi SH4
SH4 = 0x1A6,
/// Hitachi SH5
SH5 = 0x1A8,
/// Thumb
Thumb = 0x1C2,
/// MIPS little-endian WCE v2
WceMipsV2 = 0x169,
/// Invalid value
Invalid = 0xffff,
}
impl fmt::Display for MachineType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Invalid => write!(f, "Invalid"),
Self::Unknown => write!(f, "Unknown"),
Self::Am33 => write!(f, "Am33"),
Self::Amd64 => write!(f, "Amd64"),
Self::Arm => write!(f, "Arm"),
Self::Arm64 => write!(f, "Arm64"),
Self::ArmNT => write!(f, "ArmNT"),
Self::Ebc => write!(f, "Ebc"),
Self::X86 => write!(f, "X86"),
Self::Ia64 => write!(f, "Ia64"),
Self::M32R => write!(f, "M32R"),
Self::Mips16 => write!(f, "Mips16"),
Self::MipsFpu => write!(f, "MipsFpu"),
Self::MipsFpu16 => write!(f, "MipsFpu16"),
Self::PowerPC => write!(f, "PowerPC"),
Self::PowerPCFP => write!(f, "PowerPCFP"),
Self::R4000 => write!(f, "R4000"),
Self::RiscV32 => write!(f, "RiscV32"),
Self::RiscV64 => write!(f, "RiscV64"),
Self::RiscV128 => write!(f, "RiscV128"),
Self::SH3 => write!(f, "SH3"),
Self::SH3DSP => write!(f, "SH3DSP"),
Self::SH4 => write!(f, "SH4"),
Self::SH5 => write!(f, "SH5"),
Self::Thumb => write!(f, "Thumb"),
Self::WceMipsV2 => write!(f, "WceMipsV2"),
}
}
}
impl From<u16> for MachineType {
fn from(value: u16) -> Self {
match value {
0xffff => Self::Invalid,
0x0 => Self::Unknown,
0x13 => Self::Am33,
0x8664 => Self::Amd64,
0x1C0 => Self::Arm,
0xAA64 => Self::Arm64,
0x1C4 => Self::ArmNT,
0xEBC => Self::Ebc,
0x14C => Self::X86,
0x200 => Self::Ia64,
0x9041 => Self::M32R,
0x266 => Self::Mips16,
0x366 => Self::MipsFpu,
0x466 => Self::MipsFpu16,
0x1F0 => Self::PowerPC,
0x1F1 => Self::PowerPCFP,
0x166 => Self::R4000,
0x5032 => Self::RiscV32,
0x5064 => Self::RiscV64,
0x5128 => Self::RiscV128,
0x1A2 => Self::SH3,
0x1A3 => Self::SH3DSP,
0x1A6 => Self::SH4,
0x1A8 => Self::SH5,
0x1C2 => Self::Thumb,
0x169 => Self::WceMipsV2,
_ => Self::Unknown,
}
}
}
/// Information about a module's contribution to a section.
/// `struct SC` in Microsoft's code:
/// <https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/include/dbicommon.h#L42>
#[derive(Debug, Copy, Clone)]
pub struct DBISectionContribution {
/// Start offset of the section.
pub offset: PdbInternalSectionOffset,
/// The size of the contribution, in bytes.
pub size: u32,
/// The characteristics, which map to [`ImageSectionHeader::characteristics`] in binaries.
///
/// [`ImageSectionHeader::characteristics`]: crate::ImageSectionHeader::characteristics
pub characteristics: SectionCharacteristics,
/// Index of the module in [`DebugInformation::modules`] containing the actual symbol.
pub module: usize,
/// CRC of the contribution(?)
pub data_crc: u32,
/// CRC of relocations(?)
pub reloc_crc: u32,
}
impl DBISectionContribution {
fn parse(buf: &mut ParseBuffer<'_>) -> Result<Self> {
let section = buf.parse_u16()?;
let _padding = buf.parse_u16()?;
let offset = buf.parse_u32()?;
let size = buf.parse_u32()?;
let characteristics = buf.parse()?;
let module = buf.parse_u16()?.into();
let _padding = buf.parse_u16()?;
Ok(Self {
offset: PdbInternalSectionOffset { offset, section },
size,
characteristics,
module,
data_crc: buf.parse_u32()?,
reloc_crc: buf.parse_u32()?,
})
}
}
/// Information about a module parsed from the DBI stream.
///
/// Named `MODI` in the Microsoft PDB source:
/// <https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.h#L1197>
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)] // reason = "unused fields added for completeness"
pub(crate) struct DBIModuleInfo {
/// Currently open module.
pub opened: u32,
/// This module's first section contribution.
pub section: DBISectionContribution,
/// Flags, expressed as bitfields in the C struct:
/// written, EC enabled, unused, tsm
/// <https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.h#L1201-L1204>
pub flags: u16,
/// Stream number of module debug info (syms, lines, fpo).
pub stream: StreamIndex,
/// Size of local symbols debug info in `stream`.
pub symbols_size: u32,
/// Size of line number debug info in `stream`.
pub lines_size: u32,
/// Size of C13 style line number info in `stream`.
pub c13_lines_size: u32,
/// Number of files contributing to this module.
pub files: u16,
_padding: u16,
/// Used as a pointer into an array of filename indicies in the Microsoft code.
pub filename_offsets: u32,
/// Source file name index.
pub source: u32,
/// Path to compiler PDB name index.
pub compiler: u32,
}
impl DBIModuleInfo {
fn parse(buf: &mut ParseBuffer<'_>) -> Result<Self> {
Ok(Self {
opened: buf.parse_u32()?,
section: DBISectionContribution::parse(buf)?,
flags: buf.parse_u16()?,
stream: buf.parse()?,
symbols_size: buf.parse_u32()?,
lines_size: buf.parse_u32()?,
c13_lines_size: buf.parse_u32()?,
files: buf.parse_u16()?,
_padding: buf.parse_u16()?,
filename_offsets: buf.parse_u32()?,
source: buf.parse_u32()?,
compiler: buf.parse_u32()?,
})
}
}
/// Represents a module from the DBI stream.
///
/// A `Module` is a single item that contributes to the binary, such as an object file or import
/// library.
///
/// Much of the useful information for a `Module` is stored in a separate stream in the PDB. It can
/// be retrieved by calling [`PDB::module_info`](crate::PDB::module_info) with a specific module.
#[derive(Debug, Clone)]
pub struct Module<'m> {
info: DBIModuleInfo,
module_name: RawString<'m>,
object_file_name: RawString<'m>,
}
impl<'m> Module<'m> {
/// The `DBIModuleInfo` from the module info substream in the DBI stream.
pub(crate) fn info(&self) -> &DBIModuleInfo {
&self.info
}
/// The module name.
///
/// Usually either a full path to an object file or a string of the form `Import:<dll name>`.
pub fn module_name(&self) -> Cow<'m, str> {
self.module_name.to_string()
}
/// The object file name.
///
/// May be the same as `module_name` for object files passed directly
/// to the linker. For modules from static libraries, this is usually
/// the full path to the archive.
pub fn object_file_name(&self) -> Cow<'m, str> {
self.object_file_name.to_string()
}
}
/// A `ModuleIter` iterates over the modules in the DBI section, producing `Module`s.
#[derive(Debug)]
pub struct ModuleIter<'m> {
buf: ParseBuffer<'m>,
}
impl<'m> FallibleIterator for ModuleIter<'m> {
type Item = Module<'m>;
type Error = Error;
fn next(&mut self) -> result::Result<Option<Self::Item>, Self::Error> {
// see if we're at EOF
if self.buf.is_empty() {
return Ok(None);
}
let info = DBIModuleInfo::parse(&mut self.buf)?;
let module_name = self.buf.parse_cstring()?;
let object_file_name = self.buf.parse_cstring()?;
self.buf.align(4)?;
Ok(Some(Module {
info,
module_name,
object_file_name,
}))
}
}
/// The version of the section contribution stream.
#[derive(Debug, Copy, Clone, PartialEq)]
#[allow(missing_docs)]
enum DBISectionContributionStreamVersion {
V60,
V2,
OtherValue(u32),
}
impl From<u32> for DBISectionContributionStreamVersion {
fn from(v: u32) -> Self {
const V60: u32 = 0xeffe_0000 + 19_970_605;
const V2: u32 = 0xeffe_0000 + 20_140_516;
match v {
V60 => Self::V60,
V2 => Self::V2,
_ => Self::OtherValue(v),
}
}
}
/// A `DBISectionContributionIter` iterates over the section contributions in the DBI section, producing `DBISectionContribution`s.
#[derive(Debug)]
pub struct DBISectionContributionIter<'c> {
buf: ParseBuffer<'c>,
version: DBISectionContributionStreamVersion,
}
impl<'c> DBISectionContributionIter<'c> {
fn parse(mut buf: ParseBuffer<'c>) -> Result<Self> {
let version = buf.parse_u32()?.into();
Ok(Self { buf, version })
}
}
impl<'c> FallibleIterator for DBISectionContributionIter<'c> {
type Item = DBISectionContribution;
type Error = Error;
fn next(&mut self) -> result::Result<Option<Self::Item>, Self::Error> {
// see if we're at EOF
if self.buf.is_empty() {
return Ok(None);
}
let contribution = DBISectionContribution::parse(&mut self.buf)?;
if self.version == DBISectionContributionStreamVersion::V2 {
self.buf.parse_u32()?;
}
Ok(Some(contribution))
}
}
/// A `DbgDataHdr`, which contains a series of (optional) MSF stream numbers.
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)] // reason = "unused fields added for completeness"
pub(crate) struct DBIExtraStreams {
// The struct itself is defined at:
// https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/PDB/dbi/dbi.h#L250-L274
// It's just an array of stream numbers; `u16`s where 0xffff means "no stream".
//
// The array indices are:
// https://github.com/Microsoft/microsoft-pdb/blob/082c5290e5aff028ae84e43affa8be717aa7af73/langapi/include/pdb.h#L439-L449
// We'll map those to fields.
//
// The struct itself can be truncated. This is an internal struct; we'll treat missing fields as
// StreamIndex::none() even if it's a short read, so long as the short read stops on a u16 boundary.
pub fpo: StreamIndex,
pub exception: StreamIndex,
pub fixup: StreamIndex,
pub omap_to_src: StreamIndex,
pub omap_from_src: StreamIndex,
pub section_headers: StreamIndex,
pub token_rid_map: StreamIndex,
pub xdata: StreamIndex,
pub pdata: StreamIndex,
pub framedata: StreamIndex,
pub original_section_headers: StreamIndex,
}
impl DBIExtraStreams {
pub(crate) fn new(debug_info: &DebugInformation<'_>) -> Result<Self> {
// calculate the location of the extra stream information
let header = debug_info.header;
let offset = debug_info.header_len
+ (header.module_list_size
+ header.section_contribution_size
+ header.section_map_size
+ header.file_info_size
+ header.type_server_map_size
+ header.ec_substream_size) as usize;
// seek
let mut buf = debug_info.stream.parse_buffer();
buf.take(offset)?;
// grab that section as bytes
let bytes = buf.take(header.debug_header_size as _)?;
// parse those bytes
let mut extra_streams_buf = ParseBuffer::from(bytes);
Self::parse(&mut extra_streams_buf)
}
pub(crate) fn parse(buf: &mut ParseBuffer<'_>) -> Result<Self> {
// short reads are okay, as are long reads -- this struct is actually an array
// what's _not_ okay are
if buf.len() % 2 != 0 {
return Err(Error::InvalidStreamLength("DbgDataHdr"));
}
fn next_index(buf: &mut ParseBuffer<'_>) -> Result<StreamIndex> {
if buf.is_empty() {
Ok(StreamIndex::none())
} else {
buf.parse()
}
}
Ok(Self {
fpo: next_index(buf)?,
exception: next_index(buf)?,
fixup: next_index(buf)?,
omap_to_src: next_index(buf)?,
omap_from_src: next_index(buf)?,
section_headers: next_index(buf)?,
token_rid_map: next_index(buf)?,
xdata: next_index(buf)?,
pdata: next_index(buf)?,
framedata: next_index(buf)?,
original_section_headers: next_index(buf)?,
})
}
}
#[cfg(test)]
mod tests {
use crate::dbi::*;
#[test]
fn test_dbi_extra_streams() {
let bytes = vec![0xff, 0xff, 0x01, 0x02, 0x03, 0x04, 0xff, 0xff, 0x05, 0x06];
let mut buf = ParseBuffer::from(bytes.as_slice());
let extra_streams = DBIExtraStreams::parse(&mut buf).expect("parse");
// check readback
assert_eq!(extra_streams.fpo, StreamIndex::none());
assert_eq!(extra_streams.exception, StreamIndex(0x0201));
assert_eq!(extra_streams.fixup, StreamIndex(0x0403));
assert_eq!(extra_streams.omap_to_src, StreamIndex::none());
assert_eq!(extra_streams.omap_from_src, StreamIndex(0x0605));
// check that short reads => StreamIndex::none()
assert_eq!(extra_streams.section_headers, StreamIndex::none());
assert_eq!(extra_streams.token_rid_map, StreamIndex::none());
assert_eq!(extra_streams.original_section_headers, StreamIndex::none());
}
}
|
use std::cmp::Ordering;
use std::io::{self, BufRead};
use std::{env, error, fmt, fs, path, result};
#[derive(fmt::Debug)]
struct Error {
message: String,
}
impl Error {
fn new(message: String) -> Error {
Error { message }
}
}
type Result<T> = result::Result<T, Error>;
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.message)
}
}
impl error::Error for Error {}
impl From<io::Error> for Error {
fn from(e: io::Error) -> Self {
Error::new(format!("io error:{}", e))
}
}
#[derive(Eq, PartialEq)]
struct Seat {
id: u32,
code: String,
}
fn to_id(code: &str) -> Result<u32> {
code.chars().enumerate().fold(Ok(0u32), |acc, (i, c)| {
acc.and_then(|id| {
let mask = 1u32 << (9 - i);
match c {
'F' | 'L' => Ok(id),
'B' | 'R' => Ok(id | mask),
_ => Err(Error::new(format!("{} is an illegal character", c))),
}
})
})
}
impl Seat {
fn new_for_code(code: String) -> Result<Seat> {
let i = to_id(&code)?;
match i {
id if id <= 1023 => Ok(Seat {
id,
code,
}),
id => Err(Error::new(format!("id {} is too high", id))),
}
}
}
impl PartialOrd for Seat {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.id.partial_cmp(&other.id)
}
}
impl Ord for Seat {
fn cmp(&self, other: &Self) -> Ordering {
self.id.cmp(&other.id)
}
}
fn read_lines<P: AsRef<path::Path>>(filename: P) -> io::Result<io::Lines<io::BufReader<fs::File>>> {
let file = fs::File::open(filename)?;
Ok(io::BufReader::new(file).lines())
}
fn read_seats(filename: &str) -> Result<Vec<Seat>> {
read_lines(filename)?
.map(|res| match res {
Ok(code) => Seat::new_for_code(code),
Err(e) => Err(Error::new(format!("bad line: {}", e))),
})
.fold(Ok(Vec::new()), |acc, res| {
acc.and_then(|mut v| {
res.map(|seat| {
v.push(seat);
v
})
})
})
}
fn main() -> Result<()> {
let args = env::args().collect::<Vec<String>>();
if args.len() > 1 {
let mut seats = read_seats(&args[1])?;
seats.sort();
let lowest = seats.first().unwrap().id;
let highest = seats.last().unwrap().id;
let mine = (lowest..=highest)
.find(|id| seats[(id - lowest) as usize].id != *id)
.unwrap();
println!("The lowest seat id is {}", lowest);
println!("The highest seat id is {}", highest);
println!("My seat id is {}", mine);
Ok(())
} else {
panic!("{}", Error::new("filename argument required".to_string()));
}
}
#[cfg(test)]
mod tests {
use super::*;
macro_rules! test_seat_from_code {
($code:literal, $row:literal, $column:literal, $id:literal) => {
let seat = Seat::new_for_code($code.to_string())?;
assert_eq!($id, seat.id, "wrong id");
};
}
#[test]
fn converts_code_to_the_correct_seat() -> Result<()> {
// max seat
test_seat_from_code!("BBBBBBBRRR", 127, 7, 1023);
// min seat
test_seat_from_code!("FFFFFFFLLL", 0, 0, 0);
// seats from question
test_seat_from_code!("FBFBBFFRLR", 44, 5, 357);
test_seat_from_code!("BFFFBBFRRR", 70, 7, 567);
test_seat_from_code!("FFFBBBFRRR", 14, 7, 119);
test_seat_from_code!("BBFFBBFRLL", 102, 4, 820);
Ok(())
}
}
|
//! an infrastructure library for 'cargo-pack'ers.
//! This crate provides only common features of `pack`ers, currently, files to package.
//! Currently, you can write these metadata in Cargo.toml:
//!
//! ```toml
//! [package.metadata.pack]
//! # Not used for now. Reserved for future use
//! default-packers = ["docker"]
//! # files to pack in addition to binaries
//! files = ["README.md"]
//! ```
#![deny(missing_docs)]
use cargo_metadata::{Metadata, MetadataCommand, Package};
use failure::format_err;
use log::debug;
use serde::de::DeserializeOwned;
use serde::Deserialize;
use serde_json::Value;
/// Errors and related
pub mod error {
/// result type for the cargo-pack
pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
}
use crate::error::*;
/// Rust side of configurations in `Cargo.toml`
///
/// Cargo.toml will look like
///
/// ```toml
/// [package.metadata.pack]
/// default-packers = ["docker"]
/// files = ["README.md"]
/// ```
#[derive(Deserialize, Debug)]
#[serde(rename_all = "kebab-case")]
pub struct PackConfig {
/// files to pack into other than binaries
pub files: Option<Vec<String>>,
/// reserved for future usage.
pub default_packers: Option<Vec<String>>,
}
/// cargo-pack API
pub struct CargoPack {
package_name: Option<String>,
pack_config: PackConfig,
metadata: Metadata,
}
fn lookup(mut value: Value, path: &[&str]) -> Option<Value> {
for key in path {
match value {
Value::Object(mut hm) => match hm.remove(*key) {
// removing to take the ownership
Some(v) => value = v,
None => return None,
},
Value::Array(mut v) => match key.parse::<usize>().ok() {
// NOTICE: may change the index
Some(idx) if idx < v.len() => value = v.remove(idx),
_ => return None,
},
_ => return None,
}
}
Some(value)
}
impl CargoPack {
/// create a new CargoPack value
///
/// ```ignore
/// let config = Config::default().unwrap();
/// let pack = CargoPack::new(&config, None);
/// ```
pub fn new<P: Into<Option<String>>>(package_name: P) -> Result<Self> {
let package_name = package_name.into();
let metadata = MetadataCommand::new().no_deps().exec()?;
let pack_config: PackConfig = Self::decode_from_manifest_static(
&metadata,
package_name.as_ref().map(|s| s.as_ref()),
)?;
debug!("config: {:?}", pack_config);
Ok(CargoPack {
pack_config,
package_name,
metadata,
})
}
/// returns the Metadata value
pub fn metadata(&self) -> &Metadata {
&self.metadata
}
/// returns the PackConfig value
pub fn config(&self) -> &PackConfig {
&self.pack_config
}
/// returns the `Package` value of `package_name`
pub fn package(&self) -> Result<&Package> {
Self::find_package(
self.metadata(),
self.package_name.as_ref().map(AsRef::as_ref),
)
}
fn find_package<'a, 'b>(
metadata: &'a Metadata,
package_name: Option<&'b str>,
) -> Result<&'a Package> {
if let Some(ref name) = package_name {
let packages = metadata
.packages
.iter()
.filter(|p| &p.name == name)
.collect::<Vec<_>>();
match packages.len() {
0 => return Err(format_err!("unknown package {}", name)),
1 => Ok(packages[0]),
_ => return Err(format_err!("ambiguous name {}", name)),
}
} else {
match metadata.packages.len() {
1 => Ok(&metadata.packages[0]),
_ => return Err(format_err!("virtual hogehoge")),
}
}
}
fn decode_from_manifest_static<T: DeserializeOwned>(
metadata: &Metadata,
package_name: Option<&str>,
) -> Result<T> {
let package = Self::find_package(metadata, package_name)?;
debug!("package: {:?}", package);
let data = lookup(package.metadata.clone(), &["pack"])
.expect("no package.metadata.pack found in Cargo.toml");
serde_json::from_value(data).map_err(Into::into)
}
/// decode a value from the manifest toml file.
pub fn decode_from_manifest<'a, T: DeserializeOwned>(&self) -> Result<T> {
let package_name = self.package_name.as_ref().map(|s| s.as_ref());
Self::decode_from_manifest_static(self.metadata(), package_name)
}
/// returns files defined in `package.metadata.pack.files` in the Cargo.toml.
pub fn files(&self) -> &[String] {
self.pack_config
.files
.as_ref()
.map(AsRef::as_ref)
.unwrap_or(&[])
}
}
|
#![allow(non_camel_case_types)]
#![allow(non_upper_case_globals)]
#![allow(non_snake_case)]
use cuda::ffi::driver_types::{cudaStream_t};
include!(concat!(env!("OUT_DIR"), "/nccl_bind.rs"));
|
//! Entities related to and within guilds.
pub mod emoji;
pub mod member;
pub mod role;
pub use self::{
emoji::{EmojiEntity, EmojiRepository},
member::{MemberEntity, MemberRepository},
role::{RoleEntity, RoleRepository},
};
use super::{
channel::{GuildChannelEntity, TextChannelEntity, VoiceChannelEntity},
gateway::PresenceEntity,
user::UserEntity,
voice::VoiceStateEntity,
};
use crate::{
repository::{GetEntityFuture, ListEntitiesFuture, ListEntityIdsFuture, Repository},
utils, Backend, Entity,
};
use twilight_model::{
guild::{
DefaultMessageNotificationLevel, ExplicitContentFilter, Guild, MfaLevel, PartialGuild,
Permissions, PremiumTier, SystemChannelFlags, VerificationLevel,
},
id::{ApplicationId, ChannelId, EmojiId, GuildId, RoleId, UserId},
};
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GuildEntity {
pub afk_channel_id: Option<ChannelId>,
pub afk_timeout: u64,
pub application_id: Option<ApplicationId>,
pub approximate_member_count: Option<u64>,
pub approximate_presence_count: Option<u64>,
pub banner: Option<String>,
pub default_message_notifications: DefaultMessageNotificationLevel,
pub description: Option<String>,
pub discovery_splash: Option<String>,
pub explicit_content_filter: ExplicitContentFilter,
pub features: Vec<String>,
pub icon: Option<String>,
pub id: GuildId,
pub joined_at: Option<String>,
#[cfg_attr(feature = "serde", serde(default))]
pub large: bool,
// Not documented so I marked it as optional.
pub lazy: Option<bool>,
pub max_members: Option<u64>,
pub max_presences: Option<u64>,
pub max_video_channel_users: Option<u64>,
pub member_count: Option<u64>,
pub mfa_level: MfaLevel,
pub name: String,
pub owner_id: UserId,
pub owner: Option<bool>,
pub permissions: Option<Permissions>,
pub preferred_locale: String,
pub premium_subscription_count: Option<u64>,
#[cfg_attr(feature = "serde", serde(default))]
pub premium_tier: PremiumTier,
pub region: String,
pub rules_channel_id: Option<ChannelId>,
pub splash: Option<String>,
pub system_channel_flags: SystemChannelFlags,
pub system_channel_id: Option<ChannelId>,
#[cfg_attr(feature = "serde", serde(default))]
pub unavailable: bool,
pub vanity_url_code: Option<String>,
pub verification_level: VerificationLevel,
pub widget_channel_id: Option<ChannelId>,
pub widget_enabled: Option<bool>,
}
impl From<Guild> for GuildEntity {
fn from(guild: Guild) -> Self {
Self {
afk_channel_id: guild.afk_channel_id,
afk_timeout: guild.afk_timeout,
application_id: guild.application_id,
approximate_member_count: guild.approximate_member_count,
approximate_presence_count: guild.approximate_presence_count,
banner: guild.banner,
default_message_notifications: guild.default_message_notifications,
description: guild.description,
discovery_splash: guild.discovery_splash,
explicit_content_filter: guild.explicit_content_filter,
features: guild.features,
icon: guild.icon,
id: guild.id,
joined_at: guild.joined_at,
large: guild.large,
lazy: guild.lazy,
max_members: guild.max_members,
max_presences: guild.max_presences,
max_video_channel_users: guild.max_video_channel_users,
member_count: guild.member_count,
mfa_level: guild.mfa_level,
name: guild.name,
owner_id: guild.owner_id,
owner: guild.owner,
permissions: guild.permissions,
preferred_locale: guild.preferred_locale,
premium_subscription_count: guild.premium_subscription_count,
premium_tier: guild.premium_tier,
region: guild.region,
rules_channel_id: guild.rules_channel_id,
splash: guild.splash,
system_channel_flags: guild.system_channel_flags,
system_channel_id: guild.system_channel_id,
unavailable: guild.unavailable,
vanity_url_code: guild.vanity_url_code,
verification_level: guild.verification_level,
widget_channel_id: guild.widget_channel_id,
widget_enabled: guild.widget_enabled,
}
}
}
impl GuildEntity {
pub fn update(self, update: PartialGuild) -> Self {
Self {
afk_channel_id: update.afk_channel_id.or(self.afk_channel_id),
afk_timeout: update.afk_timeout,
application_id: update.application_id.or(self.application_id),
banner: update.banner.or(self.banner),
default_message_notifications: update.default_message_notifications,
description: update.description.or(self.description),
discovery_splash: update.discovery_splash.or(self.discovery_splash),
explicit_content_filter: update.explicit_content_filter,
features: update.features,
icon: update.icon.or(self.icon),
id: update.id,
max_members: update.max_members.or(self.max_members),
max_presences: update.max_presences.or(self.max_presences),
member_count: update.member_count.or(self.member_count),
mfa_level: update.mfa_level,
name: update.name,
owner_id: update.owner_id,
owner: update.owner.or(self.owner),
permissions: update.permissions.or(self.permissions),
preferred_locale: update.preferred_locale,
premium_subscription_count: update
.premium_subscription_count
.or(self.premium_subscription_count),
premium_tier: update.premium_tier,
region: update.region,
rules_channel_id: update.rules_channel_id.or(self.rules_channel_id),
splash: update.splash.or(self.splash),
system_channel_flags: update.system_channel_flags,
system_channel_id: update.system_channel_id.or(self.system_channel_id),
vanity_url_code: update.vanity_url_code.or(self.vanity_url_code),
verification_level: update.verification_level,
widget_channel_id: update.widget_channel_id.or(self.widget_channel_id),
widget_enabled: update.widget_enabled.or(self.widget_enabled),
..self
}
}
}
impl Entity for GuildEntity {
type Id = GuildId;
/// Return the guild's ID.
fn id(&self) -> Self::Id {
self.id
}
}
/// Repository to work with guilds and their associated entities.
pub trait GuildRepository<B: Backend>: Repository<GuildEntity, B> {
/// Retrieve the AFK voice channel associated with a guild.
///
/// Backend implementations should return `None` if the AFK channel isn't
/// configured (meaning [`GuildEntity::afk_channel_id`] is `None`) or is not
/// present in the cache.
///
/// [`GuildEntity::afk_channel_id`]: struct.GuildEntity.html#structfield.afk_channel_id
fn afk_channel(&self, guild_id: GuildId) -> GetEntityFuture<'_, VoiceChannelEntity, B::Error> {
utils::relation_and_then(
self.backend().guilds(),
self.backend().voice_channels(),
guild_id,
|guild| guild.afk_channel_id,
)
}
/// Retrieve a stream of channel IDs within a guild.
fn channel_ids(&self, guild_id: GuildId) -> ListEntityIdsFuture<'_, ChannelId, B::Error>;
/// Retrieve a stream of channels within a guild.
fn channels(&self, guild_id: GuildId) -> ListEntitiesFuture<'_, GuildChannelEntity, B::Error>;
/// Retrieve a stream of emoji IDs within a guild.
fn emoji_ids(&self, guild_id: GuildId) -> ListEntityIdsFuture<'_, EmojiId, B::Error>;
/// Retrieve a stream of emojis within a guild.
fn emojis(&self, guild_id: GuildId) -> ListEntitiesFuture<'_, EmojiEntity, B::Error> {
utils::stream_ids(self.emoji_ids(guild_id), self.backend().emojis())
}
/// Retrieve a stream of member IDs within a guild.
fn member_ids(&self, guild_id: GuildId) -> ListEntityIdsFuture<'_, UserId, B::Error>;
/// Retrieve a stream of members within a guild.
fn members(&self, guild_id: GuildId) -> ListEntitiesFuture<'_, MemberEntity, B::Error>;
/// Retrieve the owner associated with a guild.
///
/// Backend implementations should return `None` if the user is not in the
/// cache.
fn owner(&self, guild_id: GuildId) -> GetEntityFuture<'_, UserEntity, B::Error> {
utils::relation_map(
self.backend().guilds(),
self.backend().users(),
guild_id,
|guild| guild.owner_id,
)
}
/// Retrieve a stream of user IDs of presences within a guild.
fn presence_ids(&self, guild_id: GuildId) -> ListEntityIdsFuture<'_, UserId, B::Error>;
/// Retrieve a stream of presences within a guild.
fn presences(&self, guild_id: GuildId) -> ListEntitiesFuture<'_, PresenceEntity, B::Error>;
/// Retrieve a stream of role IDs within a guild.
fn role_ids(&self, guild_id: GuildId) -> ListEntityIdsFuture<'_, RoleId, B::Error>;
/// Retrieve a stream of roles within a guild.
fn roles(&self, guild_id: GuildId) -> ListEntitiesFuture<'_, RoleEntity, B::Error> {
utils::stream_ids(self.role_ids(guild_id), self.backend().roles())
}
/// Retrieve the rules channel associated with a guild.
///
/// Backend implementations should return `None` if the rules channel isn't
/// configured (meaning [`GuildEntity::rules_channel_id`] is `None`) or is
/// not present in the cache.
///
/// [`GuildEntity::rules_channel_id`]: struct.GuildEntity.html#structfield.rules_channel_id
fn rules_channel(&self, guild_id: GuildId) -> GetEntityFuture<'_, TextChannelEntity, B::Error> {
utils::relation_and_then(
self.backend().guilds(),
self.backend().text_channels(),
guild_id,
|guild| guild.rules_channel_id,
)
}
/// Retrieve the system channel associated with a guild.
///
/// Backend implementations should return `None` if the system channel isn't
/// configured (meaning [`GuildEntity::system_channel_id`] is `None`) or is
/// not present in the cache.
///
/// [`GuildEntity::system_channel_id`]: struct.GuildEntity.html#structfield.system_channel_id
fn system_channel(
&self,
guild_id: GuildId,
) -> GetEntityFuture<'_, TextChannelEntity, B::Error> {
utils::relation_and_then(
self.backend().guilds(),
self.backend().text_channels(),
guild_id,
|guild| guild.system_channel_id,
)
}
/// Retrieve a stream of voice states' user IDs within a guild.
fn voice_state_ids(&self, guild_id: GuildId) -> ListEntityIdsFuture<'_, UserId, B::Error>;
/// Retrieve a stream of voice states within a guild.
fn voice_states(&self, guild_id: GuildId)
-> ListEntitiesFuture<'_, VoiceStateEntity, B::Error>;
/// Retrieve the widget channel associated with a guild.
///
/// Backend implementations should return `None` if the widget channel isn't
/// configured (meaning [`GuildEntity::widget_channel_id`] is `None`) or is
/// not present in the cache.
///
/// [`GuildEntity::widget_channel_id`]: struct.GuildEntity.html#structfield.widget_channel_id
fn widget_channel(
&self,
guild_id: GuildId,
) -> GetEntityFuture<'_, GuildChannelEntity, B::Error> {
let backend = self.backend();
Box::pin(async move {
let guilds = backend.guilds();
let channel_id = match guilds
.get(guild_id)
.await?
.and_then(|g| g.widget_channel_id)
{
Some(channel_id) => channel_id,
None => return Ok(None),
};
let text_channels = backend.text_channels();
if let Some(channel) = text_channels.get(channel_id).await? {
return Ok(Some(GuildChannelEntity::Text(channel)));
}
let voice_channels = backend.voice_channels();
if let Some(channel) = voice_channels.get(channel_id).await? {
return Ok(Some(GuildChannelEntity::Voice(channel)));
}
let category_channels = backend.category_channels();
if let Some(channel) = category_channels.get(channel_id).await? {
return Ok(Some(GuildChannelEntity::Category(channel)));
}
Ok(None)
})
}
}
|
extern crate rusty_machine;
use rusty_machine::linalg::{Matrix,Vector};
use rusty_machine::learning::gp::{GaussianProcess,ConstMean};
use rusty_machine::learning::toolkit::kernel;
use rusty_machine::learning::SupModel;
fn main() {
let inputs = Matrix::new(3,3,vec![1.1,1.2,1.3,2.1,2.2,2.3,3.1,3.2,3.3]);
let targets = Vector::new(vec![0.1,0.8,0.3]);
let test_inputs = Matrix::new(2,3, vec![1.2,1.3,1.4,2.2,2.3,2.4]);
let ker = kernel::SquaredExp::new(2., 1.);
let zero_mean = ConstMean::default();
let mut gp = GaussianProcess::new(ker, zero_mean, 0.5);
gp.train(&inputs, &targets).unwrap();
let _ = gp.predict(&test_inputs).unwrap();
}
|
use std::marker::PhantomData;
use std::ptr;
use std::sync::Arc;
#[derive(Debug)]
struct Node<T> {
data: T,
next: Option<Arc<Node<T>>>,
}
#[derive(Debug)]
pub struct ArcList<T> {
inner: Option<Arc<Node<T>>>,
}
impl<T> ArcList<T> {
pub fn new() -> Self {
Self { inner: None }
}
pub fn insert(self, data: T) -> Self {
Self {
inner: Some(Arc::new(Node {
data,
next: self.inner,
})),
}
}
pub fn iter<'s>(&'s self) -> ArcListIter<'s, T> {
ArcListIter {
inner: self
.inner
.as_ref()
.map(|inner| &**inner as *const _)
.unwrap_or(ptr::null()),
_marker: PhantomData,
}
}
}
impl<T> Clone for ArcList<T> {
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
}
}
}
pub struct ArcListIter<'s, T> {
inner: *const Node<T>,
_marker: PhantomData<&'s T>,
}
impl<'s, T> Iterator for ArcListIter<'s, T> {
type Item = &'s T;
fn next(&mut self) -> Option<Self::Item> {
let inner = unsafe { self.inner.as_ref()? };
self.inner = inner
.next
.as_ref()
.map(|inner| &**inner as *const _)
.unwrap_or(ptr::null());
Some(&inner.data)
}
}
|
mod config;
mod db;
mod entities;
mod lang_cmd;
mod models;
mod repository;
mod task;
mod utils;
use anyhow::Result;
use bollard::API_DEFAULT_VERSION;
use config::ENV_CONFIG;
use core::time::Duration;
use futures::future::join_all;
use std::sync::Arc;
// TODO(magurotuna): ここの値も要検討
const JOB_THREADS: usize = 3;
const HTTP_TIMEOUT: u64 = 180;
// TODO(magurotuna): スレッド数指定を柔軟に行うため、Tokio の RuntimeBuilder を使うよう書き換える
#[tokio::main(worker_threads = 4)]
async fn main() -> Result<()> {
let db_conn = Arc::new(db::new_pool(&ENV_CONFIG.database_url).await?);
/*
let docker_conn = Arc::new(bollard::Docker::connect_with_http(
&ENV_CONFIG.docker_address,
4,
API_DEFAULT_VERSION,
)?);
*/
let docker_conn = Arc::new(bollard::Docker::connect_with_unix(
"/var/run/docker.sock",
10,
API_DEFAULT_VERSION,
)?);
let http_client = reqwest::Client::builder()
.timeout(Duration::new(HTTP_TIMEOUT, 0))
.build()?;
let mut handles = Vec::new();
for _ in 0..JOB_THREADS {
let handle = tokio::spawn(task::gen_job(
db_conn.clone(),
docker_conn.clone(),
http_client.clone(),
));
handles.push(handle);
}
join_all(handles).await;
Ok(())
}
|
use serde::Deserialize;
use std::{
cmp,
convert::{TryFrom, TryInto},
time,
};
use crate::{core::MAX_CONNS, endpoints::State, verify, Error, Info, Random, Result};
pub(crate) const MAX_ELAPSED_WINDOW: usize = 32;
pub(crate) const MAX_ELAPSED: time::Duration = time::Duration::from_secs(3600 * 24);
macro_rules! make_url {
("info", $ep:expr) => {
$ep.to_string() + "/info"
};
("public", $ep:expr) => {
$ep.to_string() + "/public/latest"
};
("public", $ep:expr, $r:expr) => {
$ep.to_string() + "/public/" + &($r.to_string())
};
}
macro_rules! async_get {
($client:ident, $url:expr) => {{
let start = time::Instant::now();
let res = $client.get($url.as_str()).send().await;
(res, start.elapsed())
}};
}
macro_rules! add_elapsed {
($this:ident, $res:expr, $elapsed:expr) => {{
match $res {
Ok(val) => {
$this.add_elapsed($elapsed);
Ok(val)
}
err @ Err(_) => {
let elapsed = cmp::min($this.to_elapsed() * 2, MAX_ELAPSED);
$this.add_elapsed(elapsed);
err
}
}
}};
}
#[derive(Clone)]
pub(crate) enum Http {
DrandApi(Vec<time::Duration>),
}
impl Http {
pub(crate) fn new_drand_api() -> Http {
Http::DrandApi(Vec::default())
}
pub(crate) fn to_elapsed(&self) -> time::Duration {
let es = match self {
Http::DrandApi(es) => es,
};
match es.len() {
0 => time::Duration::from_secs(u64::MAX),
n => {
let sum: time::Duration = es.iter().sum();
sum / (n as u32)
}
}
}
fn to_base_url(&self) -> String {
match self {
Http::DrandApi(_) => "https://api.drand.sh".to_string(),
}
}
fn add_elapsed(&mut self, elapsed: time::Duration) {
let es = match self {
Http::DrandApi(es) => es,
};
match es.len() {
n if n >= MAX_ELAPSED_WINDOW => {
es.remove(0);
}
_ => (),
};
es.push(elapsed);
}
pub(crate) async fn boot_phase1(
&mut self,
rot: Option<&[u8]>,
agent: Option<reqwest::header::HeaderValue>,
) -> Result<(Info, Random)> {
let endpoint = self.to_base_url();
let client = new_http_client(MAX_CONNS, agent.clone())?;
// get info
let info: Info = {
let (res, elapsed) = {
let url = make_url!("info", endpoint);
async_get!(client, url)
};
let resp = err_at!(IOError, add_elapsed!(self, res, elapsed))?;
let info: InfoJson = err_at!(JsonParse, resp.json().await)?;
info.try_into()?
};
// confirm whether root-of-trust is as expected.
match rot {
Some(rot) if rot != info.hash => {
let msg = format!("not expected drand-group");
err_at!(NotSecure, msg: msg)?
}
_ => (),
}
// get latest round
let latest = self.do_get(&client, None).await?;
Ok((info, latest))
}
pub(crate) async fn boot_phase2(
&mut self,
mut state: State,
latest: Random,
agent: Option<reqwest::header::HeaderValue>,
) -> Result<State> {
let client = new_http_client(MAX_CONNS, agent.clone())?;
// get check_point
state.check_point = match (state.determinism, state.check_point.take()) {
// reestablish-determinism
(true, None) => {
let r = self.do_get(&client, Some(1)).await?;
Some(self.verify(&state, r, latest, agent.clone()).await?)
}
// continued-determinism
(true, Some(check_point)) => {
let check_point = {
let (from, till) = (check_point, latest);
self.verify(&state, from, till, agent.clone()).await?
};
Some(check_point)
}
// assumed-determinism
(false, _) if state.secure => Some(latest),
// no-determinism
(false, _) => None,
};
Ok(state)
}
pub(crate) async fn get(
&mut self,
mut state: State,
round: Option<u128>,
agent: Option<reqwest::header::HeaderValue>,
) -> Result<(State, Random)> {
let client = new_http_client(MAX_CONNS, agent.clone())?;
let r = self.do_get(&client, round).await?;
let (check_point, r) = match (state.check_point.take(), round) {
// just return an earlier random-ness.
(Some(check_point), Some(round)) if round <= check_point.round => {
// TODO: with cache we can optimize this call
(check_point, r)
}
// return a verified randomness, requested round
(Some(check_point), Some(_)) if state.secure => {
let r = self.verify(&state, check_point, r, agent.clone()).await?;
(r.clone(), r)
}
// return insecure randomness, requested round
(Some(_), Some(_)) => (r.clone(), r),
// return a verified randomness, latest round
(Some(check_point), None) if state.secure => {
let r = self.verify(&state, check_point, r, agent.clone()).await?;
(r.clone(), r)
}
// return insecure randomness, latest round
(Some(_), None) => (r.clone(), r),
// return unverified and insecure randomness
(None, _) => (r.clone(), r),
};
state.check_point = Some(check_point);
Ok((state, r))
}
pub(crate) async fn verify(
&mut self,
state: &State,
mut prev: Random,
till: Random,
agent: Option<reqwest::header::HeaderValue>,
) -> Result<Random> {
let endpoint = self.to_base_url();
let client = new_http_client(state.max_conns, agent.clone())?;
let pk = state.info.public_key.as_slice();
while prev.round < till.round {
let till_round = cmp::min(prev.round + 1000, till.round);
let mut rounds = vec![];
for round in (prev.round + 1)..till_round {
let url = make_url!("public", endpoint, round);
let client = &client;
rounds.push(async move {
let (res, elapsed) = { async_get!(client, url) };
let resp = err_at!(IOError, res)?;
let r: RandomJson = err_at!(JsonParse, resp.json().await)?;
let r: Random = r.try_into()?;
Ok::<(Random, time::Duration), Error>((r, elapsed))
});
}
let mut err = false;
for item in futures::future::join_all(rounds).await {
let random = match item {
Ok((_, elapsed)) if err => {
self.add_elapsed(elapsed);
continue;
}
Ok((r, elapsed)) => {
self.add_elapsed(elapsed);
r
}
Err(_) => {
let elapsed = cmp::min(self.to_elapsed() * 2, MAX_ELAPSED);
self.add_elapsed(elapsed);
err = true;
continue;
}
};
if !verify::verify_chain(&pk, &prev.signature, &random)? {
err_at!(NotSecure, msg: format!("fail verify {}", random))?;
}
prev = random;
}
}
Ok(till)
}
pub(crate) async fn do_get(
&mut self,
client: &reqwest::Client,
round: Option<u128>,
) -> Result<Random> {
let endpoint = self.to_base_url();
let r = match round {
Some(round) => {
let (res, elapsed) = {
let url = make_url!("public", endpoint, round);
async_get!(client, url)
};
let resp = err_at!(IOError, add_elapsed!(self, res, elapsed))?;
let r: RandomJson = err_at!(JsonParse, resp.json().await)?;
r.try_into()?
}
None => {
let (res, elapsed) = {
let url = make_url!("public", endpoint);
async_get!(client, url)
};
let resp = err_at!(IOError, add_elapsed!(self, res, elapsed))?;
let r: RandomJson = err_at!(JsonParse, resp.json().await)?;
r.try_into()?
}
};
Ok(r)
}
}
#[derive(Deserialize)]
struct InfoJson {
public_key: String,
period: u64,
genesis_time: u64,
hash: String,
#[serde(alias = "groupHash")]
group_hash: String,
}
impl TryFrom<InfoJson> for Info {
type Error = Error;
fn try_from(val: InfoJson) -> Result<Self> {
let genesis_time = time::Duration::from_secs(val.genesis_time);
let val = Info {
public_key: err_at!(HexParse, hex::decode(&val.public_key))?,
period: time::Duration::from_secs(val.period),
genesis_time: time::UNIX_EPOCH + genesis_time,
hash: err_at!(HexParse, hex::decode(&val.hash))?,
group_hash: err_at!(HexParse, hex::decode(&val.group_hash))?,
};
Ok(val)
}
}
#[derive(Deserialize)]
struct RandomJson {
round: u128,
randomness: String,
signature: String,
previous_signature: String,
}
impl TryFrom<RandomJson> for Random {
type Error = Error;
fn try_from(val: RandomJson) -> Result<Self> {
let psign = err_at!(HexParse, hex::decode(&val.previous_signature))?;
let val = Random {
round: val.round,
randomness: err_at!(HexParse, hex::decode(&val.randomness))?,
signature: err_at!(HexParse, hex::decode(&val.signature))?,
previous_signature: psign,
};
Ok(val)
}
}
fn new_http_client(
max: usize,
agent: Option<reqwest::header::HeaderValue>,
) -> Result<reqwest::Client> {
let b = reqwest::Client::builder().pool_max_idle_per_host(max);
let b = match agent {
Some(agent) => b.user_agent(agent),
None => b,
};
err_at!(Invalid, b.build(), format!("http builder"))
}
#[cfg(test)]
#[path = "http_test.rs"]
mod http_test;
|
extern crate clap;
mod shifumi;
use clap::{App, SubCommand};
use std::io::{self, Write};
fn main() {
let matches = App::new("shifumi")
.version("0.1.0")
.author("Edouard Paris")
.about("shifumi game written in Rust")
.subcommand(SubCommand::with_name("play").about("start a new game"))
.get_matches();
if matches.is_present("play") {
println!(
"game is started, please choose between:\np: paper | s: scissors | r: rock | q: quit"
);
let mut input = String::new();
let mut bot_play = shifumi::Play::new();
let mut scoreboard = (0, 0);
let mut history: Vec<shifumi::Play> = Vec::new();
let mut tree = shifumi::Tree::new();
loop {
input.clear();
print!("you: ");
io::stdout().flush().expect("flush failed");
io::stdin().read_line(&mut input).expect(
"failed to read from stdin",
);
if input.trim() == "q" {
break;
}
if input.trim() == "d" {
display_tree(&tree);
continue;
}
let mut play = shifumi::Play::new();
match string_to_play(&input) {
Some(p) => play = p,
None => println!("please choose between: p | s | r | q"),
}
// Bot play
update_scoreboard(&mut scoreboard, &play, &bot_play);
let (win, lose) = scoreboard;
println!("bot: {} | W:{} L: {}", play_to_string(bot_play), win, lose);
// Bot try to predict next play
history.push(play);
tree.update(&history);
bot_play = match tree.predict(&history) {
Some(p) => p,
None => shifumi::Play::new(),
};
}
}
}
fn update_scoreboard(scoreboard: &mut (i32, i32), play: &shifumi::Play, bot_play: &shifumi::Play) {
let (ref mut win, ref mut lose) = *scoreboard;
if &play.beat() == bot_play {
*lose = *lose + 1;
return;
}
if &bot_play.beat() == play {
*win = *win + 1;
}
}
fn play_to_string(play: shifumi::Play) -> String {
match play {
shifumi::Play::Paper => String::from("p"),
shifumi::Play::Rock => String::from("r"),
shifumi::Play::Scissors => String::from("s"),
}
}
fn string_to_play(play: &String) -> Option<shifumi::Play> {
match play.trim() {
"p" => Some(shifumi::Play::Paper),
"r" => Some(shifumi::Play::Rock),
"s" => Some(shifumi::Play::Scissors),
_ => None,
}
}
fn display_tree(tree: &shifumi::Tree) {
match *tree {
shifumi::Tree::Empty => print!("E "),
shifumi::Tree::Leaf {
ref scissors,
ref paper,
ref rock,
} => {
print!("(S:");
display_tree(scissors);
print!("R:");
display_tree(rock);
print!("P:");
display_tree(paper);
print!(")");
}
}
}
|
//! PoT state management.
use crate::PotConfig;
use async_trait::async_trait;
use core::num::NonZeroUsize;
use parking_lot::Mutex;
use sc_network::PeerId;
use sp_consensus_subspace::digests::PotPreDigest;
use std::collections::btree_map::Entry;
use std::collections::{BTreeMap, VecDeque};
use std::sync::Arc;
use std::time::{Duration, Instant};
use subspace_core_primitives::{BlockNumber, NonEmptyVec, PotKey, PotProof, PotSeed, SlotNumber};
use subspace_proof_of_time::{PotVerificationError, ProofOfTime};
use tracing::trace;
/// The maximum size of the PoT chain to keep (about 5 min worth of proofs for now).
/// TODO: remove this when purging is implemented.
const POT_CHAIN_MAX_SIZE: NonZeroUsize = NonZeroUsize::new(300).expect("Not zero; qed");
/// Error codes for PotProtocolState APIs.
#[derive(Debug, thiserror::Error)]
pub(crate) enum PotProtocolStateError {
#[error("Failed to extend chain: {expected}/{actual}")]
TipMismatch {
expected: SlotNumber,
actual: SlotNumber,
},
#[error("Proof for an older slot number: {tip_slot}/{proof_slot}")]
StaleProof {
tip_slot: SlotNumber,
proof_slot: SlotNumber,
},
#[error("Proof had an unexpected seed: {expected:?}/{actual:?}")]
InvalidSeed { expected: PotSeed, actual: PotSeed },
#[error("Proof had an unexpected key: {expected:?}/{actual:?}")]
InvalidKey { expected: PotKey, actual: PotKey },
#[error("Proof is too much into future: {tip_slot}/{proof_slot}")]
TooFuturistic {
tip_slot: SlotNumber,
proof_slot: SlotNumber,
},
#[error("Duplicate proof from peer: {0:?}")]
DuplicateProofFromPeer(PeerId),
}
/// Error codes for PotConsensusState::get_block_proofs().
#[derive(Debug, thiserror::Error)]
pub enum PotGetBlockProofsError {
#[error("Failed to get start slot: {summary:?}/{block_number}/{proof_slot}/{current_slot}")]
StartSlotMissing {
summary: PotStateSummary,
block_number: BlockNumber,
proof_slot: SlotNumber,
current_slot: SlotNumber,
},
#[error(
"Invalid slot range: {summary:?}/{block_number}/{start_slot}/{proof_slot}/{current_slot}"
)]
InvalidRange {
summary: PotStateSummary,
block_number: BlockNumber,
start_slot: SlotNumber,
proof_slot: SlotNumber,
current_slot: SlotNumber,
},
#[error("Proof unavailable to send: {summary:?}/{block_number}/{missing_slot}/{current_slot}")]
ProofUnavailable {
summary: PotStateSummary,
block_number: BlockNumber,
missing_slot: SlotNumber,
current_slot: SlotNumber,
},
}
/// Error codes for PotConsensusState::verify_block_proofs().
#[derive(Debug, thiserror::Error)]
pub enum PotVerifyBlockProofsError {
#[error("Block has no proofs: {summary:?}/{block_number}/{slot}/{parent_slot}")]
NoProofs {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
},
#[error("Failed to get start slot: {summary:?}/{block_number}/{slot}/{parent_slot}")]
StartSlotMissing {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
},
#[error("Unexpected slot number: {summary:?}/{block_number}/{slot}/{parent_slot}/{expected_slot}/{actual_slot}")]
UnexpectedSlot {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
expected_slot: SlotNumber,
actual_slot: SlotNumber,
},
#[error("Unexpected seed: {summary:?}/{block_number}/{slot}/{parent_slot}/{error_slot}")]
UnexpectedSeed {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
error_slot: SlotNumber,
},
#[error("Unexpected key: {summary:?}/{block_number}/{slot}/{parent_slot}/{error_slot}")]
UnexpectedKey {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
error_slot: SlotNumber,
},
#[error(
"Verification failed: {summary:?}/{block_number}/{slot}/{parent_slot}/{error_slot:?}/{err:?}"
)]
VerificationFailed {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
error_slot: SlotNumber,
err: PotVerificationError,
},
#[error(
"Tip mismatch: {summary:?}/{block_number}/{slot}/{parent_slot}/{expected:?}/{actual:?}"
)]
TipMismatch {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
expected: Option<SlotNumber>,
actual: Option<SlotNumber>,
},
#[error(
"Local chain missing proof: {summary:?}/{block_number}/{slot}/{parent_slot}/{missing_slot}"
)]
LocalChainMissingProof {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
missing_slot: SlotNumber,
},
#[error("Mismatch with local proof: {summary:?}/{block_number}/{slot}/{parent_slot}/{mismatch_slot}")]
ProofMismatch {
summary: PotStateSummary,
block_number: BlockNumber,
slot: SlotNumber,
parent_slot: SlotNumber,
mismatch_slot: SlotNumber,
},
}
/// Summary of the current state.
#[derive(Debug, Clone)]
pub struct PotStateSummary {
/// Current tip.
pub tip: Option<SlotNumber>,
/// Length of chain.
pub chain_length: usize,
}
/// Wrapper around the PoT chain.
struct PotChain {
entries: VecDeque<PotProof>,
max_entries: usize,
}
impl PotChain {
/// Creates the chain.
fn new(max_entries: NonZeroUsize) -> Self {
Self {
entries: VecDeque::new(),
max_entries: max_entries.get(),
}
}
/// Resets the chain to the given entries.
fn reset(&mut self, proofs: NonEmptyVec<PotProof>) {
self.entries.clear();
for proof in proofs.to_vec() {
self.extend(proof);
}
}
/// Helper to extend the chain.
fn extend(&mut self, proof: PotProof) {
if let Some(tip) = self.entries.back() {
// This is a debug assert for now, as this should not happen.
// Change to return error if needed.
debug_assert!((tip.slot_number + 1) == proof.slot_number);
}
if self.entries.len() == self.max_entries {
// Evict the oldest entry if full
self.entries.pop_front();
}
self.entries.push_back(proof);
}
/// Returns the last entry in the chain.
fn tip(&self) -> Option<PotProof> {
self.entries.back().cloned()
}
/// Returns the length of the chain.
fn len(&self) -> usize {
self.entries.len()
}
/// Returns an iterator to the entries.
fn iter(&self) -> Box<dyn Iterator<Item = &PotProof> + '_> {
Box::new(self.entries.iter())
}
}
/// The shared PoT state.
struct InternalState {
/// Config.
config: PotConfig,
/// Last N entries of the PotChain, sorted by height.
/// TODO: purging to be implemented.
chain: PotChain,
/// Proofs for future slot numbers, indexed by slot number.
/// Each entry holds the proofs indexed by sender. The proofs
/// are already verified before being added to the future list.
/// TODO: limit the number of proofs per future slot.
future_proofs: BTreeMap<SlotNumber, BTreeMap<PeerId, PotProof>>,
}
impl InternalState {
/// Creates the state.
fn new(config: PotConfig) -> Self {
Self {
config,
chain: PotChain::new(POT_CHAIN_MAX_SIZE),
future_proofs: BTreeMap::new(),
}
}
/// Re-initializes the state with the given chain.
fn reset(&mut self, proofs: NonEmptyVec<PotProof>) {
self.chain.reset(proofs);
self.future_proofs.clear();
}
/// Adds the proof to the current tip and merged possible future proofs.
fn extend_and_merge(&mut self, proof: PotProof) {
self.future_proofs.remove(&proof.slot_number);
self.chain.extend(proof);
self.merge_future_proofs();
}
/// Adds the batch of proofs to the current tip and merged possible future proofs.
fn extend_and_merge_batch(&mut self, proofs: Vec<PotProof>) {
for proof in proofs.into_iter() {
self.future_proofs.remove(&proof.slot_number);
self.chain.extend(proof);
}
self.merge_future_proofs();
}
/// Tries to extend the chain with the locally produced proof.
fn handle_local_proof(&mut self, proof: &PotProof) -> Result<(), PotProtocolStateError> {
let tip = match self.chain.tip() {
Some(tip) => tip,
None => {
self.extend_and_merge(proof.clone());
return Ok(());
}
};
if (tip.slot_number + 1) == proof.slot_number {
self.extend_and_merge(proof.clone());
Ok(())
} else {
// The tip moved by the time the proof was computed.
Err(PotProtocolStateError::TipMismatch {
expected: tip.slot_number + 1,
actual: proof.slot_number,
})
}
}
/// Tries to extend the chain with the proof received from a peer.
/// The proof is assumed to have passed the AES verification.
fn handle_peer_proof(
&mut self,
sender: PeerId,
proof: &PotProof,
) -> Result<(), PotProtocolStateError> {
let tip = match self.chain.tip() {
Some(tip) => tip.clone(),
None => {
self.extend_and_merge(proof.clone());
return Ok(());
}
};
// Case 1: the proof is for an older slot
if proof.slot_number <= tip.slot_number {
return Err(PotProtocolStateError::StaleProof {
tip_slot: tip.slot_number,
proof_slot: proof.slot_number,
});
}
// Case 2: the proof extends the tip
if (tip.slot_number + 1) == proof.slot_number {
let expected_seed = tip.next_seed(None);
if proof.seed != expected_seed {
return Err(PotProtocolStateError::InvalidSeed {
expected: expected_seed,
actual: proof.seed,
});
}
let expected_key = tip.next_key();
if proof.key != expected_key {
return Err(PotProtocolStateError::InvalidKey {
expected: expected_key,
actual: proof.key,
});
}
// All checks passed, advance the tip with the new proof
self.extend_and_merge(proof.clone());
return Ok(());
}
// Case 3: proof for a future slot
self.handle_future_proof(&tip, sender, proof)
}
/// Checks if the proof is a possible candidate.
fn is_candidate(&self, _sender: PeerId, proof: &PotProof) -> Result<(), PotProtocolStateError> {
let tip = match self.chain.tip() {
Some(tip) => tip.clone(),
None => {
// Chain is empty, possible first proof.
return Ok(());
}
};
// Case 1: the proof is for an older slot.
// When same proof is gossiped by multiple peers, this check
// could help early discard of the duplicates.
if proof.slot_number <= tip.slot_number {
return Err(PotProtocolStateError::StaleProof {
tip_slot: tip.slot_number,
proof_slot: proof.slot_number,
});
}
// Case 2: the proof extends the tip
if (tip.slot_number + 1) == proof.slot_number {
let expected_seed = tip.next_seed(None);
if proof.seed != expected_seed {
return Err(PotProtocolStateError::InvalidSeed {
expected: expected_seed,
actual: proof.seed,
});
}
let expected_key = tip.next_key();
if proof.key != expected_key {
return Err(PotProtocolStateError::InvalidKey {
expected: expected_key,
actual: proof.key,
});
}
}
// Case 3: future proof
// TODO: add more filtering for future proofs
Ok(())
}
/// Handles the received proof for a future slot.
fn handle_future_proof(
&mut self,
tip: &PotProof,
sender: PeerId,
proof: &PotProof,
) -> Result<(), PotProtocolStateError> {
// Reject if too much into future
if (proof.slot_number - tip.slot_number) > self.config.max_future_slots {
return Err(PotProtocolStateError::TooFuturistic {
tip_slot: tip.slot_number,
proof_slot: proof.slot_number,
});
}
match self.future_proofs.entry(proof.slot_number) {
Entry::Vacant(entry) => {
let mut proofs = BTreeMap::new();
proofs.insert(sender, proof.clone());
entry.insert(proofs);
Ok(())
}
Entry::Occupied(mut entry) => {
let proofs_for_slot = entry.get_mut();
// Reject if the sender already sent a proof for same slot number.
if proofs_for_slot.contains_key(&sender) {
return Err(PotProtocolStateError::DuplicateProofFromPeer(sender));
}
// TODO: put a max limit on future proofs per slot number.
proofs_for_slot.insert(sender, proof.clone());
Ok(())
}
}
}
/// Called when the chain is extended with a new proof.
/// Tries to advance the tip as much as possible, by merging with
/// the pending future proofs.
fn merge_future_proofs(&mut self) {
let mut cur_tip = self.chain.tip();
while let Some(tip) = cur_tip.as_ref() {
// At this point, we know the expected seed/key for the next proof
// in the sequence. If there is at least an entry with the expected
// key/seed(there could be several from different peers), extend the
// chain.
let next_slot = tip.slot_number + 1;
let proofs_for_slot = match self.future_proofs.remove(&next_slot) {
Some(proofs) => proofs,
None => return,
};
let next_seed = tip.next_seed(None);
let next_key = tip.next_key();
match proofs_for_slot
.values()
.find(|proof| proof.seed == next_seed && proof.key == next_key)
.cloned()
{
Some(next_proof) => {
// Extend the tip with the next proof, continue merging.
self.chain.extend(next_proof.clone());
cur_tip = Some(next_proof);
}
None => {
// TODO: penalize peers that sent invalid key/seed
return;
}
}
}
}
/// Returns the proofs for the block.
fn get_block_proofs(
&self,
block_number: BlockNumber,
current_slot: SlotNumber,
parent_pre_digest: &PotPreDigest,
) -> Result<NonEmptyVec<PotProof>, PotGetBlockProofsError> {
let summary = self.summary();
let proof_slot = current_slot - self.config.global_randomness_reveal_lag_slots;
let start_slot = parent_pre_digest.next_block_initial_slot().ok_or_else(|| {
PotGetBlockProofsError::StartSlotMissing {
summary: summary.clone(),
block_number,
proof_slot,
current_slot,
}
})?;
if start_slot > proof_slot {
return Err(PotGetBlockProofsError::InvalidRange {
summary: summary.clone(),
block_number,
start_slot,
proof_slot,
current_slot,
});
}
// Collect the proofs in the requested range.
let mut proofs = Vec::with_capacity((proof_slot - start_slot + 1) as usize);
let mut iter = self.chain.iter().skip_while(|p| p.slot_number < start_slot);
for slot in start_slot..=proof_slot {
if let Some(proof) = iter.next() {
debug_assert!(proof.slot_number == slot);
proofs.push(proof.clone());
} else {
return Err(PotGetBlockProofsError::ProofUnavailable {
summary: summary.clone(),
block_number,
missing_slot: slot,
current_slot,
});
}
}
Ok(NonEmptyVec::new(proofs).expect("NonEmptyVec cannot fail with non-empty inputs"))
}
/// Verifies the block proofs.
fn verify_block_proofs(
&self,
block_number: BlockNumber,
slot_number: SlotNumber,
pre_digest: &PotPreDigest,
parent_slot_number: SlotNumber,
parent_pre_digest: &PotPreDigest,
) -> Result<(), PotVerifyBlockProofsError> {
let summary = self.summary();
let block_proofs = pre_digest
.proofs()
.ok_or(PotVerifyBlockProofsError::NoProofs {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
})?;
// Get the expected slot of the first proof in this block.
let start_slot = parent_pre_digest.next_block_initial_slot().ok_or_else(|| {
PotVerifyBlockProofsError::StartSlotMissing {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
}
})?;
// Since we check the first proof starts with the parent.last_proof.slot + 1,
// and we already verified the seed/key of the proofs in the chain were was
// correctly derived from the previous proof, this implies correct chain continuity
// from parent.
let mut local_proofs_iter = self.chain.iter().skip_while(|p| p.slot_number < start_slot);
for received in block_proofs.iter() {
if let Some(local_proof) = local_proofs_iter.next() {
// The received proof should match the proof in the local chain. No need to
// perform AES verification, as local proof is already verified.
if *local_proof != *received {
return Err(PotVerifyBlockProofsError::ProofMismatch {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
mismatch_slot: received.slot_number,
});
}
} else {
return Err(PotVerifyBlockProofsError::LocalChainMissingProof {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
missing_slot: received.slot_number,
});
}
}
Ok(())
}
/// Returns the current tip of the chain.
fn tip(&self) -> Option<PotProof> {
self.chain.tip()
}
/// Returns the summary of the current state.
fn summary(&self) -> PotStateSummary {
PotStateSummary {
tip: self.chain.tip().map(|proof| proof.slot_number),
chain_length: self.chain.len(),
}
}
}
/// Wrapper to manage the state.
struct StateManager {
/// The PoT state
state: Mutex<InternalState>,
/// For AES verification
proof_of_time: ProofOfTime,
}
impl StateManager {
/// Creates the state.
pub fn new(config: PotConfig, proof_of_time: ProofOfTime) -> Self {
Self {
state: Mutex::new(InternalState::new(config)),
proof_of_time,
}
}
/// Verify the proofs and append to the chain.
#[allow(clippy::too_many_arguments)]
fn verify_and_append(
&self,
block_number: BlockNumber,
slot_number: SlotNumber,
proofs: &NonEmptyVec<PotProof>,
parent_slot_number: SlotNumber,
tip: Option<PotProof>,
summary: PotStateSummary,
) -> Result<(), PotVerifyBlockProofsError> {
// Perform the validation, AES verification outside the lock.
let mut prev_proof = tip.clone();
let mut to_add = Vec::with_capacity(proofs.len());
for proof in proofs.iter() {
if let Some(prev_proof) = prev_proof.as_ref() {
if proof.slot_number != (prev_proof.slot_number + 1) {
return Err(PotVerifyBlockProofsError::UnexpectedSlot {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
expected_slot: prev_proof.slot_number + 1,
actual_slot: proof.slot_number,
});
}
if proof.seed != prev_proof.next_seed(None) {
return Err(PotVerifyBlockProofsError::UnexpectedSeed {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
error_slot: proof.slot_number,
});
}
if proof.key != prev_proof.next_key() {
return Err(PotVerifyBlockProofsError::UnexpectedKey {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
error_slot: proof.slot_number,
});
}
// Perform the AES check
self.proof_of_time.verify(proof).map_err(|err| {
PotVerifyBlockProofsError::VerificationFailed {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
error_slot: proof.slot_number,
err,
}
})?;
}
to_add.push(proof.clone());
prev_proof = Some(proof.clone());
}
// Checks passed, take the lock and try to append.
let mut state = self.state.lock();
let cur_tip = state.tip();
if cur_tip != tip {
// Fail if the tip moved meanwhile.
// TODO: fall back to regular path if needed.
return Err(PotVerifyBlockProofsError::TipMismatch {
summary: summary.clone(),
block_number,
slot: slot_number,
parent_slot: parent_slot_number,
expected: tip.map(|p| p.slot_number),
actual: cur_tip.map(|p| p.slot_number),
});
}
state.extend_and_merge_batch(to_add);
Ok(())
}
}
/// Interface to the internal protocol components (time keeper, PoT client).
pub(crate) trait PotProtocolState: Send + Sync {
/// Re(initializes) the chain with the given set of proofs.
/// TODO: the proofs are assumed to have been validated, validate
/// if needed.
fn reset(&self, proofs: NonEmptyVec<PotProof>);
/// Returns the current tip.
fn tip(&self) -> Option<PotProof>;
/// Called when a proof is produced locally. It tries to extend the
/// chain without verifying the proof.
fn on_proof(&self, proof: &PotProof) -> Result<(), PotProtocolStateError>;
/// Called when a proof is received via gossip from a peer. The AES
/// verification is already done by the gossip validator.
fn on_proof_from_peer(
&self,
sender: PeerId,
proof: &PotProof,
) -> Result<(), PotProtocolStateError>;
/// Called by gossip validator to filter out the received proofs
/// early on. This performs only simple/inexpensive checks, the
/// actual AES verification happens later when the proof is delivered
/// by gossip. This acts like a Bloom filter: false positives with an
/// error probability, no false negatives.
fn is_candidate(&self, sender: PeerId, proof: &PotProof) -> Result<(), PotProtocolStateError>;
}
impl PotProtocolState for StateManager {
fn reset(&self, proofs: NonEmptyVec<PotProof>) {
self.state.lock().reset(proofs);
}
fn tip(&self) -> Option<PotProof> {
self.state.lock().tip()
}
fn on_proof(&self, proof: &PotProof) -> Result<(), PotProtocolStateError> {
self.state.lock().handle_local_proof(proof)
}
fn on_proof_from_peer(
&self,
sender: PeerId,
proof: &PotProof,
) -> Result<(), PotProtocolStateError> {
self.state.lock().handle_peer_proof(sender, proof)
}
fn is_candidate(&self, sender: PeerId, proof: &PotProof) -> Result<(), PotProtocolStateError> {
self.state.lock().is_candidate(sender, proof)
}
}
/// Interface to consensus.
#[async_trait]
pub trait PotConsensusState: Send + Sync {
/// Called by consensus when trying to claim the slot.
/// Returns the proofs in the slot range
/// [start_slot, current_slot - global_randomness_reveal_lag_slots].
/// If the proofs are unavailable, retries upto wait_time(if specified).
async fn get_block_proofs(
&self,
block_number: BlockNumber,
current_slot: SlotNumber,
parent_pre_digest: &PotPreDigest,
wait_time: Option<Duration>,
) -> Result<NonEmptyVec<PotProof>, PotGetBlockProofsError>;
/// Called during block import validation.
/// Verifies the sequence of proofs in the block being validated.
fn verify_block_proofs(
&self,
block_number: BlockNumber,
slot_number: SlotNumber,
pre_digest: &PotPreDigest,
parent_slot_number: SlotNumber,
parent_pre_digest: &PotPreDigest,
) -> Result<(), PotVerifyBlockProofsError>;
}
#[async_trait]
impl PotConsensusState for StateManager {
async fn get_block_proofs(
&self,
block_number: BlockNumber,
current_slot: SlotNumber,
parent_pre_digest: &PotPreDigest,
wait_time: Option<Duration>,
) -> Result<NonEmptyVec<PotProof>, PotGetBlockProofsError> {
let start_ts = Instant::now();
let should_wait = move || {
wait_time
.as_ref()
.map_or(false, |wait_time| start_ts.elapsed() < *wait_time)
};
let retry_delay = Duration::from_millis(200);
let mut retries = 0;
loop {
let result =
self.state
.lock()
.get_block_proofs(block_number, current_slot, parent_pre_digest);
match result {
Ok(_) => return result,
Err(PotGetBlockProofsError::ProofUnavailable { .. }) => {
if (should_wait)() {
// TODO: notification instead of sleep/retry.
retries += 1;
trace!(
?result,
%retries,
"Proof unavailable, retrying...",
);
tokio::time::sleep(retry_delay).await;
} else {
return result;
}
}
_ => return result,
}
}
}
fn verify_block_proofs(
&self,
block_number: BlockNumber,
slot_number: SlotNumber,
pre_digest: &PotPreDigest,
parent_slot_number: SlotNumber,
parent_pre_digest: &PotPreDigest,
) -> Result<(), PotVerifyBlockProofsError> {
if let Some(block_proofs) = pre_digest.proofs() {
// Opportunistically try to extend the chain with
// the proofs from the block.
// TODO: this also is done when the chain is empty and
// we don't have a previous proof to verify against.
// This needs to be revisited as part of the node sync.
let (tip, summary) = {
let state = self.state.lock();
(state.tip(), state.summary())
};
let should_append = tip
.as_ref()
.map(|tip| (tip.slot_number + 1) == block_proofs.first().slot_number)
.unwrap_or(true);
if should_append {
return self.verify_and_append(
block_number,
slot_number,
block_proofs,
parent_slot_number,
tip,
summary,
);
}
}
self.state.lock().verify_block_proofs(
block_number,
slot_number,
pre_digest,
parent_slot_number,
parent_pre_digest,
)
}
}
pub(crate) fn init_pot_state(
config: PotConfig,
proof_of_time: ProofOfTime,
) -> (Arc<dyn PotProtocolState>, Arc<dyn PotConsensusState>) {
let state = Arc::new(StateManager::new(config, proof_of_time));
(state.clone(), state)
}
|
use libc::{c_int, off_t};
use mio::{Evented, Poll, Token, Ready, PollOpt};
use mio::unix::UnixReady;
use nix;
use nix::sys::aio;
use nix::sys::signal::SigevNotify;
use std::cell::RefCell;
use std::io;
use std::os::unix::io::AsRawFd;
use std::os::unix::io::RawFd;
use std::rc::Rc;
#[derive(Debug)]
pub struct AioCb<'a> {
// Must use a RefCell because mio::Evented's methods only take immutable
// references we must use a RefCell here. Unlike sockets, registering
// aiocb's requires modifying the aiocb.
// Must use Box for the AioCb so its location in memory will be constant.
// It is an error to move a libc::aiocb after passing it to the kernel.
inner: RefCell<Box<aio::AioCb<'a>>>
}
/// Wrapper around nix::sys::aio::AioCb.
///
/// Implements mio::Evented. After creation, use mio::Evented::register to
/// connect to the event loop
impl<'a> AioCb<'a> {
/// Wraps nix::sys::aio::AioCb::from_fd.
pub fn from_fd(fd: RawFd, prio: c_int) -> AioCb<'a> {
let aiocb = aio::AioCb::from_fd(fd, prio, SigevNotify::SigevNone);
AioCb { inner: RefCell::new(Box::new(aiocb)) }
}
/// Wraps nix::sys::aio::AioCb::from_mut_slice.
pub fn from_boxed_slice(fd: RawFd, offs: off_t, buf: Rc<Box<[u8]>>,
prio: c_int, opcode: aio::LioOpcode) -> AioCb<'a>{
let aiocb = aio::AioCb::from_boxed_slice(fd, offs, buf, prio,
SigevNotify::SigevNone, opcode);
AioCb { inner: RefCell::new(Box::new(aiocb)) }
}
/// Wraps nix::sys::aio::from_slice
pub fn from_slice(fd: RawFd, offs: off_t, buf: &'a [u8],
prio: c_int, opcode: aio::LioOpcode) -> AioCb {
let aiocb = aio::AioCb::from_slice(fd, offs, buf, prio,
SigevNotify::SigevNone, opcode);
AioCb { inner: RefCell::new(Box::new(aiocb)) }
}
/// Wrapper for nix::sys::aio::aio_return
pub fn aio_return(&self) -> nix::Result<isize> {
self.inner.borrow_mut().aio_return()
}
/// Wrapper for nix::sys::aio::AioCb::cancel
pub fn cancel(&self) -> nix::Result<aio::AioCancelStat> {
self.inner.borrow_mut().cancel()
}
/// Wrapper for nix::sys::aio::AioCb::fsync
pub fn fsync(&self, mode: aio::AioFsyncMode) -> nix::Result<()> {
self.inner.borrow_mut().fsync(mode)
}
/// Wrapper for nix::sys::aio::AioCb::read
pub fn read(&self) -> nix::Result<()> {
self.inner.borrow_mut().read()
}
/// Wrapper for nix::sys::aio::AioCb::write
pub fn write(&self) -> nix::Result<()> {
self.inner.borrow_mut().write()
}
}
impl<'a> Evented for AioCb<'a> {
fn register(&self,
poll: &Poll,
token: Token,
events: Ready,
_: PollOpt) -> io::Result<()> {
assert!(UnixReady::from(events).is_aio());
let udata = usize::from(token);
let kq = poll.as_raw_fd();
let sigev = SigevNotify::SigevKevent{kq: kq, udata: udata as isize};
self.inner.borrow_mut().set_sigev_notify(sigev);
Ok(())
}
fn reregister(&self,
poll: &Poll,
token: Token,
events: Ready,
opts: PollOpt) -> io::Result<()> {
self.register(poll, token, events, opts)
}
fn deregister(&self, _: &Poll) -> io::Result<()> {
let sigev = SigevNotify::SigevNone;
self.inner.borrow_mut().set_sigev_notify(sigev);
Ok(())
}
}
|
extern crate exact_cover;
use exact_cover::{Problem, Solver};
fn main() {
const NUM_COLUMNS: usize = 7;
// This problem is equivalent to the problem in subsets.rs.
// However, we express it directly as the matrix. We want to find
// a subset of rows such that every column has exactly one 1.
let matrix = [1, 0, 0, 1, 0, 0, 1,
1, 0, 0, 1, 0, 0, 0,
0, 0, 0, 1, 1, 0, 1,
0, 0, 1, 0, 1, 1, 0,
0, 1, 1, 0, 0, 1, 1,
0, 1, 0, 0, 0, 0, 1];
let mut p = Problem::new();
for (i, r) in matrix.chunks(NUM_COLUMNS).enumerate() {
let column_indices: Vec<usize> = r.iter().enumerate().filter_map(|(i, c)| if *c == 1 { Some(i) } else { None }).collect();
p.add_action(i, &column_indices);
}
let mut solver = Solver::new(p);
let sol = solver.first_solution().unwrap();
println!("{:?}", sol);
// We can also specify that some actions must exist in the final solution.
solver.require_action(1).ok();
let sol = solver.first_solution().unwrap();
println!("{:?}", sol);
// If we specifiy actions that are a-priori wrong, the method will
// fail (and the solver will not change state.)
assert!(solver.require_action(0).is_err());
let sol = solver.first_solution().unwrap();
println!("{:?}", sol);
}
|
use serde::Serialize;
#[derive(Debug, Serialize)]
pub struct Domain(pub String);
#[derive(Debug, Serialize)]
pub struct DisplayName(pub String);
#[derive(Debug, Serialize)]
pub struct ShortName(pub String);
#[derive(Debug, Serialize)]
pub struct Hostname(pub String);
#[derive(Debug, Serialize)]
pub struct Port(pub u16);
#[derive(Debug, Serialize)]
pub struct SocketType(pub String);
#[derive(Debug, Serialize)]
pub struct Authentication(pub String);
#[derive(Debug, Serialize)]
pub struct Username(pub String);
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Server {
#[serde(rename = "type")]
pub ty: String,
pub hostname: Hostname,
pub port: Port,
pub socket_type: SocketType,
pub auth: Authentication,
pub username: Username,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Provider {
pub id: String,
pub domain: Domain,
pub display_name: DisplayName,
pub display_short_name: ShortName,
#[serde(rename = "incomingServer")]
pub incoming_servers: Vec<Server>,
#[serde(rename = "outgoingServer")]
pub outgoing_servers: Vec<Server>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientConfig {
pub version: String,
#[serde(rename = "emailProvider")]
pub providers: Vec<Provider>,
}
|
//! **Sh**ared **re**source **d**ispatcher
//!
//! This library allows to dispatch
//! systems, which can have interdependencies,
//! shared and exclusive resource access, in parallel.
//!
//! # Examples
//!
//! ```rust
//! extern crate shred;
//!
//! use shred::{DispatcherBuilder, Read, Resource, ResourceId, System, SystemData, World, Write};
//!
//! #[derive(Debug, Default)]
//! struct ResA;
//!
//! #[derive(Debug, Default)]
//! struct ResB;
//!
//! # #[cfg(feature = "shred-derive")]
//! #[derive(SystemData)] // Provided with `shred-derive` feature
//! struct Data<'a> {
//! a: Read<'a, ResA>,
//! b: Write<'a, ResB>,
//! }
//!
//! struct EmptySystem;
//!
//! impl<'a> System<'a> for EmptySystem {
//! type SystemData = Data<'a>;
//!
//! fn run(&mut self, bundle: Data<'a>) {
//! println!("{:?}", &*bundle.a);
//! println!("{:?}", &*bundle.b);
//! }
//! }
//!
//! let mut world = World::empty();
//! let mut dispatcher = DispatcherBuilder::new()
//! .with(EmptySystem, "empty", &[])
//! .build();
//! world.insert(ResA);
//! world.insert(ResB);
//!
//! dispatcher.dispatch(&mut world);
//! #
//! # // The following is required for the snippet to compile without the `shred-derive` feature.
//! #
//! # #[cfg(not(feature = "shred-derive"))]
//! # struct Data<'a> {
//! # a: Read<'a, ResA>,
//! # b: Write<'a, ResB>,
//! # }
//! #
//! # #[cfg(not(feature = "shred-derive"))]
//! # impl<'a> SystemData<'a> for Data<'a> {
//! # fn setup(world: &mut World) {
//! # Read::<'_, ResA>::setup(world);
//! # Write::<'_, ResB>::setup(world);
//! # }
//! #
//! # fn fetch(world: &'a World) -> Self {
//! # Self {
//! # a: Read::<'_, ResA>::fetch(world),
//! # b: Write::<'_, ResB>::fetch(world),
//! # }
//! # }
//! #
//! # fn reads() -> Vec<ResourceId> {
//! # Read::<'_, ResA>::reads()
//! # }
//! #
//! # fn writes() -> Vec<ResourceId> {
//! # Write::<'_, ResB>::writes()
//! # }
//! # }
//! ```
//!
//! Once you are more familiar with how system data and parallelization works,
//! you can take look at a more flexible and performant way to dispatch:
//! `ParSeq`. Using it is bit trickier, but it allows dispatching without any
//! virtual function calls.
#![deny(unused_must_use, clippy::disallowed_types)]
#![warn(missing_docs)]
/// Re-exports from [`atomic_refcell`]
///
/// Mainly for internals, most users don't need to interact with this.
pub mod cell {
pub use atomic_refcell::*;
}
mod dispatch;
mod meta;
mod system;
mod world;
/// A reexport of the `#[derive(SystemData]` macro provided by `shred-derive`.
/// This requires that the `shred-derive` feature is enabled.
#[cfg(feature = "shred-derive")]
pub use shred_derive::SystemData;
#[cfg(feature = "parallel")]
pub use crate::dispatch::AsyncDispatcher;
#[cfg(feature = "parallel")]
pub use crate::dispatch::{Par, ParSeq, RunWithPool, Seq};
pub use crate::{
dispatch::{
BatchAccessor, BatchController, BatchUncheckedWorld, Dispatcher, DispatcherBuilder,
MultiDispatchController, MultiDispatcher,
},
meta::{CastFrom, MetaIter, MetaIterMut, MetaTable},
system::{
Accessor, AccessorCow, DynamicSystemData, RunNow, RunningTime, StaticAccessor, System,
SystemData,
},
world::{
DefaultProvider, Entry, Fetch, FetchMut, PanicHandler, Read, ReadExpect, Resource,
ResourceId, SetupHandler, World, Write, WriteExpect,
},
};
/// Alias for `World` for easier migration to the new version. Will be removed
/// in the future.
#[deprecated(since = "0.8.0", note = "renamed to `World`")]
pub type Resources = World;
|
pub mod littleroot_town;
use super::Location;
use std::collections::HashMap;
pub fn all<'a>() -> HashMap<u16, Location<'a>> {
let mut cities: HashMap<u16, Location> = HashMap::new();
for (key, val) in littleroot_town::all().iter() {
cities.insert(key.clone(), val.clone());
}
cities
}
|
#[macro_use]
extern crate glium;
extern crate rusttype;
extern crate rand;
extern crate time;
#[macro_use]
extern crate more_asserts;
#[macro_use]
mod util;
mod math;
mod font;
mod manifold;
mod bsp;
use bsp::{BspNode, Face};
use manifold::Manifold;
use math::*;
use math::pose::Pose;
use glium::{DisplayBuild, Surface};
use std::collections::{HashSet};
use std::cell::{RefCell};
use std::rc::Rc;
use std::f32;
use glium::backend::glutin_backend::GlutinFacade;
// flat phong
static FLAT_VS: &'static str = r#"
#version 140
in vec3 position;
out vec3 v_position, v_viewpos;
uniform mat4 perspective, view, model;
void main() {
mat4 modelview = view * model;
vec4 mpos = modelview * vec4(position, 1.0);
gl_Position = perspective * mpos;
v_position = gl_Position.xyz / gl_Position.w;
v_viewpos = -mpos.xyz;
}"#;
static FLAT_FS: &'static str = r#"
#version 140
in vec3 v_position, v_viewpos;
out vec4 color;
uniform vec3 u_light;
uniform vec4 u_color;
const vec3 ambient_color = vec3(0.1, 0.1, 0.1);
const vec3 specular_color = vec3(1.0, 1.0, 1.0);
void main() {
vec3 normal = normalize(cross(dFdx(v_viewpos), dFdy(v_viewpos)));
float diffuse = abs(dot(normal, normalize(u_light))); // ...
vec3 camera_dir = normalize(-v_position);
vec3 half_direction = normalize(normalize(u_light) + camera_dir);
float specular = pow(max(dot(half_direction, normal), 0.0), 16.0);
color = vec4(ambient_color + diffuse*u_color.rgb + specular * specular_color, u_color.a);
}"#;
// solid color
static SOLID_VS: &'static str = r#"
#version 140
in vec3 position;
uniform mat4 perspective, view, model;
void main() {
mat4 modelview = view * model;
vec4 mpos = modelview * vec4(position, 1.0);
gl_Position = perspective * mpos;
}"#;
static SOLID_FS: &'static str = r#"
#version 140
out vec4 color;
uniform vec4 u_color;
void main() {
color = u_color;
}"#;
fn unpack_arrays<'a>(arrays: &'a [[u16; 3]]) -> &'a [u16] {
unsafe { std::slice::from_raw_parts(arrays.as_ptr() as *const u16, arrays.len() * 3) }
}
#[repr(C)]
#[derive(Copy, Clone)]
struct Vertex {
position: [f32; 3]
}
implement_vertex!(Vertex, position);
fn vertex_slice<'a>(v3s: &'a [V3]) -> &'a [Vertex] {
unsafe { std::slice::from_raw_parts(v3s.as_ptr() as *const Vertex, v3s.len()) }
}
struct InputState {
pub mouse_pos: (i32, i32),
pub mouse_pos_prev: (i32, i32),
pub mouse_vec: V3,
pub mouse_vec_prev: V3,
pub view_angle: f32,
pub size: (u32, u32),
pub mouse_down: bool,
pub keys_down: HashSet<glium::glutin::VirtualKeyCode>,
pub key_changes: Vec<(glium::glutin::VirtualKeyCode, bool)>
}
impl InputState {
fn new(w: u32, h: u32, view_angle: f32) -> InputState {
InputState {
mouse_pos: (0, 0),
mouse_pos_prev: (0, 0),
mouse_vec: V3::zero(),
mouse_vec_prev: V3::zero(),
view_angle: view_angle,
size: (w, h),
mouse_down: false,
keys_down: HashSet::new(),
key_changes: Vec::new(),
}
}
fn get_projection_matrix(&self, near: f32, far: f32) -> M4x4 {
M4x4::perspective(self.view_angle.to_radians(), self.size.0 as f32 / self.size.1 as f32, near, far)
}
pub fn mouse_delta(&self) -> V2 {
let now = vec2(self.mouse_pos.0 as f32, self.mouse_pos.1 as f32);
let prev = vec2(self.mouse_pos_prev.0 as f32, self.mouse_pos_prev.1 as f32);
(now - prev)
}
#[inline]
pub fn mouse_pos_v(&self) -> V2 {
vec2(self.mouse_pos.0 as f32, self.mouse_pos.1 as f32)
}
#[inline]
pub fn mouse_prev_v(&self) -> V2 {
vec2(self.mouse_pos_prev.0 as f32, self.mouse_pos_prev.1 as f32)
}
#[inline]
pub fn dims(&self) -> V2 {
vec2(self.size.0 as f32, self.size.1 as f32)
}
#[inline]
pub fn scaled_mouse_delta(&self) -> V2 {
(self.mouse_pos_v() - self.mouse_prev_v()) / self.dims()*0.5
}
#[inline]
pub fn keys_dir(&self, k1: glium::glutin::VirtualKeyCode, k2: glium::glutin::VirtualKeyCode) -> f32 {
let v1 = if self.keys_down.contains(&k1) { 1 } else { 0 };
let v2 = if self.keys_down.contains(&k2) { 1 } else { 0 };
(v2 - v1) as f32
}
fn update(&mut self, display: &glium::backend::glutin_backend::GlutinFacade) -> bool {
use glium::glutin::{Event, ElementState, MouseButton};
let mouse_pos = self.mouse_pos;
let mouse_vec = self.mouse_vec;
self.key_changes.clear();
self.mouse_pos_prev = mouse_pos;
self.mouse_vec_prev = mouse_vec;
for ev in display.poll_events() {
match ev {
Event::Closed => return false,
Event::Resized(w, h) => {
self.size = (w, h);
},
Event::Focused(true) => {
self.keys_down.clear()
},
Event::KeyboardInput(pressed, _, Some(vk)) => {
let was_pressed = match pressed {
ElementState::Pressed => {
self.keys_down.insert(vk);
true
},
ElementState::Released => {
self.keys_down.remove(&vk);
false
}
};
self.key_changes.push((vk, was_pressed));
},
Event::MouseMoved(x, y) => {
self.mouse_pos = (x, y);
},
Event::MouseInput(state, MouseButton::Left) => {
self.mouse_down = state == ElementState::Pressed;
}
_ => (),
}
}
self.mouse_vec = {
let spread = (self.view_angle.to_radians() * 0.5).tan();
let (w, h) = (self.size.0 as f32, self.size.1 as f32);
let (mx, my) = (self.mouse_pos.0 as f32, self.mouse_pos.1 as f32);
let hh = h * 0.5;
let y = spread * (h - my - hh) / hh;
let x = spread * (mx - w * 0.5) / hh;
vec3(x, y, -1.0).normalize().unwrap()
};
true
}
}
pub fn glmat(inp: M4x4) -> [[f32; 4]; 4] { inp.into() }
struct DemoWindow {
pub display: GlutinFacade,
pub input: InputState,
pub view: M4x4,
pub lit_shader: glium::Program,
pub solid_shader: glium::Program,
pub clear_color: V4,
pub light_pos: [f32; 3],
pub targ: Option<glium::Frame>,
pub near_far: (f32, f32),
pub dt: f64,
pub mspf: f32,
pub fps: f32,
pub frame: u64,
frame_start: u64,
last_fps_time: u64,
}
impl DemoWindow {
pub fn new() -> DemoWindow {
let display = glium::glutin::WindowBuilder::new()
.with_depth_buffer(24)
.with_vsync()
.build_glium()
.unwrap();
let input_state = {
let (win_w, win_h) = display.get_window().unwrap()
.get_inner_size_pixels().unwrap();
InputState::new(win_w, win_h, 75.0)
};
let phong_program = glium::Program::from_source(&display, FLAT_VS, FLAT_FS, None).unwrap();
let solid_program = glium::Program::from_source(&display, SOLID_VS, SOLID_FS, None).unwrap();
DemoWindow {
display: display,
input: input_state,
view: M4x4::identity(),
lit_shader: phong_program,
solid_shader: solid_program,
clear_color: vec4(0.5, 0.6, 1.0, 1.0),
light_pos: [1.4, 0.4, 0.7f32],
near_far: (0.01, 500.0),
targ: None,
frame: 0,
fps: 60.0,
dt: 1.0 / 60.0,
mspf: 0.0,
frame_start: time::precise_time_ns(),
last_fps_time: time::precise_time_ns(),
}
}
pub fn up(&mut self) -> bool {
assert!(self.targ.is_none());
let last_frame_start = self.frame_start;
self.frame_start = time::precise_time_ns();
let delta_ns = (self.frame_start - last_frame_start) as f64;
self.dt = delta_ns * 1.0e-9;
self.fps = (1.0 / self.dt) as f32;
if !self.input.update(&self.display) {
false
} else {
self.targ = Some(self.display.draw());
self.targ.as_mut().unwrap().clear_color_and_depth(self.clear_color.into(), 1.0);
true
}
}
pub fn draw_lit_tris(&mut self, mat: M4x4, color: V4, verts: &[V3], maybe_tris: Option<&[[u16; 3]]>) {
let vbo = glium::VertexBuffer::new(&self.display, vertex_slice(verts)).unwrap();
let params = glium::DrawParameters {
blend: glium::Blend::alpha_blending(),
depth: glium::Depth {
test: glium::draw_parameters::DepthTest::IfLess,
write: true,
.. Default::default()
},
.. Default::default()
};
let uniforms = uniform! {
model: glmat(mat),
u_color: <[f32; 4]>::from(color),
view: glmat(self.view),
perspective: glmat(self.input.get_projection_matrix(self.near_far.0, self.near_far.1)),
u_light: self.light_pos,
};
if let Some(tris) = maybe_tris {
let ibo = glium::IndexBuffer::new(&self.display,
glium::index::PrimitiveType::TrianglesList, unpack_arrays(tris)).unwrap();
self.targ.as_mut().unwrap().draw((&vbo,), &ibo, &self.lit_shader, &uniforms, ¶ms).unwrap();
} else {
let ibo = glium::index::NoIndices(glium::index::PrimitiveType::TrianglesList);
self.targ.as_mut().unwrap().draw((&vbo,), &ibo, &self.lit_shader, &uniforms, ¶ms).unwrap();
}
}
pub fn draw_solid(&mut self, mat: M4x4, color: V4, verts: &[V3], prim_type: glium::index::PrimitiveType) {
let vbo = glium::VertexBuffer::new(&self.display, vertex_slice(verts)).unwrap();
let ibo = glium::index::NoIndices(prim_type);
self.targ.as_mut().unwrap().draw((&vbo,), &ibo, &self.solid_shader,
&uniform! {
model: glmat(mat),
u_color: <[f32; 4]>::from(color),
view: glmat(self.view),
perspective: glmat(self.input.get_projection_matrix(
self.near_far.0, self.near_far.1)),
},
&glium::DrawParameters {
point_size: Some(5.0),
blend: glium::Blend::alpha_blending(),
.. Default::default()
}).unwrap();
}
pub fn wf_manifold(&mut self, mat: M4x4, color: V4, mf: &Manifold) {
let mut verts = Vec::with_capacity(mf.edges.len()*2);
for e in &mf.edges {
verts.push(mf.verts[e.vert_idx()]);
verts.push(mf.verts[mf.edges[e.next_idx()].vert_idx()]);
}
self.draw_solid(mat, color, &verts[..], glium::index::PrimitiveType::LinesList);
}
pub fn draw_face(&mut self, mat: M4x4, color: V4, f: &Face) {
self.draw_lit_tris(mat, color, &f.vertex, Some(&f.gen_tris()[..]));
}
pub fn draw_faces(&mut self, mat: M4x4, faces: &[Face]) {
for face in faces.iter() {
self.draw_face(mat, V4::expand(face.plane.normal, 1.0), face);
}
}
pub fn end_frame(&mut self) {
let now = time::precise_time_ns();
self.mspf = ((now - self.frame_start) as f32) / 1.0e6;
self.targ.take().unwrap().finish().unwrap();
}
}
pub fn run_bsp_test() {
let font_data = include_bytes!("../data/Arial Unicode.ttf");
let mut win = DemoWindow::new();
let mut fr = font::FontRenderer::new(&mut win.display, &font_data[..]);
win.input.view_angle = 45.0;
let mut draw_mode = 0;
let mut drag_mode = 1;
let mut cam = Pose::from_rotation(Quat::from_axis_angle(vec3(1.0, 0.0, 0.0), 60f32.to_radians()));
let mut cam_dist = 5_f32;
let mut hit_dist = 0_f32;
win.light_pos = [-1.0, 0.5, 0.5];
let mut bpos = vec3(0.0, 0.0, 0.5);
let mut cpos = vec3(0.8, 0.0, 0.45);
let ac = Manifold::new_cube(1.0);
let bc = Manifold::new_box(vec3(-0.5, -0.5, -1.2), vec3(0.5, 0.5, 1.2));
let co = Manifold::new_cube(1.0).dual_r(0.85);
let af = ac.faces();
let bf = bc.faces();
let cf = co.faces();
let mut bsp = None;
let mut faces: Vec<Face> = Vec::new();
win.near_far = (0.01, 10.0);
while win.up() {
{
let (screen_width, screen_height) = {
let (w, h) = win.display.get_framebuffer_dimensions();
(w as f32, h as f32)
};
fr.begin_frame(screen_width, screen_height);
}
if win.input.key_changes.iter().any(|&(a, b)| b && a == glium::glutin::VirtualKeyCode::D) {
draw_mode = (draw_mode+1)%2;
}
if win.input.mouse_down {
match drag_mode {
1 => {
cam.orientation *= Quat::virtual_track_ball(vec3(0.0, 0.0, 2.0), V3::zero(), win.input.mouse_vec_prev, win.input.mouse_vec).conj();
},
0 => {
drag_mode = 1;
let v0 = cam.position;
let v1 = cam.position + cam.orientation * (win.input.mouse_vec*100.0);
let bhit = geom::convex_hit_check_posed(
&bc.faces[..], Pose::from_translation(bpos), v0, v1);
let v1 = bhit.impact;
let chit = geom::convex_hit_check_posed(
&co.faces[..], Pose::from_translation(cpos), v0, v1);
hit_dist = v0.dist(chit.impact);
if bhit.did_hit {
drag_mode = 2
}
if chit.did_hit {
drag_mode = 3;
}
if draw_mode == 2 {
drag_mode = 1;
}
println!("DRAG MODE => {}", drag_mode);
},
n => {
let pos = if n == 2 { &mut bpos } else { &mut cpos };
*pos += (cam.orientation * win.input.mouse_vec - cam.orientation * win.input.mouse_vec_prev) * hit_dist;
bsp = None;
},
}
} else {
drag_mode = 0;
}
cam.position = cam.orientation.z_dir() * cam_dist;
if bsp.is_none() {
let mut bsp_a = Box::new(bsp::compile(af.clone(), Manifold::new_cube(2.0)));
let mut bsp_b = Box::new(bsp::compile(bf.clone(), Manifold::new_cube(2.0)));
let mut bsp_c = Box::new(bsp::compile(cf.clone(), Manifold::new_cube(2.0)));
bsp_b.translate(bpos);
bsp_c.translate(cpos);
bsp_b.negate();
bsp_c.negate();
let mut bspres = bsp::intersect(bsp_c, bsp::intersect(bsp_b, bsp_a));
let brep = bspres.rip_brep();
bspres.make_brep(brep, 0);
faces = bspres.rip_brep();
bsp = bsp::clean(bspres);
assert!(bsp.is_some());
}
win.view = cam.inverse().to_mat4();
win.wf_manifold(M4x4::identity(), vec4(0.0, 1.0, 0.5, 1.0), &ac);
win.wf_manifold(M4x4::from_translation(bpos), vec4(0.0, 0.5, 1.0, 1.0), &bc);
win.wf_manifold(M4x4::from_translation(cpos), vec4(0.5, 0.0, 1.0, 1.0), &co);
fr.write((1, 1), format!("FPS: {}", win.fps).as_str());
match draw_mode {
0 => {
// faces (boundary)
win.draw_faces(M4x4::identity(), &faces[..]);
},
1 => {
// cells
let mut stack = vec![bsp.as_ref().unwrap().as_ref()];
while let Some(n) = stack.pop() {
if n.leaf_type == bsp::LeafType::Under {
let c = n.convex.verts.iter().fold(V3::zero(), |a, &b| a+b) / (n.convex.verts.len() as f32);
let mut m = M4x4::from_translation(c);
m *= M4x4::from_scale(V3::splat(0.95));
m *= M4x4::from_translation(-c);
win.draw_lit_tris(m, V4::splat(1.0), &n.convex.verts[..], Some(&n.convex.generate_tris()[..]))
}
if let Some(ref r) = n.under {
stack.push(r.as_ref());
}
if let Some(ref r) = n.over {
stack.push(r.as_ref());
}
}
},
_ => {
unreachable!("bad draw_mode {}", draw_mode);
}
}
fr.draw(&mut win.display, win.targ.as_mut().unwrap());
win.end_frame();
}
}
fn main() {
run_bsp_test();
}
|
#![recursion_limit = "2048"]
use std::collections::HashMap;
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;
use web_sys::SvggElement;
use yew::prelude::*;
extern crate console_error_panic_hook;
use anyhow::Error;
use std::panic;
use http::{Request, Response};
use yew::html::ComponentLink;
use yew::services::fetch;
use yew::services::websocket::{WebSocketService, WebSocketStatus, WebSocketTask};
use yew::services::ConsoleService;
use ordinal::Ordinal;
use serde_cbor::{from_slice, to_vec};
use stdweb::js;
mod structs;
use structs::{
ClientExtraFields, ProducerClientMsg, ProducerClientType, ProducerServerMsg,
ProducerServerType, /* Offsets,*/
};
use structs::Participant;
struct Model {
link: ComponentLink<Self>,
ws: Option<WebSocketTask>,
fetch_task: Option<fetch::FetchTask>,
producers: HashMap<String, Participant>,
graph_data: Graphs,
turn: u64,
game_id: String,
quantity: f64,
price: f64,
score: f64,
balance: f64,
took_turn: bool,
error_msg: String,
winner: Option<(String, u8)>,
}
impl Participant {
fn render(&self, id: String) -> Html {
html! {
<div class="seller">
<p class="d-flex flex-grow-1 id" style="margin-bottom: 0px;">{&id}<br/></p>
<p class="text-center d-xl-flex flex-grow-1 quantity" style="margin-bottom: 0px;">{format!("${:.2}",self.price)}</p>
<p class="text-center d-xl-flex flex-grow-1 quantity" style="margin-bottom: 0px;">{format!("{}/{}",self.remaining,self.produced)}</p>
</div>
}
}
}
trait ParticipantCollection {
fn render(&self) -> Html;
}
impl ParticipantCollection for HashMap<String, Participant> {
fn render(&self) -> Html {
html! {
<>
{for self.keys().zip(self.values()).map(|tuple| tuple.1.render(tuple.0.to_string()))}
</>
}
}
}
// ! Make sure allowed graph values never goes below 0.
struct Graphs {
producer_x: f64,
producer_y: f64,
supply_shock: u8,
subsidies: u8,
matrix: Option<(f64, f64, f64, f64, f64, f64)>,
dragging: bool,
}
impl Graphs {
fn new() -> Graphs {
Graphs {
producer_x: 32.50,
producer_y: 15.00,
supply_shock: 0,
subsidies: 0,
matrix: None,
dragging: false,
}
}
fn data(&mut self, supply_shock: u8, subsidies: u8) {
self.supply_shock = supply_shock;
self.subsidies = subsidies;
self.producer_move(self.producer_x, self.producer_y);
}
fn reset_matrix(&mut self) {
self.matrix = None;
}
fn producer_move(&mut self, mouse_x: f64, mouse_y: f64) {
// * extra cost
let extra_y: i16 = i16::from(self.supply_shock) - i16::from(self.subsidies);
let t = Graphs::get_closest_point_to_cubic_bezier(
10,
mouse_x,
mouse_y,
0.,
1.,
20,
0.,
(extra_y + 80).into(),
10.,
(extra_y - 10).into(),
45.,
(extra_y - 10).into(),
80.,
(extra_y + 100).into(),
);
self.producer_x = 3. * f64::powi(1. - t, 2) * t * 10.
+ 3. * (1. - t) * f64::powi(t, 2) * 45.
+ f64::powi(t, 3) * 80.;
self.producer_y = f64::powi(1. - t, 3) * 80.
+ 3. * f64::powi(1. - t, 2) * t * -10.
+ 3. * (1. - t) * f64::powi(t, 2) * -10.
+ f64::powi(t, 3) * 100.
+ f64::from(extra_y);
}
// * Takes in number of iterations, the point to be projected, the start and end bounds on the guess, the resolution (slices), and the control points
// * Returns the t value of the minimum
#[allow(clippy::too_many_arguments)]
fn get_closest_point_to_cubic_bezier(
iterations: u32,
fx: f64,
fy: f64,
start: f64,
end: f64,
slices: u32,
x0: f64,
y0: f64,
x1: f64,
y1: f64,
x2: f64,
y2: f64,
x3: f64,
y3: f64,
) -> f64 {
if iterations == 0 {
return (start + end) / 2.;
};
let tick: f64 = (end - start) / f64::from(slices);
let (mut x, mut y);
let (mut dx, mut dy);
let mut best: f64 = 0.;
let mut best_distance: f64 = f64::INFINITY;
let mut current_distance: f64;
let mut t: f64 = start;
while t <= end {
//B(t) = (1-t)**3 p0 + 3(1 - t)**2 t P1 + 3(1-t)t**2 P2 + t**3 P3
x = (1. - t) * (1. - t) * (1. - t) * x0
+ 3. * (1. - t) * (1. - t) * t * x1
+ 3. * (1. - t) * t * t * x2
+ t * t * t * x3;
y = (1. - t) * (1. - t) * (1. - t) * y0
+ 3. * (1. - t) * (1. - t) * t * y1
+ 3. * (1. - t) * t * t * y2
+ t * t * t * y3;
dx = x - fx;
dy = y - fy;
dx = f64::powi(dx, 2);
dy = f64::powi(dy, 2);
current_distance = dx + dy;
if current_distance < best_distance {
best_distance = current_distance;
best = t;
}
t += tick;
}
Graphs::get_closest_point_to_cubic_bezier(
iterations - 1,
fx,
fy,
f64::max(best - tick, 0.),
f64::min(best + tick, 1.),
slices,
x0,
y0,
x1,
y1,
x2,
y2,
x3,
y3,
)
}
fn get_t_for_quantity(&self, t_0: f64, t_2: f64, x: f64, iterations: u32) -> f64 {
if iterations == 0 {
return t_0;
}
let t_1 = (t_0+t_2)/2.;
let x_1 = 3. * f64::powi(1. - t_1, 2) * t_1 * 10.
+ 3. * (1. - t_1) * f64::powi(t_1, 2) * 45.
+ f64::powi(t_1, 3) * 80. - x;
if x_1 > 0. {
self.get_t_for_quantity(t_0, t_1, x, iterations - 1)
}
else if x_1 < 0. {
self.get_t_for_quantity(t_1, t_2, x, iterations - 1)
}
else {
t_1
}
}
}
enum Msg {
Connect(Vec<String>), // connect to websocket server
Disconnected, // disconnected from server
Ignore, // ignore this message
Received(Result<ProducerServerMsg, Error>), // data received from server
PrepWsConnect,
StartClick(yew::MouseEvent),
MouseMove(yew::MouseEvent),
StartTouch(yew::TouchEvent),
TouchMove(yew::TouchEvent),
EndDrag,
Quantity(yew::InputData),
Price(yew::html::InputData),
Submit,
}
impl Model {
fn update_producers(&mut self, new_list: Vec<(String, Participant)>) {
self.producers.clear();
for producer in new_list {
self.producers.insert(producer.0, producer.1);
}
}
fn render_submit(&self) -> Html {
if self.took_turn || self.turn%2 == 0 {
html! {<button onclick=self.link.callback(|_| Msg::Submit) class="btn btn-danger disabled btn-block flex-grow-0 flex-shrink-1" type="submit" disabled=true>{"Submit and End Turn"}</button>}
}
else {
html! {<button onclick=self.link.callback(|_| Msg::Submit) class="btn btn-danger btn-block flex-grow-0 flex-shrink-1" type="submit">{"Submit and End Turn"}</button>}
}
}
}
impl Component for Model {
type Message = Msg;
type Properties = ();
fn create(_: Self::Properties, link: ComponentLink<Self>) -> Self {
Self {
link,
ws: None,
fetch_task: None,
producers: HashMap::new(),
graph_data: Graphs::new(),
game_id: "".to_string(),
turn: 0,
price: 0.,
balance: 0.,
score: 0.,
quantity: 0.,
took_turn: false,
error_msg: String::new(),
winner: None,
}
}
fn update(&mut self, msg: Self::Message) -> ShouldRender {
match msg {
Msg::Connect(v) => {
ConsoleService::log("Connecting");
let cbout = self.link.callback(|data: Result<Vec<u8>, anyhow::Error>| {
Msg::Received(Ok(from_slice::<ProducerServerMsg>(&data.unwrap()).unwrap()))
});
let cbnot = self.link.batch_callback(|input| {
ConsoleService::log(&format!("Notification: {:?}", input));
match input {
WebSocketStatus::Closed | WebSocketStatus::Error => {
std::vec![Msg::Disconnected]
}
_ => std::vec![Msg::Ignore],
}
});
if self.ws.is_none() {
let window = web_sys::window;
let host: String = window().unwrap().location().host().unwrap();
let protocol: String = window().unwrap().location().protocol().unwrap();
let url = match protocol.as_str() {
"http:" => {
format!("ws://{}/ws/{}/{}/{}", host, v[0], v[1], v[2])
}
"https:" => {
format!("wss://{}/ws/{}/{}/{}", host, v[0], v[1], v[2])
}
&_ => return false,
};
let task = match WebSocketService::connect_binary(&url, cbout, cbnot) {
Err(e) => {
ConsoleService::error(e);
None
}
Ok(f) => Some(f),
};
self.ws = task;
}
true
}
Msg::Disconnected => {
self.ws = None;
ConsoleService::log("Disconnected");
true
}
Msg::Ignore => false,
Msg::Received(Ok(s)) => {
match s.msg_type {
ProducerServerType::Info(info) => {
ConsoleService::log(&format!("{:?}",info));
self.producers.extend(info.producers.into_iter());
self.game_id = info.game_id;
self.turn = info.turn;
self.graph_data.data(info.supply_shock, info.subsidies);
self.balance = info.balance;
self.score = info.score;
self.took_turn = info.took_turn;
}
ProducerServerType::Ping => {
if let Some(ref mut task) = self.ws {
ConsoleService::log("Sending Pong");
task.send_binary(Ok(to_vec(&ProducerClientMsg {
msg_type: ProducerClientType::Pong,
})
.unwrap()));
}
return false;
}
ProducerServerType::ServerKicked => {
self.ws = None;
js! {
document.getElementById("kick-modal").click();
}
}
ProducerServerType::ChoiceFailed(fail_info) => {
self.error_msg = fail_info;
}
ProducerServerType::ChoiceSubmitted(a, b) => {
self.score = a; self.balance = b;
self.took_turn = true;
self.error_msg = "".to_string();
}
ProducerServerType::NewOffsets(offsets) => {
self.graph_data.data(
offsets.supply_shock,
offsets.subsidies,
);
}
ProducerServerType::TurnInfo(turn_info) => {
self.update_producers(turn_info.producers);
}
ProducerServerType::TurnAdvanced(balance,score) => {
self.turn += 1;
self.took_turn = false;
if self.turn%2 == 0 {
self.balance = 0.;
self.score = score;
}
else {
self.balance = balance;
}
}
ProducerServerType::StockReduced(targets) => {
for target in targets {
if let Some(producer) = self.producers.get_mut(&target.0) {
producer.remaining -= &target.1;
}
}
}
ProducerServerType::GameEnded => {
if self.winner.is_none() {
js! {
document.getElementById("end-modal").click();
}
}
}
ProducerServerType::GotPurchased(additional_score) => {
self.score += additional_score;
}
ProducerServerType::Winner(hash, place) => {
self.winner = Some((hash, place));
js! {
document.getElementById("win-modal").click();
}
}
}
true
}
Msg::Received(Err(_)) => {
ConsoleService::log("Error reading information from WebSocket");
true
}
Msg::PrepWsConnect => {
let post_request = Request::post("/wsprep").body(yew::format::Nothing).unwrap();
let callback = self
.link
.callback(|response: Response<Result<String, Error>>| {
if response.status().is_success() {
ConsoleService::log("Sent Request and Received Response with code: ");
ConsoleService::log(response.status().as_str());
let mut cookie_values: Vec<String> = Vec::new();
for cookie_value in response.body().as_ref().unwrap().split('\n') {
cookie_values.push(cookie_value.to_owned());
}
Msg::Connect(cookie_values)
} else {
ConsoleService::log("Failed to Send Websocket Open Request");
Msg::Ignore
}
});
let fetch_task = fetch::FetchService::fetch(post_request, callback).unwrap();
self.fetch_task = Some(fetch_task);
false
}
Msg::StartClick(event) => {
if let Some(target) = event.current_target() {
let element: SvggElement = target.dyn_ref::<SvggElement>().unwrap().clone();
let matrix: web_sys::SvgMatrix =
element.get_screen_ctm().unwrap().inverse().unwrap();
self.graph_data.matrix = Some((
matrix.a().into(),
matrix.b().into(),
matrix.c().into(),
matrix.d().into(),
matrix.e().into(),
matrix.f().into(),
));
let matrix = self.graph_data.matrix.unwrap();
let temp_x: f64 = event.client_x().into();
let temp_y: f64 = event.client_y().into();
let mouse_x = matrix.0 * temp_x + matrix.2 * temp_y + matrix.4;
let mouse_y = matrix.1 * temp_x + matrix.3 * temp_y + matrix.5;
self.graph_data.producer_move(mouse_x, mouse_y);
self.graph_data.dragging = true;
}
true
}
Msg::MouseMove(event) => {
if self.graph_data.dragging {
let matrix = self.graph_data.matrix.unwrap();
let temp_x: f64 = event.client_x().into();
let temp_y: f64 = event.client_y().into();
let mouse_x = matrix.0 * temp_x + matrix.2 * temp_y + matrix.4;
let mouse_y = matrix.1 * temp_x + matrix.3 * temp_y + matrix.5;
self.graph_data.producer_move(mouse_x, mouse_y);
true
} else {
false
}
}
Msg::EndDrag => {
self.graph_data.dragging = false;
self.graph_data.reset_matrix();
false
}
Msg::StartTouch(event) => {
let list = event.changed_touches();
if list.length() == 1 {
if let Some(touch) = list.get(0) {
let window = web_sys::window().unwrap();
let document = window.document().unwrap();
let temp_x: f64 = touch.client_x().into();
let temp_y: f64 = touch.client_y().into();
let string = "Producer Group";
let element: SvggElement = document
.get_element_by_id(string)
.unwrap()
.dyn_ref::<web_sys::SvggElement>()
.unwrap()
.clone();
let matrix: web_sys::SvgMatrix =
element.get_screen_ctm().unwrap().inverse().unwrap();
self.graph_data.matrix = Some((
matrix.a().into(),
matrix.b().into(),
matrix.c().into(),
matrix.d().into(),
matrix.e().into(),
matrix.f().into(),
));
let matrix = self.graph_data.matrix.unwrap();
let mouse_x = matrix.0 * temp_x + matrix.2 * temp_y + matrix.4;
let mouse_y = matrix.1 * temp_x + matrix.3 * temp_y + matrix.5;
self.graph_data.producer_move(mouse_x, mouse_y);
self.graph_data.dragging = true;
}
}
true
}
Msg::TouchMove(event) => {
if self.graph_data.dragging {
let list = event.touches();
if list.length() == 1 {
if let Some(touch) = list.get(0) {
let temp_x: f64 = touch.client_x().into();
let temp_y: f64 = touch.client_y().into();
let matrix = self.graph_data.matrix.unwrap();
let mouse_x = matrix.0 * temp_x + matrix.2 * temp_y + matrix.4;
let mouse_y = matrix.1 * temp_x + matrix.3 * temp_y + matrix.5;
self.graph_data.producer_move(mouse_x, mouse_y);
return true;
}
} else {
self.graph_data.dragging = false;
}
}
false
}
Msg::Quantity(data) => {
if let Ok(value) = data.value.parse() {
self.quantity = value;
}
false
}
Msg::Price(data) => {
if let Ok(value) = data.value.parse() {
self.price = value;
}
false
}
Msg::Submit => {
if let Some(ref mut task) = self.ws {
ConsoleService::log("Sending Submit");
let choice = ClientExtraFields {
quantity: self.quantity,
price: self.price,
t: self.graph_data.get_t_for_quantity(0., 1., self.quantity, 50),
};
task.send_binary(Ok(to_vec(&ProducerClientMsg {
msg_type: ProducerClientType::Choice(choice),
})
.unwrap()));
}
false
},
}
}
fn change(&mut self, _props: Self::Properties) -> ShouldRender {
false
}
fn rendered(&mut self, first_render: bool) {
if first_render {
self.link.send_message(Msg::PrepWsConnect);
}
}
fn view(&self) -> Html {
let producer_click_down = self.link.callback(Msg::StartClick);
let click_move = self.link.callback(Msg::MouseMove);
let producer_touch_start = self.link.callback(Msg::StartTouch);
let touch_move = self.link.callback(Msg::TouchMove);
let end_drag = self.link.callback(|_: yew::MouseEvent| Msg::EndDrag);
let change_quantity = self.link.callback(Msg::Quantity);
let change_price = self.link.callback(Msg::Price);
html! {
<>
<div class="container text-center">
<h1>{"Producer"}</h1>
<div class="row" style="margin-right: 0;margin-left: 0;">
<div class="col-md-6 text-center" style="padding: 0;min-height: 40vmin;">
<div class="d-flex flex-column" style="height: 100%;width: 100%;">
<h2>{"Marginal Cost"}</h2>
<div class="d-xl-flex flex-fill justify-content-xl-center align-items-xl-center" style="width: 100%;">
<svg viewBox="-5 -5 100 100" preserveAspectRatio="xMidYMid meet" fill="white" >
<g id="Producer Group" transform="scale(1,-1) translate(0,-90)" style="cursor:cell" onmousedown=producer_click_down onmousemove=click_move onmouseup=end_drag.clone() onmouseleave=end_drag.clone() ontouchstart=producer_touch_start ontouchmove=touch_move>
<rect width="105" height="105" x="-5" y="-5" fill-opacity="0%"></rect>
<text x="10" y="-70" style="font: 10px Georgia; " transform="scale(1,-1)">{format!("{:.2}, {:.2}",self.graph_data.producer_x,self.graph_data.producer_y)}</text>
<path d="M 0 80 C 10 -10, 45 -10, 80 100" stroke="#6495ED" stroke-width="1" stroke-opacity="60%" fill-opacity="0%" stroke-dasharray="4" />
<path d={
let net: i16 = i16::from(self.graph_data.supply_shock) - i16::from(self.graph_data.subsidies);
format!("M 0 {} C 10 {}, 45 {}, 80 {}", net+80, net-10, net-10, net+100)
} stroke="white" stroke-width="1" fill="transparent"/>
<polygon points="0,95 -5,90 -1,90 -1,-1 90,-1 90,-5 95,0 90,5 90,1 1,1 1,90 5,90" fill="#1F6DDE" />
<line x1="25" x2="25" y1="2" y2="-2" stroke="white" stroke-width="1"/>
<line x1="50" x2="50" y1="3" y2="-3" stroke="white" stroke-width="1"/>
<text y="-5" x="47" style="font: 5px Georgia; " transform="scale(1,-1)">{"50"}</text>
<line x1="75" x2="75" y1="2" y2="-2" stroke="white" stroke-width="1"/>
<line y1="25" y2="25" x1="2" x2="-2" stroke="white" stroke-width="1"/>
<line y1="50" y2="50" x1="3" x2="-3" stroke="white" stroke-width="1"/>
<line y1="75" y2="75" x1="2" x2="-2" stroke="white" stroke-width="1"/>
<circle cx={format!("{:.2}",self.graph_data.producer_x)} cy={format!("{:.2}",self.graph_data.producer_y)} r="3" stroke="white" fill="#F34547" stroke-width="0.2"/>
</g>
</svg>
</div>
<div class="d-flex">
<p class="text-center text-light mb-auto text-info" style="width: 50%;">{format!("Balance: {}", self.balance)}</p>
<p class="text-center text-light mb-auto text-info" style="width: 50%;">{format!("Score: {:.2}", self.score)}</p>
</div>
</div>
</div>
<div class="col-md-6 text-center d-flex flex-column" style="padding: 0;min-height: 40vmin;">
<h2>{"Marketplace"}</h2>
<p>{format!("Game ID: {}", self.game_id)}</p>
<p>{format!("Turn: {}", self.turn)}</p>
<div class="d-flex flex-column flex-grow-1 marketplace">
<h4>{"Previous Turn"}</h4>
<div class="flex-grow-1 flex-shrink-1 sellers" style="background: var(--dark);border-radius: 6px;border: 2px solid var(--secondary);margin: 8px;">
{self.producers.render()}
</div>
</div>
<form>
<div class="form-group"><label for="Quantity" style="width: 40%;">{"Quantity"}</label><input oninput=change_quantity class="form-control" type="number" placeholder="0" min="0" max="80"/></div>
<div class="form-group"><label for="Price" style="width: 40%;">{"Price"} </label><input oninput=change_price class="form-control" type="number" placeholder="0" min="0" max="100"/></div>
</form>
<div class="d-flex">
<p class="text-center text-danger mb-auto text-info" style="width: 100%;">{&self.error_msg}</p>
</div>
{
self.render_submit()
}
</div>
</div>
<footer>
<p>{"Built by Francis Chua"}</p>
</footer>
<button class="btn btn-danger border rounded" id="kick-modal" type="button" data-toggle="modal" data-target="#kicked-modal" hidden=true></button>
<div class="modal fade" role="dialog" tabindex="-1" id="kicked-modal">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<h4 class="modal-title">{"Kicked by Server"}</h4><button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">{"×"}</span></button>
</div>
<div class="modal-footer">
<a class="btn btn-info active" role="button" href="/login/index.html" id="test">{"Continue"}</a>
</div>
</div>
</div>
</div>
<button class="btn btn-danger border rounded" id="end-modal" type="button" data-toggle="modal" data-target="#ended-modal" hidden=true></button>
<div role="dialog" tabindex="-1" class="modal fade" id="ended-modal">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<h4 class="modal-title">{"Game Ended"}</h4><button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">{"×"}</span></button>
</div>
<div class="modal-body">
<p>{"This game has been ended by a Director."}</p>
</div>
<div class="modal-footer">
<a class="btn btn-info active" role="button" href="/login/index.html">{"Continue to Login"}</a>
</div>
</div>
</div>
</div>
<button class="btn btn-danger border rounded" id="win-modal" type="button" data-toggle="modal" data-target="#winner-modal" hidden=true></button>
<div role="dialog" tabindex="-1" class="modal fade" id="winner-modal">
<div class="modal-dialog" role="document">
<div class="modal-content">
<div class="modal-header">
<h4 class="modal-title">{"You Won!"}</h4><button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">{"×"}</span></button>
</div>
<div class="modal-body">
<p data-bss-hover-animate="swing">{&format!("You were in {} place. Your verification hash is: {}. ", Ordinal(self.winner.as_ref().unwrap_or(&("".to_string(), 0)).1).to_string(), self.winner.as_ref().unwrap_or(&("".to_string(), 0)).0)}</p>
</div>
<div class="modal-footer"><a class="btn btn-info active" role="button" href="/login/index.html">{"Continue to Login"}</a></div>
</div>
</div>
</div>
</div>
</>
}
}
}
#[wasm_bindgen(start)]
pub fn run_app() {
panic::set_hook(Box::new(console_error_panic_hook::hook));
App::<Model>::new().mount_to_body();
}
|
use crate::parse;
use crate::parse::{Code, LineNumber, Register, Span, Stmt, StmtIdx};
use std::io::Write;
use std::path::Path;
#[derive(Debug, Clone)]
struct Vm<'a> {
stmts: Vec<Stmt>,
span: Vec<Span>,
code_lines: Vec<&'a str>,
pc: StmtIdx,
registers: Vec<usize>,
breakpoints: Vec<StmtIdx>,
file_name: String,
}
#[derive(Debug, Copy, Clone)]
enum VmState {
Run,
Break,
Stop,
OutOfBounds,
}
impl Vm<'_> {
fn step(&mut self) -> VmState {
let pc = self.pc;
match self.stmts.get(pc.0).cloned() {
Some(Stmt::Inc(r)) => self.registers[r.0] += 1,
Some(Stmt::Dec(r)) => self.registers[r.0] -= 1,
Some(Stmt::IsZero(r, index)) => {
if self.registers[r.0] == 0 {
self.pc = StmtIdx(index.0 - 1);
}
}
Some(Stmt::Jump(index)) => self.pc = StmtIdx(index.0 - 1),
Some(Stmt::Stop) => return VmState::Stop,
None => return VmState::OutOfBounds,
}
self.pc.0 += 1;
if self.breakpoints.contains(&self.pc) {
VmState::Break
} else {
VmState::Run
}
}
fn run(&mut self, time_kind: VmRunKind) -> VmState {
let now = std::time::Instant::now();
loop {
if let state @ (VmState::Break | VmState::Stop | VmState::OutOfBounds) = self.step() {
if let VmRunKind::WithTime = time_kind {
println!("Vm ran for {}ms.", now.elapsed().as_millis());
}
return state;
}
}
}
fn statement_at_span(&self, search_span: Span) -> Option<StmtIdx> {
self.span
.iter()
.position(|span| *span >= search_span)
.map(|idx| StmtIdx(idx))
}
}
#[derive(Debug, Copy, Clone)]
enum VmRunKind {
WithTime,
WithoutTime,
}
#[derive(Debug, Copy, Clone)]
enum VmInstruction {
Step,
Run(VmRunKind),
Break(StmtIdx),
Set(Register, usize),
Stop,
}
pub fn start(program_path: Option<String>) {
if let Some(path) = program_path {
read_and_run(&path);
}
loop {
match loading_input() {
LoadInstruction::Quit => return,
LoadInstruction::Load(path) => read_and_run(&path),
}
}
}
fn read_and_run(path: &str) {
let path = Path::new(path);
match std::fs::read_to_string(path) {
Ok(content) => match parse::parse(&content, filename(path)) {
Ok(stmts) => run(stmts),
Err(why) => eprintln!("{}", why),
},
Err(why) => eprintln!("error while reading file: {}.", why),
};
}
#[derive(Debug, Clone)]
enum LoadInstruction {
Quit,
Load(String),
}
fn loading_input() -> LoadInstruction {
loop {
let input = get_input(None);
let mut iter = input.split_whitespace();
if let Some(str) = iter.next() {
match str {
"l" | "load" => match iter.next() {
Some(path) => return LoadInstruction::Load(path.to_owned()),
None => println!("error: No file path provided to load from."),
},
"h" | "help" => print_load_help(),
"q" | "quit" => return LoadInstruction::Quit,
cmd => println!("error: Unknown command: {}.", cmd),
}
}
}
}
fn filename(path: &Path) -> String {
path.file_stem().unwrap().to_str().unwrap().to_owned()
}
fn run(code: Code) {
println!("Loaded {}.", code.file_name);
let max_register_index = max_register(&code.stmts);
let mut vm = Vm {
stmts: code.stmts,
span: code.span,
code_lines: code.code_lines,
file_name: code.file_name,
pc: StmtIdx(0),
registers: vec![0; max_register_index + 1],
breakpoints: vec![],
};
loop {
match debug_input(&vm) {
VmInstruction::Stop => break,
VmInstruction::Run(time_kind) => match vm.run(time_kind) {
VmState::Stop => break,
VmState::OutOfBounds => {
print_program(&vm);
print_registers(&vm);
eprintln!("error: Program ran out of bounds.");
return;
}
VmState::Run => {
unreachable!("internal error: Program still running after returning from run.")
}
_ => {}
},
VmInstruction::Step => match vm.step() {
VmState::Stop => break,
VmState::OutOfBounds => {
print_program(&vm);
print_registers(&vm);
eprintln!("error: Program ran out of bounds.");
return;
}
_ => {}
},
VmInstruction::Break(line) => {
let position = vm.breakpoints.iter().position(|point| *point == line);
match position {
None => vm.breakpoints.push(line),
Some(pos) => {
vm.breakpoints.remove(pos);
}
}
}
VmInstruction::Set(r, value) => vm.registers[r.0] = value,
}
}
println!("Execution finished.");
}
fn debug_input(vm: &Vm) -> VmInstruction {
loop {
let input = get_input(Some(&vm.file_name));
let mut iter = input.split_whitespace();
if let Some(str) = iter.next() {
match str {
"r" | "register" => print_registers(vm),
"p" | "program" => print_program(vm),
"h" | "?" | "help" => print_debug_help(),
"b" | "break" => match iter.next() {
Some(line_number) => match line_number.parse::<usize>() {
Ok(line_number) => {
let stmt_pos =
match vm.statement_at_span(LineNumber(line_number).span()) {
Some(pos) => pos,
None => {
println!(
"error: Line number '{}' out of bounds for length {}.",
line_number,
vm.code_lines.len()
);
continue;
}
};
return VmInstruction::Break(stmt_pos);
}
Err(_) => println!("error: Invalid argument provided."),
},
None => print_breakpoints(vm),
},
"set" => match parse_set_command(&mut iter) {
Some((reg, value)) => return VmInstruction::Set(reg, value),
None => println!("error: Invalid arguments provided."),
},
"c" | "continue" => {
if let Some("time") = iter.next() {
return VmInstruction::Run(VmRunKind::WithTime);
}
return VmInstruction::Run(VmRunKind::WithoutTime);
}
"s" | "step" => return VmInstruction::Step,
"q" | "quit" => return VmInstruction::Stop,
cmd => println!("error: Unknown command: {}.", cmd),
}
}
}
}
fn parse_set_command<'a>(iter: &mut impl Iterator<Item = &'a str>) -> Option<(Register, usize)> {
let reg = iter.next().and_then(|reg| reg.parse().ok())?;
let value = iter.next().and_then(|value| value.parse().ok())?;
Some((Register(reg), value))
}
fn max_register(stmts: &[Stmt]) -> usize {
stmts
.iter()
.map(|stmt| match stmt {
Stmt::Inc(r) => r.0,
Stmt::Dec(r) => r.0,
Stmt::IsZero(r, _) => r.0,
Stmt::Jump(_) => 0,
Stmt::Stop => 0,
})
.max()
.unwrap_or(0)
}
fn print_registers(vm: &Vm) {
println!("Registers:");
for (i, r) in vm.registers.iter().enumerate() {
println!("{: >4} : {}", i, r);
}
}
fn print_program(vm: &Vm) {
use std::cmp::min;
if let Some(span_pc) = vm.span.get(vm.pc.0) {
println!("Program:");
let lower = span_pc.0.saturating_sub(5);
let higher = min(vm.code_lines.len(), span_pc.0 + 6);
for line_index in lower..higher {
let code_line = vm.code_lines[line_index];
if line_index == span_pc.0 {
println!("> {} {}", Span(line_index).line_number(), code_line);
} else {
println!("{} {}", Span(line_index).line_number(), code_line);
}
}
} else {
println!("Reached the end of the program.");
}
}
fn print_breakpoints(vm: &Vm) {
println!(
"Breakpoints:
{}
",
vm.breakpoints
.iter()
.map(|p| p.0.to_string())
.collect::<Vec<String>>()
.join(", ")
);
}
fn print_load_help() {
println!(
"List of commands and their aliases:
load (l) <filename> -- Load and run a program
quit (q) -- Quits the program
help (h, ?) -- Shows this help page
"
);
}
fn print_debug_help() {
println!(
"List of commands and their aliases:
step (s) -- Steps the program forward by one step
set <register> <value> -- Sets a register to a value
break <line> (b) -- Set a breakpoint to a line, use again to toggle
continue (c) (time) -- Run the program until the next breakpoint, add 'time' to display execution time
register (r) -- Shows the contents of the registers
program (p) -- Shows where the program currently is
quit (q) -- Stop execution of the current program
help (h, ?) -- Shows this help page
"
);
}
fn get_input(prompt: Option<&str>) -> String {
let mut input_buf = String::new();
match prompt {
None => print!("(m8db) "),
Some(text) => print!("(m8db - {}) ", text),
}
std::io::stdout().flush().unwrap();
std::io::stdin().read_line(&mut input_buf).unwrap();
input_buf.trim().to_owned()
}
|
use std::fmt;
use std::time::SystemTime;
pub struct ElapsedMetrics {
load:String,
resize:String,
save:String,
timer:SystemTime,
}
impl ElapsedMetrics {
pub fn new() -> ElapsedMetrics {
ElapsedMetrics {
load: String::new(),
resize: String::new(),
save: String::new(),
timer: SystemTime::now(),
}
}
pub fn start(&mut self) {
self.timer = SystemTime::now();
}
pub fn set_load_time(&mut self) {
match self.timer.elapsed() {
Ok(elapsed) => {
self.load = format!("{}.{:03}",elapsed.as_secs(),elapsed.subsec_millis());
}
Err(e) => {
// an error occurred!
println!("Error: {:?}", e);
}
}
}
pub fn set_resize_time(&mut self) {
match self.timer.elapsed() {
Ok(elapsed) => {
self.resize = format!("{}.{:03}",elapsed.as_secs(),elapsed.subsec_millis());
}
Err(e) => {
// an error occurred!
println!("Error: {:?}", e);
}
}
}
pub fn set_save_time(&mut self) {
match self.timer.elapsed() {
Ok(elapsed) => {
self.save = format!("{}.{:03}",elapsed.as_secs(),elapsed.subsec_millis());
}
Err(e) => {
// an error occurred!
println!("Error: {:?}", e);
}
}
}
}
impl fmt::Debug for ElapsedMetrics {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "load: {}\nresize: {}\nsave: {}",
self.load, self.resize, self.save)
}
} |
use sample_web_app::{init_db, users_api};
#[tokio::main]
async fn main() {
let database = init_db();
warp::serve(users_api(database))
.run(([127, 0, 0, 1], 3030))
.await;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.