text stringlengths 8 4.13M |
|---|
use std::fs::File;
use std::io::{prelude::*, BufReader};
use std::u16;
// 1: I, 2: DT, 3: ST
struct Instr {
name: String,
params: Vec<String>,
refs_label: bool,
has_immediate: bool,
special_register: u8,
special_register_src: bool,
address: u16
}
struct Label {
name: String,
address: u16
}
struct Directive {
name: String,
dtype: u8,
data: u16
}
struct Data {
data: Vec<u8>,
address: u16
}
fn is_label(word: &str) -> bool {
!word.starts_with("@") && word.ends_with(":")
}
fn is_preprocessor(word: &str) -> bool {
word.starts_with("@")
}
fn num_params_valid_for_instruction(num_params: usize, word: &str) -> bool {
match word {
"cls" | "ret" | "sys" => return num_params == 0,
"jmp" => return num_params == 1 || num_params == 2,
"call" | "skp" | "sknp" => return num_params == 1,
"se" | "sne" | "shl" | "shr" | "ld" | "or" | "and" | "xor" | "add" | "sub" | "rnd" | "subn" => return num_params == 2,
"drw" => return num_params == 3,
_ => return false
}
}
fn immediate_is_valid(imm: &str, max_size: u16) -> bool {
if String::from(imm).starts_with("0x") {
let no_prefix = imm.trim_start_matches("0x");
let result = u16::from_str_radix(no_prefix, 16);
return result.is_ok() && result.unwrap() <= max_size;
} else if String::from(imm).starts_with("0b") {
let no_prefix = imm.trim_start_matches("0b");
let result = u16::from_str_radix(no_prefix, 2);
return result.is_ok() && result.unwrap() <= max_size;
}
let result = u16::from_str_radix(imm, 10);
result.is_ok() && result.unwrap() <= max_size
}
fn param_valid_for_instruction(param: &str, index: usize, instr: &mut Instr) -> bool {
static REGISTER_TOKENS: [&str; 0x10] = ["v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "va", "vb", "vc", "vd", "ve", "vf"];
static SPECIAL_REGISTER_TOKENS: [&str; 0x4] = ["I" , "dt", "st", "key"];
match instr.name.as_str() {
"jmp" => {
if index == 0 {
if param == REGISTER_TOKENS[0] {
return true;
}
let is_immediate = immediate_is_valid(param, 0xfff);
if !is_immediate {
instr.refs_label = true;
return true;
}
return is_immediate;
} else if index == 1 {
instr.has_immediate = true;
return immediate_is_valid(param, 0xfff);
}
return false;
},
"call" => {
if index == 0 {
let is_immediate = immediate_is_valid(param, 0xfff);
if !is_immediate {
instr.refs_label = true;
return true;
}
return is_immediate;
}
return false;
},
"rnd" => {
if index == 0 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
return false;
} else if index == 1 {
instr.has_immediate = true;
return immediate_is_valid(param, 0xff);
}
return false;
},
"se" | "sne" | "add" => {
if index == 0 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
return false;
} else if index == 1 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
instr.has_immediate = true;
return immediate_is_valid(param, 0xff);
}
return false;
},
"skp" | "sknp" => {
if index == 0 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
}
return false;
},
"sub" | "xor" | "or" | "and" => {
if index == 0 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
} else if index == 1 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
}
return false;
}
"ld" => {
if index == 0 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
for (index, token) in SPECIAL_REGISTER_TOKENS.iter().enumerate() {
if ¶m == token {
instr.special_register = index as u8 + 1;
instr.special_register_src = false;
return true;
}
}
return false;
} else if index == 1 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
if instr.special_register > 1 {
return false;
}
// LD i, addr can be up to 0xfff
if instr.special_register == 1 {
instr.has_immediate = true;
let is_immediate = immediate_is_valid(param, 0xfff);
if !is_immediate {
instr.refs_label = true;
return true;
}
return is_immediate;
} else {
for (index, token) in SPECIAL_REGISTER_TOKENS.iter().enumerate() {
if ¶m == token {
instr.special_register = index as u8 + 1;
instr.special_register_src = true;
return true;
}
}
}
instr.has_immediate = true;
return immediate_is_valid(param, 0xff);
}
return false;
},
"drw" => {
if index == 0 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
} else if index == 1 {
for token in REGISTER_TOKENS.iter() {
if ¶m == token {
return true;
}
}
} else if index == 2 {
return immediate_is_valid(param, 0xf);
}
return false;
}
_ => return false
}
}
/*
fn valid_tokens_for_param<'a>() -> Vec<&'a str> {
vec!["cum!"]
}*/
fn num_for_string(hex: &str, force_hex: bool) -> u16 {
if force_hex {
return u16::from_str_radix(hex, 16).unwrap();
}
let has_hex_prefix = String::from(hex).starts_with("0x");
if has_hex_prefix {
let no_prefix = hex.trim_start_matches("0x");
return u16::from_str_radix(no_prefix, 16).unwrap();
}
let has_binary_prefix = String::from(hex).starts_with("0b");
if has_binary_prefix {
let no_prefix = hex.trim_start_matches("0b");
return u16::from_str_radix(no_prefix, 2).unwrap();
}
u16::from_str_radix(hex, 10).unwrap()
}
fn opcode_for_instruction(instr: &Instr, valid_labels: &Vec<Label>) -> u16 {
match instr.name.as_str() {
"cls" => return 0x00E0,
"ret" => return 0x00EE,
"sys" => return 0,
"jmp" => {
if instr.params.len() == 1 {
if instr.refs_label {
for label in valid_labels {
if label.name == instr.params[0] {
let addr = label.address;
//println!("label address: {}", addr);
return 0x1000 | (addr & 0x0fff);
}
}
println!("Invalid label for instruction {}", instr.name);
return 0xFFFF;
} else {
let addr = num_for_string(instr.params[0].as_str(), false);
return 0x1000 | (addr & 0x0fff);
}
} else {
let addr = num_for_string(instr.params[1].as_str(), false);
return 0xB000 | (addr & 0x0fff);
}
},
"call" => {
if instr.refs_label {
for label in valid_labels {
if label.name == instr.params[0] {
let addr = label.address;
//println!("label address: {}", addr);
return 0x2000 | (addr & 0x0fff);
}
}
println!("Invalid label for instruction {}", instr.name);
return 0xFFFF;
} else {
let addr = num_for_string(instr.params[0].as_str(), false);
return 0x2000 | (addr & 0x0fff);
}
},
"se" => {
if instr.has_immediate {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
let imm = num_for_string(&instr.params[1], false);
return 0x3000 | (reg_num << 8) | (imm & 0xff);
} else {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x5000 | (dest_reg_num << 8) | (src_reg_num << 4);
}
},
"sne" => {
if instr.has_immediate {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
let imm = num_for_string(&instr.params[1], false);
return 0x4000 | (reg_num << 8) | (imm & 0xff);
} else {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x9000 | (dest_reg_num << 8) | (src_reg_num << 4);
}
},
"skp" => {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
return 0xE09E | (reg_num << 8);
},
"sknp" => {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
return 0xE0A1 | (reg_num << 8);
},
"ld" => {
///println!("hmm");
//println!("type: {}\n", instr.special_register as u32);
if instr.has_immediate {
if instr.special_register > 0 {
// I
match instr.special_register {
1 => {
if instr.refs_label {
for label in valid_labels {
//println!("label name {}", label.name);
if label.name == instr.params[1] {
let addr = label.address;
return 0xA000 | (addr & 0x0fff);
}
}
println!("Invalid label for instruction {}", instr.name);
return 0xFFFF;
} else {
let val = num_for_string(&instr.params[1], false);
return 0xA000 | (val & 0x0fff);
}
},
2 => {
return 0;
},
3 => {
return 0;
}
_ => return 0
}
} else {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
let imm = num_for_string(&instr.params[1], false);
return 0x6000 | (reg_num << 8) | (imm & 0xff);
}
} else {
println!("hmm");
if instr.special_register > 0 {
if instr.special_register_src {
if instr.special_register == 2 {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
return 0xF007 | reg_num << 8;
} else {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
return 0xF00A | reg_num << 8;
}
return 0xFF;
} else {
if instr.special_register == 2 {
let no_register_prefix = &instr.params[1][1..2];
let reg_num = num_for_string(no_register_prefix, true);
return 0xF015 | reg_num << 8;
} else {
let no_register_prefix = &instr.params[1][1..2];
let reg_num = num_for_string(no_register_prefix, true);
return 0xF018 | reg_num << 8;
}
}
} else {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x8000 | (dest_reg_num << 8) | (src_reg_num << 4);
}
}
},
"or" => {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x8001 | (dest_reg_num << 8) | (src_reg_num << 4);
},
"and" => {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x8002 | (dest_reg_num << 8) | (src_reg_num << 4);
},
"xor" => {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x8003 | (dest_reg_num << 8) | (src_reg_num << 4);
},
"add" => {
if instr.has_immediate {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
let imm = num_for_string(&instr.params[1], false);
return 0x7000 | (reg_num << 8) | (imm & 0xff);
} else {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x8004 | (dest_reg_num << 8) | (src_reg_num << 4);
}
},
"rnd" => {
let no_register_prefix = &instr.params[0][1..2];
let reg_num = num_for_string(no_register_prefix, true);
let imm = num_for_string(&instr.params[1], false);
return 0xC000 | (reg_num << 8) | (imm & 0xff);
},
"drw" => {
let reg_x_str = &instr.params[0][1..2];
let reg_y_str = &instr.params[1][1..2];
let reg_x = num_for_string(reg_x_str, true);
let reg_y = num_for_string(reg_y_str, true);
let num_bytes = num_for_string(&instr.params[2], false);
return 0xD000 | (reg_x << 8) | (reg_y << 4) | (num_bytes & 0xf);
}
"sub" => {
let dest_reg = &instr.params[0][1..2];
let dest_reg_num = num_for_string(dest_reg, true);
let src_reg = &instr.params[1][1..2];
let src_reg_num = num_for_string(src_reg, true);
return 0x8005 | (dest_reg_num << 8) | (src_reg_num << 4);
}
_ => return 0
}
}
fn instruction_is_valid(word: &str) -> bool {
static VALID_INSTRUCTIONS: [&str; 20] = ["cls", "ret", "sys", "jmp", "call", "se", "sne",
"ld", "or", "and", "xor", "add", "sub", "shr",
"subn", "shl", "rnd", "drw", "skp", "sknp"];
for string in VALID_INSTRUCTIONS.iter() {
// check if the instruction is valid
if &word == string {
return true;
}
}
false
}
fn remove_suffix<'a>(s: &'a str, p: &str) -> &'a str {
if s.ends_with(p) {
return &s[..s.len() - p.len()];
} else {
s
}
}
fn remove_prefix<'a>(s: &'a str, p: &str) -> &'a str {
if s.starts_with(p) {
&s[p.len()..]
} else {
s
}
}
fn expected_params_for_directive(name: &str) -> u32 {
match name {
"org" => return 1,
"db" => return 1,
_ => 0
}
}
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
if args.len() < 3 {
println!("Usage: chip8asm <input file> <output file>");
return;
}
let input = &args[1];
let output = &args[2];
let file_result = File::open(input);
if !file_result.is_ok() {
println!("Error opening file {}", input);
return;
}
let file = file_result.unwrap();
let reader = BufReader::new(file);
let mut instrs: Vec<Instr> = Vec::new();
let mut labels: Vec<Label> = Vec::new();
let mut data: Vec<Data> = Vec::new();
let mut current_address: u16 = 0x200;
let mut max_rom_size: usize = 0;
for (line_number, line) in reader.lines().enumerate() {
let current_line: String = line.unwrap();
let words: Vec<&str> = current_line.split_whitespace().collect();
if words.len() > 0 {
//comment
if words[0].starts_with(";") {
continue;
}
let mut word_offset = 0;
// add label to label list, possibly add instruction
if is_label(words[word_offset]) {
let new_label = Label {
name: String::from(remove_suffix(words[word_offset], ":")),
address: current_address as u16
};
labels.push(new_label);
// no instructions after
if words.len() < 2 {
continue;
}
word_offset += 1;
} else if is_preprocessor(words[word_offset]) {
let directive_name = remove_prefix(words[word_offset], "@");
let mut new_directive = Directive {
name: String::from(directive_name),
dtype: 0,
data: 0
};
let num_params_for_directive = expected_params_for_directive(directive_name);
let num_params = words.len() - word_offset - 1;
if num_params != num_params_for_directive as usize && directive_name != "db" {
println!("Invalid parameters for directive \"{}\" on line {}", directive_name, line_number + 1);
return;
}
if directive_name == "org" {
new_directive.dtype = 1;
new_directive.data = num_for_string(words[word_offset + 1], false);
if new_directive.data >= 0x1000 {
println!("Location beyond bounds");
return;
}
current_address = new_directive.data;
} else if directive_name == "db" {
new_directive.dtype = 2;
let mut new_data = Data {
data: Vec::new(),
address: current_address
};
for i in 1..num_params + 1 {
let num_str = String::from(words[i]);
let value: u8 = num_for_string(num_str.trim_end_matches(","), false) as u8;
new_data.data.push(value);
}
if num_params & 1 != 0 {
current_address += (num_params + 1) as u16;
} else {
current_address += num_params as u16;
}
data.push(new_data);
if current_address as usize > max_rom_size {
max_rom_size = current_address as usize;
}
} else {
println!("Invalid directive \"{}\" on line {}", directive_name, line_number + 1);
return;
}
continue;
}
let word = words[word_offset];
if instruction_is_valid(word) {
let mut new_instr = Instr {
name: String::from(word),
has_immediate: false,
refs_label: false,
params: Vec::new(),
special_register: 0,
special_register_src: false,
address: current_address as u16
};
let num_params = words.len() - word_offset - 1;
if num_params_valid_for_instruction(num_params, word) {
for i in 0..num_params {
let mut the_str = String::from(words[i + 1 + word_offset]);
if !param_valid_for_instruction(the_str.trim_end_matches(","), i, &mut new_instr) {
println!("Error: Invalid parameter {} on line {}... exiting", words[i + 1 + word_offset], line_number + 1);
return;
}
// enforce comma for parameters
if i < num_params - 1 {
if the_str.ends_with(",") {
the_str.truncate(the_str.len() - 1);
} else {
println!("Error: Separate parameters on line {} with a comma", line_number + 1);
return;
}
}
new_instr.params.push(the_str);
}
} else {
println!("Error: Invalid parameters on line {}", line_number + 1);
return;
}
instrs.push(new_instr);
current_address += 2;
} else {
println!("{} on line {} is not a valid instruction", word, line_number + 1);
return;
}
}
if current_address as usize > max_rom_size {
max_rom_size = current_address as usize;
}
}
let mut byte_buffer: [u8; 0xE00] = [0; 0xE00];
for dat in data {
for index in 0..dat.data.len() {
byte_buffer[(dat.address - 0x200 + index as u16) as usize] = dat.data[index];
}
}
for instr in instrs {
let opcode: u16 = opcode_for_instruction(&instr, &labels);
//invalid opcode or error
if opcode == 0xFFFF {
return;
}
byte_buffer[(instr.address - 0x200) as usize] = (opcode >> 8) as u8;
byte_buffer[(instr.address - 0x200 + 1) as usize] = (opcode & 0xff) as u8;
}
// write opcodes to file
let mut buffer = File::create(output).expect("error opening output file");
//while pos < max_rom_size {
let bytes_written = buffer.write(&byte_buffer[0..(max_rom_size - 0x200)]);
if bytes_written.unwrap() == 0 {
println!("Error writing output file");
}
} |
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under both the MIT license found in the
* LICENSE-MIT file in the root directory of this source tree and the Apache
* License, Version 2.0 found in the LICENSE-APACHE file in the root directory
* of this source tree.
*/
use futures_old::{future, stream, Stream};
use futures_stats::{Timed, TimedStreamTrait};
fn main() {
let mut runtime = tokio_old::runtime::Runtime::new().unwrap();
let fut = future::lazy(|| {
println!("future polled");
Ok(())
})
.timed(|stats, _: Result<&(), &()>| {
println!("{:#?}", stats);
Ok(())
});
runtime.block_on(fut).unwrap();
let stream = stream::iter_ok([1, 2, 3].iter()).timed(|stats, _: Result<_, &()>| {
println!("{:#?}", stats);
Ok(())
});
runtime.block_on(stream.for_each(|_| Ok(()))).unwrap();
let empty: Vec<u32> = vec![];
let stream = stream::iter_ok(empty.into_iter()).timed(|stats, _: Result<_, &()>| {
assert!(stats.first_item_time.is_none());
Ok(())
});
runtime.block_on(stream.for_each(|_| Ok(()))).unwrap();
}
|
use crate::{
codegen::{AatbeModule, ValueTypePair},
fmt::AatbeFmt,
ty::variant::{Variant, VariantType},
};
use parser::ast::{FloatSize, FunctionType, IntSize, PrimitiveType};
use llvm_sys_wrapper::{LLVMFunctionType, LLVMTypeRef, LLVMValueRef};
use std::{collections::HashMap, fmt};
pub mod aggregate;
pub mod infer;
pub mod record;
pub mod size;
pub mod variant;
pub use aggregate::Aggregate;
pub use record::Record;
#[derive(Debug)]
pub enum TypeError {
NotFound(String),
NotFoundPrim(PrimitiveType),
VariantOOB(String, u32),
RecordIndexOOB(String, u32),
NamedOnVariant(String, String),
RecordNameNotFound(String, String),
}
pub type TypeResult<T> = Result<T, TypeError>;
pub enum TypeKind {
RecordType(Record),
Primitive(PrimitiveType),
Typedef(TypedefKind),
}
pub enum TypedefKind {
Opaque(LLVMTypeRef),
Newtype(LLVMTypeRef, PrimitiveType),
VariantType(VariantType),
}
impl fmt::Debug for TypeKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TypeKind::Primitive(prim) => write!(f, "Primitive({})", AatbeFmt::fmt(prim)),
TypeKind::RecordType(rec) => write!(f, "RecordType({})", rec.name()),
TypeKind::Typedef(tk) => write!(f, "Typedef({:?})", tk),
}
}
}
impl fmt::Debug for TypedefKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TypedefKind::Opaque(ty) => write!(f, "Opaque({:?})", ty),
TypedefKind::Newtype(ty, prim) => {
write!(f, "RecordType({:?}, {})", ty, AatbeFmt::fmt(prim))
}
TypedefKind::VariantType(ty) => write!(f, "VariantType({:?})", ty),
}
}
}
impl LLVMTyInCtx for TypeKind {
fn llvm_ty_in_ctx(&self, module: &AatbeModule) -> LLVMTypeRef {
match self {
TypeKind::RecordType(record) => record.llvm_ty_in_ctx(module),
TypeKind::Primitive(primitive) => primitive.llvm_ty_in_ctx(module),
TypeKind::Typedef(TypedefKind::Opaque(ty)) => *ty,
TypeKind::Typedef(TypedefKind::Newtype(ty, _)) => *ty,
TypeKind::Typedef(TypedefKind::VariantType(VariantType { ty, .. })) => *ty,
}
}
}
impl TypeKind {
fn record(&self) -> Option<&Record> {
match self {
TypeKind::RecordType(record) => Some(record),
_ => None,
}
}
fn typedef(&self) -> Option<&TypedefKind> {
match self {
TypeKind::Typedef(ty) => Some(ty),
_ => None,
}
}
fn variant_mut(&mut self) -> Option<&mut VariantType> {
match self {
TypeKind::Typedef(TypedefKind::VariantType(ty)) => Some(ty),
_ => None,
}
}
}
pub struct TypeContext {
types: HashMap<String, TypeKind>,
}
impl TypeContext {
pub fn new() -> Self {
Self {
types: HashMap::new(),
}
}
pub fn push_type(&mut self, name: &String, ty: TypeKind) {
if self.types.contains_key(name) {
panic!("Type {} already in context", name);
} else {
self.types.insert(name.clone(), ty);
}
}
pub fn get_type(&self, name: &String) -> Option<&TypeKind> {
self.types.get(name)
}
pub fn llvm_ty_in_ctx(&self, name: &String) -> Option<&dyn LLVMTyInCtx> {
self.get_type(name)
.map(|t| t as &dyn LLVMTyInCtx)
.or_else(|| self.get_variant(name).map(|t| t as &dyn LLVMTyInCtx))
}
pub fn get_aggregate(&self, name: &String) -> Option<&dyn Aggregate> {
match self.types.get(name)? {
TypeKind::RecordType(record) => Some(record),
//TypeKind::Typedef(TypedefKind::Variant(variant)) => Some(variant),
_ => None,
}
}
pub fn get_aggregate_from_prim(&self, prim: &PrimitiveType) -> Option<&dyn Aggregate> {
match prim {
PrimitiveType::TypeRef(name) => match self.types.get(name) {
Some(TypeKind::RecordType(record)) => Some(record as &dyn Aggregate),
_ => None,
},
PrimitiveType::VariantType(name) => match self.get_variant(name) {
Some(variant) => Some(variant as &dyn Aggregate),
_ => None,
},
PrimitiveType::Variant { variant, .. } => match self.get_variant(variant) {
Some(variant) => Some(variant as &dyn Aggregate),
_ => None,
},
_ => None,
}
}
pub fn get_variant(&self, name: &String) -> Option<&Variant> {
self.types
.values()
.filter_map(|ty| match ty {
TypeKind::Typedef(TypedefKind::VariantType(variant)) => variant.get_variant(name),
_ => None,
})
.nth(0)
}
pub fn push_variant(
&mut self,
parent_name: &String,
variant_name: &String,
variant: Variant,
) -> Result<(), TypeError> {
self.types
.get_mut(parent_name)
.and_then(|ty| ty.variant_mut())
.ok_or(TypeError::NotFound(parent_name.clone()))
.map(|var| var.push_variant(variant_name, variant))
}
pub fn get_parent_for_variant(&self, name: &String) -> Option<&VariantType> {
self.types
.values()
.filter_map(|ty| match ty {
TypeKind::Typedef(TypedefKind::VariantType(variant))
if variant.has_variant(name) =>
{
Some(variant)
}
_ => None,
})
.nth(0)
}
pub fn get_record(&self, name: &String) -> TypeResult<&Record> {
self.types
.get(name)
.and_then(|ty| ty.record())
.ok_or(TypeError::NotFound(name.clone()))
}
pub fn get_typedef(&self, name: &String) -> TypeResult<&TypedefKind> {
self.types
.get(name)
.and_then(|ty| ty.typedef())
.ok_or(TypeError::NotFound(name.clone()))
}
pub fn gep_fields(
&self,
module: &AatbeModule,
ty: &dyn Aggregate,
fields: Vec<String>,
reference: LLVMValueRef,
) -> TypeResult<ValueTypePair> {
match fields.as_slice() {
[field] => ty.gep_field(module, field, reference),
[field, subfields @ ..] => {
let field = ty.gep_field(module, field, reference)?;
let prim = field.prim();
let ty = self
.get_aggregate_from_prim(&prim.clone())
.ok_or(TypeError::NotFoundPrim(prim.clone()))?;
self.gep_fields(module, ty, subfields.to_vec(), *field)
}
[] => unreachable!(),
}
}
}
pub trait LLVMTyInCtx {
fn llvm_ty_in_ctx(&self, module: &AatbeModule) -> LLVMTypeRef;
}
impl LLVMTyInCtx for FunctionType {
fn llvm_ty_in_ctx(&self, module: &AatbeModule) -> LLVMTypeRef {
let ret = self.ret_ty.llvm_ty_in_ctx(module);
let mut varargs = false;
let ext = self.ext;
let mut param_types = self
.params
.iter()
.filter_map(|t| match t {
PrimitiveType::TypeRef(name) => {
Some(module.typectx_ref().get_type(name)?.llvm_ty_in_ctx(module))
}
PrimitiveType::Symbol(_) => None,
PrimitiveType::Unit => None,
PrimitiveType::Varargs => {
varargs = true;
None
}
PrimitiveType::NamedType {
ty: Some(box PrimitiveType::Slice { ty: box ty }),
..
}
| PrimitiveType::Slice { ty: box ty }
if ext =>
{
Some(
module
.llvm_context_ref()
.PointerType(ty.llvm_ty_in_ctx(module)),
)
}
_ => Some(t.llvm_ty_in_ctx(module)),
})
.collect::<Vec<_>>();
unsafe {
LLVMFunctionType(
ret,
param_types.as_mut_ptr(),
param_types.len() as u32,
varargs as i32,
)
}
}
}
impl LLVMTyInCtx for PrimitiveType {
fn llvm_ty_in_ctx(&self, module: &AatbeModule) -> LLVMTypeRef {
let ctx = module.llvm_context_ref();
match self {
PrimitiveType::Slice { ty } => ctx
.StructType(
&mut vec![
ctx.PointerType(ctx.ArrayType(ty.llvm_ty_in_ctx(module), 0)),
ctx.Int32Type(),
],
false,
)
.as_ref(),
PrimitiveType::Array { ty, len } => ctx.ArrayType(ty.llvm_ty_in_ctx(module), *len),
PrimitiveType::Ref(r) => ctx.PointerType(r.llvm_ty_in_ctx(module)),
PrimitiveType::Unit => ctx.VoidType(),
PrimitiveType::Bool => ctx.Int1Type(),
PrimitiveType::Int(IntSize::Bits8) | PrimitiveType::UInt(IntSize::Bits8) => {
ctx.Int8Type()
}
PrimitiveType::Int(IntSize::Bits16) | PrimitiveType::UInt(IntSize::Bits16) => {
ctx.Int16Type()
}
PrimitiveType::Int(IntSize::Bits32) | PrimitiveType::UInt(IntSize::Bits32) => {
ctx.Int32Type()
}
PrimitiveType::Int(IntSize::Bits64) | PrimitiveType::UInt(IntSize::Bits64) => {
ctx.Int64Type()
}
PrimitiveType::Float(FloatSize::Bits32) => ctx.FloatType(),
PrimitiveType::Float(FloatSize::Bits64) => ctx.DoubleType(),
PrimitiveType::Str => ctx.CharPointerType(),
PrimitiveType::Char => ctx.Int8Type(),
PrimitiveType::NamedType {
name: _,
ty: Some(ty),
} => ty.llvm_ty_in_ctx(module),
PrimitiveType::TypeRef(name) => module
.typectx_ref()
.llvm_ty_in_ctx(name)
.expect(format!("Type {} is not declared", name).as_str())
.llvm_ty_in_ctx(module),
PrimitiveType::GenericTypeRef(name, types) => {
let rec = format!(
"{}[{}]",
name,
types
.iter()
.map(|ty| ty.fmt())
.collect::<Vec<_>>()
.join(", ")
);
module
.typectx_ref()
.get_type(&rec)
.expect(format!("Type {} is not declared", rec).as_str())
.llvm_ty_in_ctx(module)
}
PrimitiveType::Pointer(ty) => match ty {
box PrimitiveType::Char => ctx.CharPointerType(),
tr @ box PrimitiveType::TypeRef(_) => ctx.PointerType(tr.llvm_ty_in_ctx(module)),
tr @ box PrimitiveType::UInt(_) => ctx.PointerType(tr.llvm_ty_in_ctx(module)),
tr @ box PrimitiveType::Int(_) => ctx.PointerType(tr.llvm_ty_in_ctx(module)),
box PrimitiveType::Str => ctx.PointerType(ctx.Int8PointerType()),
box PrimitiveType::Pointer(box ty) => ctx.PointerType(ty.llvm_ty_in_ctx(module)),
_ => panic!("llvm_ty_in_ctx {:?}", ty),
},
PrimitiveType::Function(ty) => ty.llvm_ty_in_ctx(module),
PrimitiveType::Newtype(name) => module
.typectx_ref()
.get_type(&name)
.map(|ty| match ty {
TypeKind::Typedef(TypedefKind::Newtype(_, ty)) => ty.llvm_ty_in_ctx(module),
_ => unreachable!(),
})
.expect(format!("Cannot find type for {:?}", self).as_ref()),
PrimitiveType::Variant { variant, .. } => {
module.typectx_ref().get_variant(variant).expect("ICE").ty
}
PrimitiveType::VariantType(variant) => {
module
.typectx_ref()
.get_parent_for_variant(variant)
.expect("ICE")
.ty
}
PrimitiveType::Box(box val) => module
.llvm_context_ref()
.PointerType(val.llvm_ty_in_ctx(module)),
_ => panic!("ICE: llvm_ty_in_ctx {:?}", self),
}
}
}
|
#[feature(struct_variant)];
#[feature(managed_boxes)];
use std::os;
use std::at_vec;
use std::io::fs::File;
use std::option::Option;
mod scanner;
enum Gate {
And,
Or
}
pub enum Node {
Leaf { value: bool },
Interior { gate : Gate, changeable : bool }
}
impl Clone for Node {
fn clone(&self) -> Node {
match *self {
Leaf{value: v} =>
Leaf{value: v},
Interior {gate: g, changeable: c} =>
Interior{gate: g, changeable: c}
}
}
}
pub struct NodeRef {
index : uint,
node_list : @[Node],
}
impl NodeRef {
pub fn new(nodes : &[Node]) -> ~NodeRef {
~NodeRef{ index : 0,
node_list : ::at_vec::to_managed(nodes) }
}
pub fn parent(&self) -> Option<~NodeRef> {
let new_index = (self.index - 1) / 2;
if new_index < 0 {
None
} else {
Some(~NodeRef { index : new_index, node_list : self.node_list })
}
}
pub fn left_child(&self) -> Option<~NodeRef> {
let new_index = 1 + 2 * self.index;
if new_index < self.node_list.len() {
Some(~NodeRef { index : new_index,
node_list : self.node_list })
} else {
None
}
}
pub fn right_child(&self) -> Option<~NodeRef> {
let new_index = 2 + 2 * self.index;
if new_index < self.node_list.len() {
Some(~NodeRef { index : new_index, node_list : self.node_list })
} else {
None
}
}
pub fn eval(&self) -> bool {
debug!("evaluating node with index {}", self.index);
let node = &self.node_list[self.index];
match *node {
Leaf{value : v} => v,
Interior{ gate : And, changeable : _ } =>
self.left_child().unwrap().eval() &&
self.right_child().unwrap().eval(),
Interior{ gate : Or, changeable : _ } =>
self.left_child().unwrap().eval() ||
self.right_child().unwrap().eval(),
}
}
pub fn min_changes(&self, desired : bool) -> Option<uint> {
let cur_val = self.eval();
if cur_val == desired {
return Some(0);
}
let node = &self.node_list[self.index];
match *node {
Leaf{value : _} => None,
Interior{ gate : op, changeable : false} => {
let left_val = self.left_child().unwrap().eval();
let right_val = self.right_child().unwrap().eval();
match (desired, op, left_val, right_val) {
(false, Or, true, true) =>
NodeRef::add(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired)),
(false, Or, false, true) =>
self.right_child().unwrap().min_changes(desired),
(false, Or, true, false) =>
self.left_child().unwrap().min_changes(desired),
(true, Or, false, false) =>
NodeRef::min_option(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired)),
(true, And, false, false) =>
NodeRef::add(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired)),
(true, And, true, false) =>
self.right_child().unwrap().min_changes(desired),
(true, And, false, true) =>
self.left_child().unwrap().min_changes(desired),
(false, And, true, true) =>
NodeRef::min_option(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired)),
_ => fail!("Impossible")
}
},
Interior{ gate : op, changeable : true} => {
let left_val = self.left_child().unwrap().eval();
let right_val = self.right_child().unwrap().eval();
match (desired, op, left_val, right_val) {
(false, Or, false, _) => Some(1),
(false, Or, _, false) => Some(1),
(true, Or, false, false) =>
NodeRef::min_option(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired)),
(false, Or, true, true) =>
NodeRef::add_one(
&NodeRef::min_option(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired))),
(true, And, true, _) => Some(1),
(true, And, _, true) => Some(1),
(false, And, true, true) =>
NodeRef::min_option(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired)),
(true, And, false, false) =>
NodeRef::add_one(
&NodeRef::min_option(
&self.left_child().unwrap().min_changes(desired),
&self.right_child().unwrap().min_changes(desired))),
_ => fail!("Impossible combination.")
}
}
}
}
fn min_option(v1 : &Option<uint>, v2 : &Option<uint>) -> Option<uint> {
match (v1, v2) {
(&None, &None) => None,
(&Some(v), &None) => Some(v),
(&None, &Some(v)) => Some(v),
(&Some(v1), &Some(v2)) if v1 <= v2 => Some(v1),
(&Some(_), &Some(v2)) => Some(v2)
}
}
fn add_one(v : &Option<uint>) -> Option<uint> {
match v {
&None => None,
&Some(v) => Some(1 + v)
}
}
fn add(v1 : &Option<uint>, v2 : &Option<uint>) -> Option<uint> {
match (v1, v2) {
(&None, _) => None,
(_, &None) => None,
(&Some(a), &Some(b)) => Some(a + b),
}
}
}
fn main() {
let args = os::args();
assert_eq!(2, args.len());
let path = Path::new(args[1]);
let mut scanner = scanner::Scanner::new_from_reader(File::open(&path));
let test_count = scanner.next_uint().unwrap();
for test in range(1, 1 + test_count) {
let node_count = scanner.next_uint().unwrap();
let desired_value = 1 == scanner.next_uint().unwrap();
let mut nodes : ~[Node] = ~[];
for _ in range(0, node_count / 2) {
let gate = match scanner.next_uint().unwrap() {
1 => And,
_ => Or
};
let changeable = 1 == scanner.next_uint().unwrap();
nodes.push(Interior{gate: gate, changeable: changeable});
}
for _ in range(0, 1 + node_count / 2) {
let value = scanner.next_uint().unwrap();
nodes.push(Leaf{value: 1 == value});
}
let tree = NodeRef::new(nodes);
let min = tree.min_changes(desired_value);
print!("Case \\#{}: ", test);
match min {
None => { println!("IMPOSSIBLE"); }
Some(v) => { println!("{}", v); }
}
}
}
|
#[doc = "Reader of register TEMP_T0VALR1"]
pub type R = crate::R<u32, super::TEMP_T0VALR1>;
#[doc = "Reader of field `TS1_FMT0`"]
pub type TS1_FMT0_R = crate::R<u16, u16>;
#[doc = "Reader of field `TS1_T0`"]
pub type TS1_T0_R = crate::R<u8, u8>;
impl R {
#[doc = "Bits 0:15 - TS1_FMT0"]
#[inline(always)]
pub fn ts1_fmt0(&self) -> TS1_FMT0_R {
TS1_FMT0_R::new((self.bits & 0xffff) as u16)
}
#[doc = "Bits 16:17 - TS1_T0"]
#[inline(always)]
pub fn ts1_t0(&self) -> TS1_T0_R {
TS1_T0_R::new(((self.bits >> 16) & 0x03) as u8)
}
}
|
use cmdr::*;
struct CaveScope {}
#[cmdr]
impl CaveScope {
#[cmd]
fn north(&self, _args: &[String]) -> CommandResult {
println!("You walk north");
CommandResult::Ok
}
#[cmd]
fn south(&self, _args: &[String]) -> CommandResult {
println!("You walk south");
CommandResult::Ok
}
#[cmd]
fn east(&self, _args: &[String]) -> CommandResult {
println!("You walk east");
CommandResult::Ok
}
#[cmd]
fn west(&self, _args: &[String]) -> CommandResult {
println!("You walk west");
CommandResult::Ok
}
}
fn main() {
cmd_loop(&mut CaveScope {})
}
|
use std::env;
use std::path::Path;
use std::io::{stdout, Write};
use std::time::Duration;
use tui::Terminal;
use tui::backend::CrosstermBackend;
use crossterm::event::{poll, read, Event};
use crossterm::{execute, cursor, terminal::{EnterAlternateScreen, LeaveAlternateScreen}};
mod assembler;
mod computer;
mod utils;
mod app;
use assembler::assemble;
use utils::lines_from_file;
use app::App;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let args: Vec<String> = env::args().collect();
let filename = Path::new(&args[1]).file_name().unwrap().to_string_lossy();
let input = lines_from_file(&args[1]).expect("could not read file");
let program = assemble(&input);
let mut app = App::new(filename.to_string(), program);
let mut stdout = stdout();
execute!(stdout, EnterAlternateScreen)?;
let backend = CrosstermBackend::new(stdout);
let mut terminal = Terminal::new(backend)?;
loop {
terminal.draw(|mut f| app.draw(&mut f))?;
match app.cursor_pos {
Some((x, y)) => {
terminal.show_cursor()?;
write!(terminal.backend_mut(), "{}", cursor::MoveTo(x, y))?;
}
None => {
terminal.hide_cursor()?;
}
};
std::io::stdout().flush().ok();
if poll(Duration::from_millis(200))? {
if let Event::Key(key) = read()? {
let quit = app.handle_input_event(key.code);
if quit {
execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
terminal.show_cursor()?;
break;
}
}
} else {
app.clear_input_event();
}
}
Ok(())
}
|
use crate::libs::color::color_system;
use crate::libs::type_id::type_id;
use isaribi::{
style,
styled::{Style, Styled},
};
use nusa::prelude::*;
pub struct TabBtn {}
impl TabBtn {
pub fn new(
is_draggable: bool,
is_selected: bool,
attrs: Attributes,
events: Events,
children: Vec<Html>,
) -> Html {
Self::styled(Html::div(
attrs
.class(Self::class("base"))
.draggable(is_draggable.to_string()),
events,
vec![Html::div(
Attributes::new()
.class("pure-button")
.class(Self::class("btn"))
.string("data-tab-selected", is_selected.to_string()),
Events::new(),
children,
)],
))
}
}
impl Styled for TabBtn {
fn style() -> Style {
style! {
".base" {
"max-width": "max-content";
"min-width": "max-content";
"max-height": "max-content";
"min-height": "max-content";
}
".btn" {
"border-radius": "2px 2px 0 0";
"color": color_system::gray(100, 0).to_string();
"max-width": "12em";
"overflow": "hidden";
"text-overflow": "ellipsis";
}
r#".btn[data-tab-selected="true"]"# {
"background-color": color_system::blue(100, 5).to_string();
}
r#".btn[data-tab-selected="false"]"# {
"background-color": color_system::gray(100, 9).to_string();
}
}
}
}
|
use simple_error::bail;
use evmap;
use std::error;
use std::io;
use std::io::BufRead;
use std::sync::mpsc;
use std::thread;
use crate::day;
use evmap::{ReadHandle, WriteHandle};
pub type BoxResult<T> = Result<T, Box<dyn error::Error>>;
struct Intcode {
p: Vec<i64>,
base: i64,
}
impl Intcode {
fn new(p: &[i64]) -> Self { Self { p: p.to_vec(), base: 0 } }
fn op(&self, c: i64) -> i64 { c % 100 }
fn get(&mut self, a: usize) -> i64 {
if a >= self.p.len() { self.p.resize(a + 1, 0); }
self.p[a]
}
fn put(&mut self, a: usize, v: i64) {
// eprintln!("put @{} {}", a, v);
if a >= self.p.len() { self.p.resize(a + 1, 0); }
self.p[a] = v;
}
fn addr(&mut self, ip: usize, i: usize) -> usize {
let a = self.get(ip + i);
let v = match self.get(ip) / vec![100, 1000, 10000][i - 1] % 10 {
0 => a as usize,
2 => (a + self.base) as usize,
_ => 0, // XXX
};
v
}
fn val(&mut self, ip: usize, i: usize) -> i64 {
let a = self.get(ip + i);
let v = match self.get(ip) / vec![100, 1000, 10000][i - 1] % 10 {
1 => a,
_ => {
let addr = self.addr(ip, i);
self.get(addr)
},
};
// eprintln!("{} {} {} {} {} {}", ip, self.get(ip), i, a, self.base, v);
v
}
fn run(&mut self, sender: mpsc::Sender<i64>, receiver: mpsc::Receiver<i64>,
request: mpsc::Sender<()>, ack: mpsc::Receiver<()>) -> BoxResult<i64> {
let mut ip = 0;
let mut o = None;
while { let op = self.get(ip); self.op(op) != 99 } {
// eprintln!("{}: {} {} {} {}", ip, self.p[ip], self.p[ip + 1], self.p[ip + 2], self.p[ip + 3]);
match self.op(self.p[ip]) {
1 => {
let a = self.val(ip, 1);
let b = self.val( ip, 2);
let c = self.addr(ip, 3);
self.put(c, a + b);
ip += 4;
},
2 => {
let a = self.val(ip, 1);
let b = self.val(ip, 2);
let c = self.addr(ip, 3);
self.put(c, a * b);
ip += 4;
},
3 => {
let a = self.addr(ip, 1);
// eprintln!(">recv {}", a);
request.send(())?;
self.put(a as usize, receiver.recv()?);
// eprintln!("<recv {}", self.get(a as usize));
ip += 2;
},
4 => {
let a = self.val(ip, 1);
o = Some(a);
// eprintln!(">send {}", a);
sender.send(a)?;
// eprintln!("<send");
ack.recv()?;
// eprintln!("<<send");
ip += 2;
},
5 => {
let a = self.val(ip, 1);
let b = self.val(ip, 2) as usize;
ip = if a != 0 { b } else { ip + 3 };
},
6 => {
let a = self.val(ip, 1);
let b = self.val(ip, 2) as usize;
ip = if a == 0 { b } else { ip + 3 };
},
7 => {
let a = self.val(ip, 1);
let b = self.val(ip, 2);
let c = self.addr(ip, 3);
self.put(c, if a < b { 1 } else { 0 });
ip += 4;
},
8 => {
let a = self.val(ip, 1);
let b = self.val(ip, 2);
let c = self.addr(ip,3);
self.put(c, if a == b { 1 } else { 0 });
ip += 4;
},
9 => {
self.base += self.val(ip, 1);
// eprintln!("<base {}", self.base);
ip += 2;
}
_ => bail!("unknown opcode {}: {}", ip, self.op(self.p[ip])),
};
}
if o.is_none() { bail!("no output"); }
Ok(o.unwrap())
}
#[allow(dead_code)]
fn arg(&self, ip: usize, offset: usize) -> String {
let a = self.p[ip + offset].to_string();
match self.p[ip] / vec![100, 1000, 10000][offset - 1] % 10 {
0 => format!("@{}", a),
1 => a,
2 => format!("+{}", a),
_ => String::from(""), // XXX
}
}
#[allow(dead_code)]
fn disassemble(&self) {
let mut ip = 0;
while ip < self.p.len() {
match self.op(self.p[ip]) {
1 => {
println!("{}: add {} {} {}", ip, self.arg(ip, 1), self.arg(ip, 2), self.arg(ip, 3));
ip += 4;
},
2 => {
println!("{}: mul {} {} {}", ip, self.arg(ip, 1), self.arg(ip, 2), self.arg(ip, 3));
ip += 4;
},
3 => {
println!("{}: in {}", ip, self.arg(ip, 1));
ip += 2;
},
4 => {
println!("{}: out {}", ip, self.arg(ip, 1));
ip += 2;
},
5 => {
println!("{}: jnz {} {}", ip, self.arg(ip, 1), self.arg(ip, 2));
ip += 3;
},
6 => {
println!("{}: jz {} {}", ip, self.arg(ip, 1), self.arg(ip, 2));
ip += 3;
},
7 => {
println!("{}: testlt {} {} {}", ip, self.arg(ip, 1), self.arg(ip, 2), self.arg(ip, 3));
ip += 4;
},
8 => {
println!("{}: testeq {} {} {}", ip, self.arg(ip, 1), self.arg(ip, 2), self.arg(ip, 3));
ip += 4;
},
9 => {
println!("{}: base {}", ip, self.arg(ip, 1));
ip += 2;
},
99 => {
println!("{}: halt", ip);
ip += 1;
},
_ => {
println!("{}: data ({})", ip, self.p[ip]);
ip += 1;
},
};
}
}
}
pub struct Day17 {}
impl day::Day for Day17 {
fn tag(&self) -> &str { "17" }
fn part1(&self, input: &dyn Fn() -> Box<dyn io::Read>) {
let reader = io::BufReader::new(input());
let p = reader.split(b',')
.map(|v| String::from_utf8(v.unwrap()).unwrap())
.map(|s| s.trim_end().parse::<i64>().unwrap())
.collect::<Vec<_>>();
let (grid_r, mut grid_w) = evmap::new();
let mut o = (0, 0);
let mut dir = (0, 0);
println!("{:?}", self.part1_impl(p, &grid_r, &mut grid_w, &mut o, &mut dir));
}
fn part2(&self, input: &dyn Fn() -> Box<dyn io::Read>) {
let reader = io::BufReader::new(input());
let p = reader.split(b',')
.map(|v| String::from_utf8(v.unwrap()).unwrap())
.map(|s| s.trim_end().parse::<i64>().unwrap())
.collect::<Vec<_>>();
let mut p2 = p.clone();
p2[0] = 2;
let mut o = (0, 0);
let mut dir = (0, 0);
let (grid_r, mut grid_w) = evmap::new();
self.part1_impl(p, &grid_r, &mut grid_w, &mut o, &mut dir).unwrap();
println!("{:?}", self.part2_impl(p2, &grid_r, &mut grid_w, o, dir));
}
}
impl Day17 {
fn part1_impl(self: &Self, p: Vec<i64>,
grid_r: &ReadHandle<(i32, i32), char>,
grid_w: &mut WriteHandle<(i32, i32), char>,
origin: &mut (i32, i32), dir: &mut (i32, i32))
-> BoxResult<i32> {
let (_input_sender, input_receiver) = mpsc::channel::<i64>();
let (output_sender, output_receiver) = mpsc::channel::<i64>();
let (request_sender, _request_receiver) = mpsc::channel::<()>();
let (ack_sender, ack_receiver) = mpsc::channel::<()>();
let _cpu = thread::spawn(move || {
let mut ic = Intcode::new(&p);
ic.run(output_sender, input_receiver, request_sender, ack_receiver)
.unwrap_or(0);
});
let mut s = String::new();
let (mut x, mut y) = (0, 0);
let mut t = 0;
while match output_receiver.recv() {
Ok(b) => {
ack_sender.send(()).unwrap();
let c = b as u8 as char;
s.push(c);
grid_w.update((x, y).clone(), c);
grid_w.refresh();
match c {
'#' => {
if y > 0 && x > 0
&& grid_r.get_and(&(x, y - 1), |c| c[0]) == Some('#')
&& grid_r.get_and(&(x - 1, y - 1), |c| c[0]) == Some('#')
&& grid_r.get_and(&(x + 1, y - 1), |c| c[0]) == Some('#') {
t += x * (y - 1);
};
x += 1;
},
'.' => { x += 1; },
'^' => { *origin = (x, y); *dir = (0, -1); x += 1; }
'v' => { *origin = (x, y); *dir = (0, 1); x += 1; }
'<' => { *origin = (x, y); *dir = (-1, 0); x += 1; }
'>' => { *origin = (x, y); *dir = (1, 0); x += 1; }
'\n' => { x = 0; y += 1; },
_ => (),
}
true
},
Err(_) => false,
} {};
eprintln!("{}", s);
Ok(t)
}
fn part2_impl(self: &Self, p: Vec<i64>,
grid_r: &ReadHandle<(i32, i32), char>,
grid_w: &mut WriteHandle<(i32, i32), char>,
origin: (i32, i32), dir: (i32, i32))
-> BoxResult<i64> {
let (input_sender, input_receiver) = mpsc::channel::<i64>();
let (output_sender, output_receiver) = mpsc::channel::<i64>();
let (request_sender, request_receiver) = mpsc::channel::<()>();
let (ack_sender, ack_receiver) = mpsc::channel::<()>();
let _cpu = thread::spawn(move || {
let mut ic = Intcode::new(&p);
ic.run(output_sender, input_receiver, request_sender, ack_receiver)
.unwrap_or(0);
});
let mut s = String::new();
for _i in 0..2047 {
match output_receiver.recv().unwrap() as u8 as char {
'\n' => { eprintln!("{}", s); s = String::new(); },
c => { s.push(c); }
};
ack_sender.send(()).unwrap();
}
// eprintln!("{:?} {:?}", origin, dir);
let is_ok = |(x, y), (dx, dy)| {
grid_r.get_and(&(x + dx, y + dy), |c| c[0]) == Some('#')
};
let run = |(x, y), (dx, dy)| {
let len = (1..).position(|i| !is_ok((x, y), (dx * i, dy * i)))
.unwrap()
as i32;
if len == 0 { None } else { Some(((x + len * dx, y + len * dy), len, (dx, dy))) }
};
let mut n = 0;
let mut pos = origin;
let mut last = None;
let mut face = dir;
loop {
let (_m, next, next_face) =
if let Some((next, dist, next_face)) = run(pos, face) {
(format!("{}", dist), next, next_face)
} else if let Some((next, dist, next_face)) = run(pos, (face.1, -face.0)) {
(format!("L,{}", dist), next, next_face)
} else if let Some((next, dist, next_face)) = run(pos, (-face.1, face.0)) {
(format!("R,{}", dist), next, next_face)
} else {
let (next, dist, next_face) = run(pos, (-face.0, -face.1)).unwrap();
(format!("L,L,{}", dist), next, next_face)
};
if Some(next) == last { break; }
// eprintln!("{:?}", _m);
face = next_face;
last = Some(pos);
pos = next;
}
// XXX
let instructions = "A,B,B,A,B,C,A,C,B,C
L,4,L,6,L,8,L,12
L,8,R,12,L,12
R,12,L,6,L,6,L,8
y
";
for c in instructions.chars() {
request_receiver.recv().unwrap();
input_sender.send(c as i64).unwrap();
match c {
'\n' => {
loop {
let mut done = false;
match output_receiver.recv().unwrap() as u8 as char {
'\n' => { eprintln!("{}", s); s = String::new(); done = true; },
c => { s.push(c); }
};
ack_sender.send(()).unwrap();
if done { break; }
};
},
_ => (),
}
}
let mut s = String::new();
let (mut x, mut y) = (0, 0);
while match output_receiver.recv() {
Ok(b) => {
ack_sender.send(()).unwrap();
let c = b as u8 as char;
s.push(c);
match c {
'#' => {
x += 1;
},
'.' => { x += 1; },
'^' => { x += 1; }
'v' => { x += 1; }
'<' => { x += 1; }
'>' => { x += 1; }
'\n' => {
eprintln!("{}", s);
s = String::new();
x = 0;
y += 1;
},
_ => {
eprintln!("whoa: {}", b);
n += b;
x += 1;
},
}
true
},
Err(_) => false,
} {};
Ok(n)
}
}
#[cfg(test)]
mod tests {
// use super::*;
fn test1(s: &str, v: usize) {
// assert_eq!(Day17 {}.part1_impl(s), v);
}
#[test]
fn part1() {
test1("
..#..........
..#..........
#######...###
#.#...#...#.#
#############
..#...#...#..
..#####...^..", 76);
}
// fn test2(s: &str, n: usize, v: &str) {
//// assert_eq!(Day16 {}.part2_impl(s, n).unwrap(), v);
// assert_eq!(Day17 {}.part2_helper(s, n, 1, 0).unwrap(), v);
// }
//
//// #[test]
// fn part2() {
// test2("56781234", 10, "");
//// test2("03036732577212944063491565474664", 100, "84462026");
// }
} |
use doctor_syn::Parity;
use doctor_syn::{expr, name};
use std::io::Write;
use quote::quote;
// acos
// acosh
// asin
// asinh
// atan
// atan2
// atanh
// cbrt
// cosh
// hypot
// ln_1p
// log
// log10
// log2
// powf
// powi
// recip
// sin_cos
// sinh
// sqrt
// tan
// tanh
fn gen_sin(num_terms: usize) -> proc_macro2::TokenStream {
let xmin = -0.5;
let xmax = 0.5;
let approx = expr!((x * 3.1415926535897932384626433 * 2.0).sin() * -1.0)
.approx(num_terms, xmin, xmax, name!(x), Parity::Odd)
.unwrap()
.use_suffix(Some("f32".to_string()))
.unwrap()
.into_inner();
quote!(
fn sin(x: f32) -> f32 {
let x = x * (1.0 / (std::f32::consts::PI * 2.0));
let x = x - x.floor() - 0.5;
#approx
}
)
}
fn gen_cos(num_terms: usize) -> proc_macro2::TokenStream {
let xmin = -0.5;
let xmax = 0.5;
let approx = expr!((x * 3.1415926535897932384626433 * 2.0).cos() * -1.0)
.approx(num_terms, xmin, xmax, name!(x), Parity::Even)
.unwrap()
.use_suffix(Some("f32".to_string()))
.unwrap()
.into_inner();
quote!(
fn cos(x: f32) -> f32 {
let x = x * (1.0 / (std::f32::consts::PI * 2.0));
let x = x - x.floor() - 0.5;
#approx
}
)
}
fn gen_exp2(num_terms: usize) -> proc_macro2::TokenStream {
let xmin = -0.5;
let xmax = 0.5;
let approx = expr!(2.0.powf(x + 0.5))
.approx(num_terms, xmin, xmax, name!(x), Parity::Neither)
.unwrap()
.use_suffix(Some("f32".to_string()))
.unwrap()
.into_inner();
quote!(
fn exp2(x: f32) -> f32 {
let mul = f32::from_bits((x.floor() * 0x00800000 as f32 + 0x3f800000 as f32) as u32);
let x = x - x.floor() - 0.5;
#approx * mul
}
)
}
fn gen_exp(num_terms: usize) -> proc_macro2::TokenStream {
let xmin = -0.5;
let xmax = 0.5;
let approx = expr!(2.0.powf(x + 0.5))
.approx(num_terms, xmin, xmax, name!(x), Parity::Neither)
.unwrap()
.use_suffix(Some("f32".to_string()))
.unwrap()
.into_inner();
quote!(
fn exp(x: f32) -> f32 {
let x = x * std::f32::consts::LOG2_E;
let mul = f32::from_bits((x.floor() * 0x00800000 as f32 + 0x3f800000 as f32) as u32);
let x = x - x.floor() - 0.5;
#approx * mul
}
)
}
fn gen_exp_m1(num_terms: usize) -> proc_macro2::TokenStream {
let xmin = -0.5;
let xmax = 0.5;
let approx = expr!(2.0.powf(x + 0.5)-1.0)
.approx(num_terms, xmin, xmax, name!(x), Parity::Neither)
.unwrap()
.use_suffix(Some("f32".to_string()))
.unwrap()
.into_inner();
quote!(
fn exp_m1(x: f32) -> f32 {
let x = x * std::f32::consts::LOG2_E;
let mul = f32::from_bits((x.floor() * 0x00800000 as f32 + 0x3f800000 as f32) as u32);
let x = x - x.floor() - 0.5;
#approx * mul + (mul - 1.0)
}
)
}
fn gen_ln(num_terms: usize) -> proc_macro2::TokenStream {
let xmin = -0.5;
let xmax = 0.5;
let approx = expr!((x + 1.5).log2())
.approx(num_terms, xmin, xmax, name!(x), Parity::Neither)
.unwrap()
.use_suffix(Some("f32".to_string()))
.unwrap()
.into_inner();
quote!(
fn ln(x: f32) -> f32 {
let exponent = (x.to_bits() >> 23) as i32 - 0x7f;
let x = f32::from_bits((x.to_bits() & 0x7fffff) | 0x3f800000) - 1.5;
let y: f32 = #approx;
(y + (exponent as f32)) * (1.0 / std::f32::consts::LOG2_E)
}
)
}
fn gen_test(test_name: &str, name: &str, accuracy: f64, tmin: f64, tmax: f64) -> String {
let mut res = Vec::new();
writeln!(res, "#[test]").unwrap();
writeln!(res, "fn test_{}() {{", test_name).unwrap();
writeln!(res, " const N: i32 = 0x100000;").unwrap();
writeln!(res, " let tmin = {:20.16};", tmin).unwrap();
writeln!(res, " let tmax = {:20.16};", tmax).unwrap();
writeln!(res, " let mut max_error = 0.0_f64;").unwrap();
writeln!(res, " for i in 0..=N {{").unwrap();
writeln!(res, " let x = i as f64 * (tmax - tmin) / N as f64 + tmin;").unwrap();
writeln!(res, " let y1 = x.{}();", name).unwrap();
writeln!(res, " let y2 = {}(x as f32) as f64;", name).unwrap();
writeln!(res, " max_error = max_error.max((y1 - y2).abs());").unwrap();
writeln!(res, " if i % (N/16) == 0 {{ println!(\"y1={{:20.16}}\\ny2={{:20.16}} e={{:20.16}}\", y1, y2, y2-y1); }}").unwrap();
writeln!(res, " }}").unwrap();
writeln!(res, " println!(\"{} me={{:20}}\", max_error);", name).unwrap();
writeln!(res, " assert!(max_error < {});", accuracy).unwrap();
writeln!(res, "}}").unwrap();
String::from_utf8(res).unwrap()
}
fn generate_libm() -> std::io::Result<()> {
let mut file = std::fs::File::create("tests/libm.rs")?;
write!(file, "\n{}\n", gen_sin(16))?;
write!(file, "\n{}\n", gen_cos(17))?;
write!(file, "\n{}\n", gen_exp(7))?;
write!(file, "\n{}\n", gen_exp2(7))?;
write!(file, "\n{}\n", gen_exp_m1(7))?;
write!(file, "\n{}\n", gen_ln(9))?;
write!(file, "\n{}\n", gen_test("sin", "sin", (2.0_f64).powi(-23)*4.2, -std::f64::consts::PI, std::f64::consts::PI))?;
write!(file, "\n{}\n", gen_test("cos", "cos", (2.0_f64).powi(-23)*3.0, -std::f64::consts::PI, std::f64::consts::PI))?;
write!(file, "\n{}\n", gen_test("exp_a", "exp", (2.0_f64).powi(-23)*3.0, 0.0, 1.0))?;
write!(file, "\n{}\n", gen_test("exp_b", "exp", (2.0_f64).powi(-23)*10.0, 1.0, 2.0))?;
write!(file, "\n{}\n", gen_test("exp_m1", "exp_m1", (2.0_f64).powi(-23)*2.0, 0.0, 1.0))?;
write!(file, "\n{}\n", gen_test("exp2", "exp2", (2.0_f64).powi(-23)*2.0, 0.0, 1.0))?;
write!(file, "\n{}\n", gen_test("ln", "ln", (2.0_f64).powi(-23)*2.0, 1.0, std::f64::consts::E))?;
Ok(())
}
fn main() {
generate_libm().unwrap();
}
|
mod default;
mod ttnv2;
mod ttnv3;
use crate::commands::CommandOptions;
use actix_web::{web, HttpResponse};
use async_trait::async_trait;
use drogue_client::{registry, Translator};
use drogue_cloud_endpoint_common::{
error::HttpEndpointError,
sender::{Publish, PublishOptions, Publisher, UpstreamSender},
sink::Sink,
};
use reqwest::{
header::{HeaderName, HeaderValue},
Response, StatusCode,
};
use std::{fmt::Formatter, str::FromStr};
use thiserror::Error;
use url::Url;
pub struct Context {
pub device_id: String,
pub client: reqwest::Client,
}
#[async_trait]
pub trait Sender {
async fn send(
&self,
ctx: Context,
endpoint: registry::v1::ExternalEndpoint,
command: CommandOptions,
body: web::Bytes,
) -> Result<(), Error>;
async fn process<S>(
&self,
application: registry::v1::Application,
device: registry::v1::Device,
gateways: Vec<registry::v1::Device>,
sender: &UpstreamSender<S>,
client: reqwest::Client,
content_type: Option<String>,
opts: CommandOptions,
body: web::Bytes,
) -> Result<HttpResponse, HttpEndpointError>
where
S: Sink + Send + Sync,
<S as Sink>::Error: Send,
{
if !device.attribute::<registry::v1::DeviceEnabled>() {
return Ok(HttpResponse::NotAcceptable().finish());
}
for gateway in gateways {
if !gateway.attribute::<registry::v1::DeviceEnabled>() {
continue;
}
if let Some(command) = gateway.attribute::<registry::v1::Commands>().pop() {
return match command {
registry::v1::Command::External(endpoint) => {
log::debug!("Sending to external command endpoint {:?}", endpoint);
let ctx = Context {
device_id: device.metadata.name,
client,
};
match send_to_external(ctx, endpoint, opts, body).await {
Ok(_) => Ok(HttpResponse::Ok().finish()),
Err(err) => {
log::info!("Failed to process external command: {}", err);
Ok(HttpResponse::NotAcceptable().finish())
}
}
}
};
}
}
// no hits so far
sender
.publish_http_default(
Publish {
channel: opts.command,
application: &application,
device_id: opts.device,
options: PublishOptions {
topic: None,
content_type,
..Default::default()
},
},
body,
)
.await
}
}
#[derive(Debug, Error)]
pub enum Error {
#[error("Transport failed: {0}")]
Transport(#[source] Box<dyn std::error::Error + Send + Sync>),
#[error("Unknown external type: {0}")]
UnknownType(String),
#[error("Invalid configuration: {0}")]
InvalidConfiguration(String),
#[error("Invalid payload: {0}")]
Payload(String),
}
#[derive(Clone, Debug)]
pub struct HttpError(pub StatusCode, pub String);
impl std::fmt::Display for HttpError {
fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
write!(f, "HTTP request failed: {}\n{}", self.0, self.1)
}
}
impl std::error::Error for HttpError {}
pub async fn send_to_external(
ctx: Context,
endpoint: registry::v1::ExternalEndpoint,
command: CommandOptions,
payload: web::Bytes,
) -> Result<(), Error> {
match endpoint.r#type.as_deref() {
None => {
default::DefaultSender
.send(ctx, endpoint, command, payload)
.await
}
Some("ttn") | Some("ttnv2") => {
ttnv2::TtnV2Sender
.send(ctx, endpoint, command, payload)
.await
}
Some("ttnv3") => {
ttnv3::TtnV3Sender
.send(ctx, endpoint, command, payload)
.await
}
Some(t) => Err(Error::UnknownType(t.to_string())),
}
}
/// Convert the name to an HTTP method.
///
/// If the name is empty, [`None`] is returned. If the method is invalid, and error will be returned.
fn to_method(name: &str) -> Result<Option<reqwest::Method>, Error> {
if name.is_empty() {
Ok(None)
} else {
match reqwest::Method::from_str(name) {
Ok(m) => Ok(Some(m)),
Err(_) => Err(Error::InvalidConfiguration(format!(
"Invalid HTTP method: {}",
name
))),
}
}
}
/// Takes an external endpoint and creates an HTTP request builder from it.
pub(crate) fn to_builder<F>(
client: reqwest::Client,
default_method: reqwest::Method,
endpoint: ®istry::v1::ExternalEndpoint,
f: F,
) -> Result<reqwest::RequestBuilder, Error>
where
F: FnOnce(Url) -> Result<Url, Error>,
{
let method = to_method(&endpoint.method)?.unwrap_or(default_method);
let url = Url::parse(&endpoint.url)
.map_err(|err| Error::InvalidConfiguration(format!("Unable to parse URL: {}", err)))?;
let url = f(url)?;
let mut builder = client.request(method, url);
for (k, v) in &endpoint.headers {
let key = HeaderName::from_str(&k).map_err(|err| {
Error::InvalidConfiguration(format!("Invalid HTTP header key: '{}': {}", k, err))
})?;
let value = HeaderValue::from_str(&v).map_err(|err| {
Error::InvalidConfiguration(format!("Invalid HTTP header value: '{}': {}", v, err))
})?;
builder = builder.header(key, value);
}
Ok(builder)
}
pub(crate) async fn default_error(resp: Response) -> Error {
let code = resp.status();
match resp.text().await {
Ok(text) => Error::Transport(Box::new(HttpError(code, text))),
Err(err) => Error::Transport(Box::new(HttpError(
code,
format!("Failed to get error information: {}", err),
))),
}
}
|
extern crate alloc;
use crate::archiver::{Segment, SegmentItem};
use alloc::string::String;
use alloc::vec::Vec;
use core::mem;
use core::num::NonZeroUsize;
use parity_scale_codec::Decode;
use subspace_core_primitives::crypto::Scalar;
use subspace_core_primitives::{
ArchivedBlockProgress, ArchivedHistorySegment, BlockNumber, LastArchivedBlock, Piece,
RawRecord, RecordedHistorySegment, SegmentHeader, SegmentIndex,
};
use subspace_erasure_coding::ErasureCoding;
/// Reconstructor-related instantiation error.
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[cfg_attr(feature = "thiserror", derive(thiserror::Error))]
pub enum ReconstructorInstantiationError {
/// Failed to initialize erasure coding
#[cfg_attr(
feature = "thiserror",
error("Failed to initialize erasure coding: {0}")
)]
FailedToInitializeErasureCoding(String),
}
/// Reconstructor-related instantiation error
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "thiserror", derive(thiserror::Error))]
pub enum ReconstructorError {
/// Error during data shards reconstruction
#[cfg_attr(
feature = "thiserror",
error("Error during data shards reconstruction: {0}")
)]
DataShardsReconstruction(String),
/// Segment size is not bigger than record size
#[cfg_attr(feature = "thiserror", error("Error during segment decoding: {0}"))]
SegmentDecoding(parity_scale_codec::Error),
/// Incorrect segment order, each next segment must have monotonically increasing segment index
#[cfg_attr(
feature = "thiserror",
error("Incorrect segment order, expected index {expected_segment_index}, actual {actual_segment_index}")
)]
IncorrectSegmentOrder {
expected_segment_index: SegmentIndex,
actual_segment_index: SegmentIndex,
},
}
/// Data structure that contains information reconstructed from given segment (potentially using
/// information from segments that were added previously)
#[derive(Debug, Default, Clone, Eq, PartialEq)]
pub struct ReconstructedContents {
/// Segment header stored in a segment
pub segment_header: Option<SegmentHeader>,
/// Reconstructed encoded blocks with their block numbers
pub blocks: Vec<(BlockNumber, Vec<u8>)>,
}
/// Reconstructor helps to retrieve blocks from archived pieces.
#[derive(Debug, Clone)]
pub struct Reconstructor {
/// Erasure coding data structure
erasure_coding: ErasureCoding,
/// Index of last segment added to reconstructor
last_segment_index: Option<SegmentIndex>,
/// Partially reconstructed block waiting for more data
partial_block: Option<Vec<u8>>,
}
impl Reconstructor {
// TODO: Make erasure coding an explicit argument
pub fn new() -> Result<Self, ReconstructorInstantiationError> {
// TODO: Check if KZG can process number configured number of elements and update proof
// message in `.expect()`
let erasure_coding = ErasureCoding::new(
NonZeroUsize::new(ArchivedHistorySegment::NUM_PIECES.ilog2() as usize)
.expect("Archived history segment contains at very least one piece; qed"),
)
.map_err(ReconstructorInstantiationError::FailedToInitializeErasureCoding)?;
Ok(Self {
erasure_coding,
last_segment_index: None,
partial_block: None,
})
}
/// Given a set of pieces of a segment of the archived history (any half of all pieces are
/// required to be present, the rest will be recovered automatically due to use of erasure
/// coding if needed), reconstructs and returns segment header and a list of encoded blocks with
/// corresponding block numbers.
///
/// It is possible to start with any segment, but when next segment is pushed, it needs to
/// follow the previous one or else error will be returned.
pub fn add_segment(
&mut self,
segment_pieces: &[Option<Piece>],
) -> Result<ReconstructedContents, ReconstructorError> {
let mut segment_data = RecordedHistorySegment::new_boxed();
if !segment_pieces
.iter()
// Take each source shards here
.step_by(2)
.zip(segment_data.iter_mut())
.all(|(maybe_piece, raw_record)| {
if let Some(piece) = maybe_piece {
piece.record().iter().zip(raw_record.iter_mut()).for_each(
|(source, target)| {
target.copy_from_slice(&source[..Scalar::SAFE_BYTES]);
},
);
true
} else {
false
}
})
{
// If not all data pieces are available, need to reconstruct data shards using erasure
// coding.
// Scratch buffer to avoid re-allocation
let mut tmp_shards_scalars =
Vec::<Option<Scalar>>::with_capacity(ArchivedHistorySegment::NUM_PIECES);
// Iterate over the chunks of `Scalar::SAFE_BYTES` bytes of all records
for record_offset in 0..RawRecord::SIZE / Scalar::SAFE_BYTES {
// Collect chunks of each record at the same offset
for maybe_piece in segment_pieces.iter() {
let maybe_scalar = maybe_piece
.as_ref()
.map(|piece| {
piece
.record()
.iter()
.nth(record_offset)
.expect("Statically guaranteed to exist in a piece; qed")
})
.map(Scalar::try_from)
.transpose()
.map_err(ReconstructorError::DataShardsReconstruction)?;
tmp_shards_scalars.push(maybe_scalar);
}
self.erasure_coding
.recover(&tmp_shards_scalars)
.map_err(ReconstructorError::DataShardsReconstruction)?
.into_iter()
// Take each source shards here
.step_by(2)
.zip(segment_data.iter_mut().map(|raw_record| {
raw_record
.iter_mut()
.nth(record_offset)
.expect("Statically guaranteed to exist in a piece; qed")
}))
.for_each(|(source_scalar, segment_data)| {
// Source scalar only contains payload data within first
// [`Scalar::SAFE_BYTES`]
segment_data
.copy_from_slice(&source_scalar.to_bytes()[..Scalar::SAFE_BYTES]);
});
tmp_shards_scalars.clear();
}
}
let Segment::V0 { items } =
Segment::decode(&mut AsRef::<[u8]>::as_ref(segment_data.as_ref()))
.map_err(ReconstructorError::SegmentDecoding)?;
let mut reconstructed_contents = ReconstructedContents::default();
let mut next_block_number = 0;
let mut partial_block = self.partial_block.take().unwrap_or_default();
for segment_item in items {
match segment_item {
SegmentItem::Padding => {
// Doesn't contain anything
}
SegmentItem::Block { bytes, .. } => {
if !partial_block.is_empty() {
reconstructed_contents
.blocks
.push((next_block_number, mem::take(&mut partial_block)));
next_block_number += 1;
}
reconstructed_contents
.blocks
.push((next_block_number, bytes));
next_block_number += 1;
}
SegmentItem::BlockStart { bytes, .. } => {
if !partial_block.is_empty() {
reconstructed_contents
.blocks
.push((next_block_number, mem::take(&mut partial_block)));
next_block_number += 1;
}
partial_block = bytes;
}
SegmentItem::BlockContinuation { bytes, .. } => {
if partial_block.is_empty() {
// This is continuation from previous segment, we don't have the beginning
// of the block to continue.
continue;
}
partial_block.extend_from_slice(&bytes);
}
SegmentItem::ParentSegmentHeader(segment_header) => {
let segment_index = segment_header.segment_index();
if let Some(last_segment_index) = self.last_segment_index {
if last_segment_index != segment_index {
return Err(ReconstructorError::IncorrectSegmentOrder {
expected_segment_index: last_segment_index + SegmentIndex::ONE,
actual_segment_index: segment_index + SegmentIndex::ONE,
});
}
}
self.last_segment_index
.replace(segment_index + SegmentIndex::ONE);
let LastArchivedBlock {
number,
archived_progress,
} = segment_header.last_archived_block();
reconstructed_contents
.segment_header
.replace(segment_header);
match archived_progress {
ArchivedBlockProgress::Complete => {
reconstructed_contents
.blocks
.push((next_block_number, mem::take(&mut partial_block)));
next_block_number = number + 1;
}
ArchivedBlockProgress::Partial(_bytes) => {
next_block_number = number;
if partial_block.is_empty() {
// Will not be able to recover full block, bump right away.
next_block_number += 1;
}
}
}
}
}
}
if !partial_block.is_empty() {
self.partial_block.replace(partial_block);
}
if self.last_segment_index.is_none() {
self.last_segment_index.replace(SegmentIndex::ZERO);
}
Ok(reconstructed_contents)
}
}
|
// This file is part of lock-free-multi-producer-single-consumer-ring-buffer. 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/lock-free-multi-producer-single-consumer-ring-buffer/master/COPYRIGHT. No part of lock-free-multi-producer-single-consumer-ring-buffer, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2018 The developers of lock-free-multi-producer-single-consumer-ring-buffer. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/lock-free-multi-producer-single-consumer-ring-buffer/master/COPYRIGHT.
#![allow(non_upper_case_globals)]
#![deny(missing_docs)]
#![feature(allocator_api, core_intrinsics)]
//! # lock-free-multi-producer-single-consumer-ring-buffer
//!
//! ## Usage
//!
//! ```
//! extern crate lock_free_multi_produce_single_consume_ring_buffer;
//!
//! use ::lock_free_multi_produce_single_consume_ring_buffer::*;
//!
//! let (ring_buffer_consumer, ring_buffer_producers) = RingBuffer::new(capacity, number_of_producers);
//!
//! // For each producer thread.
//! let ring_buffer_producer = ring_buffer_producers.get(0);
//!
//! let result = ring_buffer_producer.acquire(length);
//! // result is `None` if length was too much; try a shorter length.
//!
//! let slice_guard = result.unwrap();
//!
//! // Dereferences to a slice.
//! // slice_guard[0] = some_value;
//!
//! // Produce (relinquishes the slice).
//! drop(slice_guard);
//!
//! ring_buffer_producer.produce();
//!
//! // For each consumer thread.
//! let slice_guard = ring_buffer_consumer.consume();
//!
//! // Iterate, move out, etc.
//! println!("should be `some_value`", slice_guard.move_out(slice_guard.len())[0]);
//!
//! // Releases the slice so producers can now use it.
//! drop(slice_guard);
//! ```
//!
//! Once all the producers and the consumer are dropped then the memory underlying the ring buffer is freed and any unconsumed items in it are safely `Drop`ped.
//!
//!
//! ## The following documentation is originally "Copyright (c) 2016-2017 Mindaugas Rasiukevicius <rmind at noxt eu>".
//!
//! Atomic multi-producer single-consumer ring buffer, which supports contiguous range operations and which can be conveniently used for message passing.
//!
//! There are three offsets ("think of clock hands"):-
//!
//! * `NEXT`: marks the beginning of the available space,
//! * `WRITTEN`: the point up to which the data is actually written.
//! * Observed `READY`: point up to which data is ready to be written.
//!
//!
//! ### Producers
//!
//! Observe and save the 'next' offset, then request `N` bytes from the ring buffer by atomically advancing the `next` offset.
//! Once the data is written into the "reserved" buffer space, the thread clears the saved value; these observed values are used to compute the `ready` offset.
//!
//!
//! ### Consumer
//!
//! Writes the data between `written` and `ready` offsets and updates the `written` value.
//! The consumer thread scans for the lowest seen value by the producers.
//!
//!
//! ### Key invariant
//!
//! Producers cannot go beyond the `written` offset
//!
//! Producers are not allowed to catch up with the consumer.
//!
//! Only the consumer is allowed to catch up with the producer, ie set the `written` offset to be equal to the `next` offset.
//!
//!
//! ### Wrap-around
//!
//! If the producer cannot acquire the requested length due to little available space at the end of the buffer, then it will wraparound.
//!
//! The `WrapLockBit` in `next` offset is used to lock the `end` offset.
//!
//! There is an ABA problem if one producer stalls while a pair of producer and consumer would both successfully wrap-around and set the `next` offset to the stale value of the first producer, thus letting it to perform a successful compare-and-swap (CAS) violating the invariant.
//! A counter in the `next` offset (masked by `WrapCounter`) is used to prevent from this problem.
//! It is incremented on wraparounds.
//!
//! The same ABA problem could also cause a stale `ready` offset, which could be observed by the consumer.
//! The algorithm sets `WrapLockBit` in the `seen` value before advancing the `next` and clears this bit after the successful advancing; this ensures that only the stable `ready` observed by the consumer.
#[macro_use] extern crate likely;
use ::std::alloc::Alloc;
use ::std::alloc::Global;
use ::std::alloc::Layout;
use ::std::cell::Cell;
use ::std::cell::UnsafeCell;
use ::std::cmp::min;
use ::std::cmp::max;
use ::std::intrinsics::atomic_cxchgweak;
use ::std::marker::PhantomData;
use ::std::mem::align_of;
use ::std::mem::size_of;
use ::std::mem::transmute_copy;
use ::std::mem::uninitialized;
use ::std::ops::Deref;
use ::std::ops::DerefMut;
use ::std::ptr::drop_in_place;
use ::std::ptr::NonNull;
use ::std::ptr::write;
use ::std::slice::from_raw_parts;
use ::std::slice::from_raw_parts_mut;
use ::std::sync::atomic::fence;
use ::std::sync::atomic::Ordering::SeqCst;
use ::std::sync::atomic::spin_loop_hint;
use std::sync::Arc;
include!("fence_stores.rs");
include!("RingBuffer.rs");
include!("RingBufferConsumer.rs");
include!("RingBufferConsumerGuard.rs");
include!("RingBufferInner.rs");
include!("RingBufferInnerHeader.rs");
include!("RingBufferInnerDropHandler.rs");
include!("RingBufferOffset.rs");
include!("RingBufferProducer.rs");
include!("RingBufferProducerGuard.rs");
include!("RingBufferProducerInner.rs");
include!("SpinLockBackOff.rs");
include!("VolatileRingBufferOffset.rs");
|
/*
Okay... one way or another I have a list of per-rect properties, like position. All rects in that list are drawn with the same texture and geometry, however that geometry is specified. Then I have another list of (texture, rect list) pairs. And that gets me batched drawing in a form that's easy to make automatic.
THEN I have one or more frames in flight, and each frame in flight has its own copies of the things necessary to actually draw that frame: uniforms/push constants, descriptor set, and the GPU buffers containing the list of (texture, rect list) pairs
To actually draw, you grab the appropriate free frame-in-flight, copy your (texture, rect list) pairs into its buffers, and for each pair issue one draw call to draw that chunk of the buffer.
*/
/*
Okay, so the first step is going to be rendering multiple things with the same
geometry and texture using instanced drawing. DONE.
Next step is to render things with different textures. DONE.
Last step is to render things with different textures and
different geometry. Trivial to do currently but it would be nice
to not re-bind the mesh descriptor if we don't have to...
How much does that actually matter though? Dunno.
DONE.
Time to clean up and refactor!
Last+1 step is going to be having multiple pipelines with
different shaders.
Last+2 step might be to make rendering quads a more efficient special case,
for example by reifying the geometry in the vertex shader a la the Rendy
quads example. This might also be where we try to reduce
descriptor swaps if possible.
Then actual last step will be to have multiple render passes with different
render targets.
*/
use std::io;
use std::mem;
use std::sync::Arc;
use euclid;
use oorandom;
pub type Point2 = euclid::Point2D<f32, euclid::UnknownUnit>;
pub type Transform3 = euclid::Transform3D<f32, euclid::UnknownUnit, euclid::UnknownUnit>;
pub type Rect = euclid::Rect<f32, euclid::UnknownUnit>;
pub mod quad;
/*
use rendy::command::{QueueId, RenderPassEncoder};
use rendy::factory::{Factory, ImageState};
use rendy::graph::{render::*, GraphContext, NodeBuffer, NodeImage};
use rendy::hal;
use rendy::hal::Device as _;
use rendy::memory::Dynamic;
use rendy::mesh::{AsVertex, Mesh, PosColorNorm};
use rendy::resource::{
Buffer, BufferInfo, DescriptorSet, DescriptorSetLayout, Escape, Filter, Handle, SamplerInfo,
WrapMode,
};
use rendy::texture::Texture;
use rendy::wsi::winit;
// TODO: Think a bit better about how to do this. Can we set it or specialize it at runtime perhaps?
// Perhaps.
// For now though, this is okay if not great.
// It WOULD be quite nice to be able to play with OpenGL and DX12 backends.
//
// TODO: We ALSO need to specify features to rendy to build these, so this doesn't even work currently.
// For now we only ever specify Vulkan.
//
// Rendy doesn't currently work on gfx-rs's DX12 backend though, and the OpenGL backend
// is still WIP, so... I guess this is what we get.
/// Data we need per instance. DrawParam gets turned into this.
/// We have to be *quite particular* about layout since this gets
/// fed straight to the shader.
///
/// TODO: Currently the shader doesn't use src or color though.
#[repr(C, align(16))]
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct InstanceData {
// The euclid types don't impl PartialOrd and PartialEq so
// we have to use the lower-level forms for
// actually sending to the GPU. :-/
transform: [f32; 16],
src: [f32; 4],
color: [f32; 4],
}
use rendy::mesh::{Attribute, VertexFormat};
/// Okay, this tripped me up. Instance data is technically
/// part of the per-vertex data. So we describe it as
/// part of the vertex format. This is where that
/// definition happens.
///
/// This trait impl is basically extended from the impl for
/// `rendy::mesh::Transform`
impl AsVertex for InstanceData {
fn vertex() -> VertexFormat {
VertexFormat {
attributes: vec![
Attribute::new(
"Transform1",
0,
hal::pso::Element {
format: hal::format::Format::Rgba32Sfloat,
offset: 0,
},
),
Attribute::new(
"Transform2",
1,
hal::pso::Element {
format: hal::format::Format::Rgba32Sfloat,
offset: 16,
},
),
Attribute::new(
"Transform3",
0,
hal::pso::Element {
format: hal::format::Format::Rgba32Sfloat,
offset: 32,
},
),
Attribute::new(
"Transform4",
0,
hal::pso::Element {
format: hal::format::Format::Rgba32Sfloat,
offset: 48,
},
),
// rect
Attribute::new(
"rect",
0,
hal::pso::Element {
format: hal::format::Format::Rgba32Sfloat,
offset: 64,
},
),
// color
Attribute::new(
"color",
0,
hal::pso::Element {
format: hal::format::Format::Rgba32Sfloat,
offset: 80,
},
),
],
stride: 96,
}
}
}
/// Uniform data. Each frame contains one of these.
#[derive(Clone, Copy, Debug, Default)]
#[repr(C, align(16))]
pub struct UniformData {
pub proj: Transform3,
pub view: Transform3,
}
/// An instance buffer that bounds checks how many instances you can
/// put into it. Is not generic on the instance data type, just holds
/// `InstanceData`.
/// TODO: Make it resizeable someday.
///
/// The buffer in a `FrameInFlight`.
///
/// We pack data from multiple `DrawCall`'s together into one `Buffer`
/// but each draw call can have a varying amount of instance data,
/// so we end up with something like:
///
/// ```
/// | Instances1 ... | Instances2 ... | ... | empty space |
/// ```
///
/// Right now we have a fixed size buffer and just limit the number
/// of objects in it. TODO: Eventually someday we will grow the buffer
/// as needed. Maybe shrink it too? Not sure about that.
#[derive(Debug)]
pub struct InstanceBuffer<B>
where
B: hal::Backend,
{
/// Capacity, in *number of instances*.
pub capacity: u64,
/// Number of instances currently in the buffer
pub length: u64,
/// Actual buffer object.
pub buffer: Escape<Buffer<B>>,
}
impl<B> InstanceBuffer<B>
where
B: hal::Backend,
{
/// Create a new empty instance buffer with the given
/// capacity in *number of instances*
pub fn new(capacity: u64, factory: &Factory<B>) -> Self {
let bytes_per_instance = Self::instance_size();
let buffer_size = capacity * bytes_per_instance;
let buffer = factory
.create_buffer(
BufferInfo {
size: buffer_size,
// TODO: We probably don't need usage::Uniform here anymore. Confirm!
usage: hal::buffer::Usage::UNIFORM | hal::buffer::Usage::VERTEX,
},
Dynamic,
)
.unwrap();
Self {
capacity,
length: 0,
buffer,
}
}
/// Resizes the underlying buffer. Does NOT copy the contents
/// of the old buffer (yet), new buffer is empty.
pub fn resize(&mut self, factory: &Factory<B>, new_capacity: u64) {
let buffer = factory
.create_buffer(
BufferInfo {
size: new_capacity,
// TODO: We probably don't need usage::Uniform here anymore. Confirm!
usage: hal::buffer::Usage::UNIFORM | hal::buffer::Usage::VERTEX,
},
Dynamic,
)
.unwrap();
let old_buffer = mem::replace(&mut self.buffer, buffer);
unsafe {
factory.destroy_relevant_buffer(Escape::unescape(old_buffer));
}
self.length = 0;
self.capacity = new_capacity;
}
/// Returns the size in bytes of a single instance for this type.
/// For now, this doesn't change, but it's convenient to have.
///
/// This can't be a const fn yet, 'cause trait bounds.
/// See https://github.com/rust-lang/rust/issues/57563
pub fn instance_size() -> u64 {
mem::size_of::<InstanceData>() as u64
}
/// Returns the buffer size in bytes, rounded up
/// to the given alignment.
/// TODO: Are the alignment requirements for this necessary?
pub fn buffer_size(&self, align: u64) -> u64 {
(((Self::instance_size() * self.capacity) - 1) / align + 1) * align
}
/// Returns an offset in bytes, pointing to free space right after
/// the given number of instances, or None if `idx >= self.capacity`
pub fn instance_offset(&self, idx: u64) -> Option<u64> {
if idx >= self.capacity {
None
} else {
Some(idx * Self::instance_size())
}
}
/// Empties the buffer by setting the length to 0.
/// Capacity remains unchanged.
pub fn clear(&mut self) {
self.length = 0;
}
/// Copies the instance data in the given slice into the buffer,
/// starting from the current end of it.
/// Returns the offset at which it started if ok, or if the buffer
/// is not large enough returns Err.
///
/// TODO: Better error types. Do bounds checks with assert_dbg!()?
pub fn add_slice(
&mut self,
factory: &Factory<B>,
instances: &[InstanceData],
) -> Result<u64, ()> {
if self.length + (instances.len() as u64) >= self.capacity {
return Err(());
}
let offset = self.instance_offset(self.length).ok_or(())?;
// Vulkan doesn't seem to like zero-size copies very much.
if instances.len() > 0 {
unsafe {
factory
.upload_visible_buffer(&mut self.buffer, offset, instances)
.unwrap();
}
self.length += instances.len() as u64;
}
Ok(self.length)
}
pub fn inner(&self) -> &Buffer<B> {
&self.buffer
}
pub fn inner_mut(&mut self) -> &mut Buffer<B> {
&mut self.buffer
}
}
/// What data we need for each frame in flight.
/// Rendy doesn't do any synchronization for us
/// beyond guarenteeing that when we get a new frame
/// index everything touched by that frame index is
/// now free to reuse. So we just make one entire
/// set of data per frame.
///
/// We could make different frames share buffers
/// and descriptor sets and such and only change bits
/// that aren't in use from other frames, but that's
/// more complex than I want to get into right now.
///
/// When we do want to do that though, I think the simple
/// way would be... maybe create a structure through which
/// a FrameInFlight can be altered and which records if
/// things have actually changed. Actually, the DrawCall
/// might the place to handle that? Hm, having a separate
/// Buffer per draw call might be the way to go too? If
/// the buffer does not change from one draw call to the
/// next, we don't need to re-record its data, just issue
/// the draw call directly with the right PrepareReuse...
/// idk, I'm rambling.
#[derive(Debug)]
struct FrameInFlight<B>
where
B: hal::Backend,
{
/// The buffer where we store instance data.
buffer: InstanceBuffer<B>,
/// One descriptor set per draw call we do.
/// Also has the number of instances in that draw call,
/// so we can find offsets.
descriptor_sets: Vec<Escape<DescriptorSet<B>>>,
/// The frame's local copy of uniform data.
push_constants: [u32; 32],
}
impl<B> FrameInFlight<B>
where
B: hal::Backend,
{
/// All our descriptor sets use the same layout.
/// This one! We have an instance buffer, an
/// image, and a sampler.
const LAYOUT: &'static [hal::pso::DescriptorSetLayoutBinding] = &[
// TODO: Can we get rid of this uniform buffer since we use push constants?
// Doesn't look like it, 'cause we use the buffer for our instance data too.
hal::pso::DescriptorSetLayoutBinding {
binding: 0,
ty: hal::pso::DescriptorType::UniformBuffer,
count: 1,
stage_flags: hal::pso::ShaderStageFlags::GRAPHICS,
immutable_samplers: false,
},
hal::pso::DescriptorSetLayoutBinding {
binding: 1,
ty: hal::pso::DescriptorType::SampledImage,
count: 1,
stage_flags: hal::pso::ShaderStageFlags::FRAGMENT,
immutable_samplers: false,
},
hal::pso::DescriptorSetLayoutBinding {
binding: 2,
ty: hal::pso::DescriptorType::Sampler,
count: 1,
stage_flags: hal::pso::ShaderStageFlags::FRAGMENT,
immutable_samplers: false,
},
];
fn get_descriptor_set_layout() -> SetLayout {
SetLayout {
bindings: Self::LAYOUT.to_vec(),
}
}
fn new(
factory: &mut Factory<B>,
align: u64,
draw_calls: &[DrawCall<B>],
descriptor_set: &Handle<DescriptorSetLayout<B>>,
) -> Self {
use std::convert::TryInto;
let buffer_count = MAX_OBJECTS * draw_calls.len();
let buffer = InstanceBuffer::new(buffer_count.try_into().unwrap(), factory);
let descriptor_sets = vec![];
let mut ret = Self {
buffer,
descriptor_sets,
push_constants: [0; 32],
};
for draw_call in draw_calls {
// all descriptor sets use the same layout
// we need one per draw call, per frame in flight.
ret.create_descriptor_sets(factory, draw_call, descriptor_set, align);
}
ret
}
/// Takes a draw call and creates a descriptor set that points
/// at its resources.
///
/// For now we do not care about preserving descriptor sets between draw calls.
fn create_descriptor_sets(
&mut self,
factory: &Factory<B>,
draw_call: &DrawCall<B>,
layout: &Handle<DescriptorSetLayout<B>>,
_align: u64,
) {
// Does this sampler need to stay alive? We pass a
// reference to it elsewhere in an `unsafe` block...
// It's cached in the Factory anyway, so I don't think so.
let sampler = factory
.get_sampler(draw_call.sampler_info.clone())
.expect("Could not get sampler");
unsafe {
let set = factory.create_descriptor_set(layout.clone()).unwrap();
factory.write_descriptor_sets(Some(hal::pso::DescriptorSetWrite {
set: set.raw(),
binding: 1,
array_offset: 0,
descriptors: vec![hal::pso::Descriptor::Image(
draw_call.texture.view().raw(),
hal::image::Layout::ShaderReadOnlyOptimal,
)],
}));
factory.write_descriptor_sets(Some(hal::pso::DescriptorSetWrite {
set: set.raw(),
binding: 2,
array_offset: 0,
descriptors: vec![hal::pso::Descriptor::Sampler(sampler.raw())],
}));
self.descriptor_sets.push(set);
}
}
/// This happens before a frame; it should take a LIST of draw calls and take
/// care of uploading EACH of them into the buffer so they don't clash!
fn prepare(
&mut self,
factory: &Factory<B>,
uniforms: &UniformData,
draw_calls: &[DrawCall<B>],
_layout: &Handle<DescriptorSetLayout<B>>,
_align: u64,
) {
assert!(draw_calls.len() > 0);
// Store the uniforms to be shoved into push constants this frame
// TODO: Be less crude about indexing and such.
for (i, vl) in uniforms.proj.to_row_major_array().into_iter().enumerate() {
self.push_constants[i] = vl.to_bits();
}
for (i, vl) in uniforms.view.to_row_major_array().into_iter().enumerate() {
self.push_constants[16 + i] = vl.to_bits();
}
//println!("Preparing frame-in-flight, {} draw calls, first has {} instances.", draw_calls.len(),
//draw_calls[0].objects.len());
self.buffer.clear();
for draw_call in draw_calls {
let _offset = self
.buffer
.add_slice(factory, &draw_call.objects[..])
.unwrap();
}
}
/// Draws a list of DrawCall's.
fn draw(
&mut self,
draw_calls: &[DrawCall<B>],
layout: &B::PipelineLayout,
encoder: &mut RenderPassEncoder<'_, B>,
_align: u64,
) {
//println!("Drawing {} draw calls", draw_calls.len());
let mut instance_count: u64 = 0;
for (draw_call, descriptor_set) in draw_calls.iter().zip(&self.descriptor_sets) {
//println!("Drawing {:#?}, {:#?}, {}", draw_call, descriptor_set, draw_offset);
// This is a bit weird, but basically tells the thing where to find the
// instance data. The stride and such of the instance structure is
// defined in the `AsVertex` definition.
unsafe {
encoder.bind_graphics_descriptor_sets(
layout,
0,
std::iter::once(descriptor_set.raw()),
std::iter::empty(),
);
}
draw_call
.mesh
.as_ref()
.bind(0, &[PosColorNorm::vertex()], encoder)
.expect("Could not bind mesh?");
// The 1 here is because this is the second vertex buffer we've bound;
// the first is bound to the Mesh.
unsafe {
encoder.bind_vertex_buffers(
1,
std::iter::once((
self.buffer.inner().raw(),
self.buffer.instance_offset(instance_count).unwrap(),
)),
);
}
unsafe {
encoder.push_constants(
layout,
hal::pso::ShaderStageFlags::ALL,
0,
&self.push_constants,
);
}
// The length of the mesh is the number of indices if it has any, the number
// of verts otherwise. See https://github.com/amethyst/rendy/issues/119
let indices = 0..(draw_call.mesh.len() as u32);
// This count is the *number of instances*. What instance
// to start at in the buffer is defined by the offset in
// `bind_vertex_buffers()` above, and the stride/size of an instance
// is defined in `AsVertex`.
let instances = 0..(draw_call.objects.len() as u32);
unsafe {
encoder.draw_indexed(indices, 0, instances);
}
instance_count += draw_call.objects.len() as u64;
}
}
}
/// The data we need for a single draw call, which
/// gets bound to descriptor sets and
///
/// For now we re-bind EVERYTHING even if only certain
/// resources have changed (for example, texture changes
/// and mesh stays the same). Should be easy to check
/// that in the future and make the various things
/// in here `Option`s.
#[derive(Debug)]
pub struct DrawCall<B>
where
B: hal::Backend,
{
objects: Vec<InstanceData>,
mesh: Arc<Mesh<B>>,
texture: Arc<Texture<B>>,
/// We just need the actual config for the sampler 'cause
/// Rendy's `Factory` can manage a sampler cache itself.
sampler_info: SamplerInfo,
}
impl<B> DrawCall<B>
where
B: hal::Backend,
{
pub fn new(texture: Arc<Texture<B>>, mesh: Arc<Mesh<B>>) -> Self {
let sampler_info = SamplerInfo::new(Filter::Nearest, WrapMode::Clamp);
Self {
objects: vec![],
mesh,
texture,
sampler_info,
}
}
pub fn add_object(&mut self, rng: &mut oorandom::Rand32, max_width: f32, max_height: f32) {
if self.objects.len() < MAX_OBJECTS {
let x = rng.rand_float() * max_width;
let y = rng.rand_float() * max_height;
//println!("Adding object at {}x{}", x, y);
let transform = Transform3::create_translation(x, y, -100.0);
let src = Rect::from(euclid::Size2D::new(1.0, 1.0));
let color = [1.0, 0.0, 1.0, 1.0];
let instance = InstanceData {
transform: transform.to_row_major_array(),
src: [src.origin.x, src.origin.y, src.size.width, src.size.height],
color,
};
self.objects.push(instance);
}
}
}
#[derive(Debug)]
pub struct Aux<B: hal::Backend> {
pub frames: usize,
pub align: u64,
pub draws: Vec<DrawCall<B>>,
pub camera: UniformData,
pub shader: rendy::shader::ShaderSetBuilder,
}
const MAX_OBJECTS: usize = 10_000;
/// Render group that consist of simple graphics pipeline.
#[derive(Debug)]
pub struct MeshRenderGroup<B>
where
B: hal::Backend,
{
set_layouts: Vec<Handle<DescriptorSetLayout<B>>>,
pipeline_layout: B::PipelineLayout,
graphics_pipeline: B::GraphicsPipeline,
frames_in_flight: Vec<FrameInFlight<B>>,
}
/// Descriptor for simple render group.
#[derive(Debug)]
pub struct MeshRenderGroupDesc {
// inner: MeshRenderPipelineDesc,
colors: Vec<hal::pso::ColorBlendDesc>,
}
impl MeshRenderGroupDesc {
pub fn new() -> Self {
Self {
colors: vec![hal::pso::ColorBlendDesc {
mask: hal::pso::ColorMask::ALL,
blend: Some(hal::pso::BlendState::ALPHA),
}],
}
}
}
impl<B> RenderGroupDesc<B, Aux<B>> for MeshRenderGroupDesc
where
B: hal::Backend,
{
fn buffers(&self) -> Vec<rendy::graph::BufferAccess> {
vec![]
}
fn images(&self) -> Vec<rendy::graph::ImageAccess> {
vec![]
}
fn colors(&self) -> usize {
self.colors.len()
}
fn depth(&self) -> bool {
true
}
fn build<'a>(
self,
_ctx: &GraphContext<B>,
factory: &mut Factory<B>,
_queue: QueueId,
aux: &Aux<B>,
framebuffer_width: u32,
framebuffer_height: u32,
subpass: hal::pass::Subpass<'_, B>,
_buffers: Vec<NodeBuffer>,
_images: Vec<NodeImage>,
) -> Result<Box<dyn RenderGroup<B, Aux<B>>>, failure::Error> {
let depth_stencil = hal::pso::DepthStencilDesc {
depth: Some(hal::pso::DepthTest {
fun: hal::pso::Comparison::LessEqual,
write: true,
}),
depth_bounds: false,
stencil: None,
};
let input_assembler_desc = hal::pso::InputAssemblerDesc {
primitive: hal::Primitive::TriangleList,
primitive_restart: hal::pso::PrimitiveRestart::Disabled,
};
let layout_sets = vec![FrameInFlight::<B>::get_descriptor_set_layout()];
let layout_push_constants = vec![(
hal::pso::ShaderStageFlags::ALL,
// Pretty sure the size of push constants is given in bytes,
// but even putting nonsense sizes in here seems to make
// the program run fine unless you put super extreme values in.
// Thanks, NVidia.
0..(mem::size_of::<UniformData>() as u32),
)];
let vertices = vec![
PosColorNorm::vertex().gfx_vertex_input_desc(hal::pso::VertexInputRate::Vertex),
InstanceData::vertex().gfx_vertex_input_desc(hal::pso::VertexInputRate::Instance(1)),
];
let set_layouts = layout_sets
.into_iter()
.map(|set| {
factory
.create_descriptor_set_layout(set.bindings)
.map(Handle::from)
})
.collect::<Result<Vec<_>, _>>()?;
let pipeline_layout = unsafe {
factory
.device()
.create_pipeline_layout(set_layouts.iter().map(|l| l.raw()), layout_push_constants)
}?;
let mut vertex_buffers = Vec::new();
let mut attributes = Vec::new();
for &(ref elements, stride, rate) in &vertices {
push_vertex_desc(elements, stride, rate, &mut vertex_buffers, &mut attributes);
}
let rect = hal::pso::Rect {
x: 0,
y: 0,
w: framebuffer_width as i16,
h: framebuffer_height as i16,
};
let mut shader_set = aux.shader.build(factory, Default::default()).unwrap();
// TODO: Make disposing of the shader set nicer. Either store it, or have a wrapper
// that disposes it on drop, or something. Would that cause a double-borrow?
//
// Actually, think about this more in general, 'cause there's other structures that
// need similar handling: set_layouts, pipeline layouts, etc.
let shaders = match shader_set.raw() {
Err(e) => {
shader_set.dispose(factory);
return Err(e);
}
Ok(s) => s,
};
let graphics_pipeline = unsafe {
factory.device().create_graphics_pipelines(
Some(hal::pso::GraphicsPipelineDesc {
shaders,
rasterizer: hal::pso::Rasterizer::FILL,
vertex_buffers,
attributes,
input_assembler: input_assembler_desc,
blender: hal::pso::BlendDesc {
logic_op: None,
targets: self.colors.clone(),
},
depth_stencil: depth_stencil,
multisampling: None,
baked_states: hal::pso::BakedStates {
viewport: Some(hal::pso::Viewport {
rect,
depth: 0.0..1.0,
}),
scissor: Some(rect),
blend_color: None,
depth_bounds: None,
},
layout: &pipeline_layout,
subpass,
flags: hal::pso::PipelineCreationFlags::empty(),
parent: hal::pso::BasePipeline::None,
}),
None,
)
}
.remove(0)
.map_err(|e| {
shader_set.dispose(factory);
e
})?;
let (frames, align) = (aux.frames, aux.align);
// Each `FrameInFlight` needs one descriptor set per draw call.
let mut frames_in_flight = vec![];
frames_in_flight.extend(
(0..frames).map(|_| FrameInFlight::new(factory, align, &aux.draws, &set_layouts[0])),
);
shader_set.dispose(factory);
Ok(Box::new(MeshRenderGroup::<B> {
set_layouts,
pipeline_layout,
graphics_pipeline,
frames_in_flight,
}))
}
}
impl<B> RenderGroup<B, Aux<B>> for MeshRenderGroup<B>
where
B: hal::Backend,
{
fn prepare(
&mut self,
factory: &Factory<B>,
_queue: QueueId,
index: usize,
_subpass: hal::pass::Subpass<'_, B>,
aux: &Aux<B>,
) -> PrepareResult {
let align = aux.align;
let layout = &self.set_layouts[0];
self.frames_in_flight[index].prepare(factory, &aux.camera, &aux.draws, layout, align);
// TODO: Investigate this more...
// Ooooooh in the example it always used the same draw command buffer 'cause it
// always did indirect drawing, and just modified the draw command in the data buffer.
// we're doing direct drawing now so we have to always re-record our drawing
// command buffers when they change -- and the number of instances always changes
// in this program, so!
//PrepareResult::DrawReuse
PrepareResult::DrawRecord
}
fn draw_inline(
&mut self,
mut encoder: RenderPassEncoder<'_, B>,
index: usize,
_subpass: hal::pass::Subpass<'_, B>,
aux: &Aux<B>,
) {
encoder.bind_graphics_pipeline(&self.graphics_pipeline);
self.frames_in_flight[index].draw(
&aux.draws,
&self.pipeline_layout,
&mut encoder,
aux.align,
);
}
fn dispose(self: Box<Self>, factory: &mut Factory<B>, _aux: &Aux<B>) {
unsafe {
factory
.device()
.destroy_graphics_pipeline(self.graphics_pipeline);
factory
.device()
.destroy_pipeline_layout(self.pipeline_layout);
drop(self.set_layouts);
}
}
}
pub fn push_vertex_desc(
elements: &[hal::pso::Element<hal::format::Format>],
stride: hal::pso::ElemStride,
rate: hal::pso::VertexInputRate,
vertex_buffers: &mut Vec<hal::pso::VertexBufferDesc>,
attributes: &mut Vec<hal::pso::AttributeDesc>,
) {
let index = vertex_buffers.len() as hal::pso::BufferIndex;
vertex_buffers.push(hal::pso::VertexBufferDesc {
binding: index,
stride,
rate,
});
let mut location = attributes.last().map_or(0, |a| a.location + 1);
for &element in elements {
attributes.push(hal::pso::AttributeDesc {
location,
binding: index,
element,
});
location += 1;
}
}
/// This is how we can load an image and create a new texture.
pub fn make_texture<B>(device: &mut GraphicsDevice<B>, image_bytes: &[u8]) -> Arc<Texture<B>>
where
B: hal::Backend,
{
let cursor = std::io::Cursor::new(image_bytes);
let texture_builder = rendy::texture::image::load_from_image(cursor, Default::default())
.expect("Could not load texture?");
let texture = texture_builder
.build(
ImageState {
queue: device.queue_id,
stage: hal::pso::PipelineStage::FRAGMENT_SHADER,
access: hal::image::Access::SHADER_READ,
layout: hal::image::Layout::ShaderReadOnlyOptimal,
},
&mut device.factory,
)
.unwrap();
Arc::new(texture)
}
fn make_quad_mesh<B>(device: &mut GraphicsDevice<B>) -> Mesh<B>
where
B: hal::Backend,
{
let verts: Vec<[f32; 3]> = vec![
[0.0, 0.0, 0.0],
[0.0, 100.0, 0.0],
[100.0, 100.0, 0.0],
[100.0, 0.0, 0.0],
];
let indices = rendy::mesh::Indices::from(vec![0u32, 1, 2, 0, 2, 3]);
// TODO: Mesh color... how do we want to handle this?
// It's a bit of an open question in ggez as well, so.
// For now the shader just uses the vertex color.
// It feels weird but ggez more or less requires both vertex
// colors and per-model colors.
// Unless you want to handle changing sprite colors by
// creating entirely new geometry for the sprite.
let vertices: Vec<_> = verts
.into_iter()
.map(|v| PosColorNorm {
position: rendy::mesh::Position::from(v),
color: [1.0, 1.0, 1.0, 1.0].into(),
normal: rendy::mesh::Normal::from([0.0, 0.0, 1.0]),
})
.collect();
let m = Mesh::<B>::builder()
.with_indices(indices)
.with_vertices(&vertices[..])
.build(device.queue_id, &device.factory)
.unwrap();
m
}
/*
fn make_tri_mesh<B>(queue_id: QueueId, factory: &mut Factory<B>) -> Mesh<B>
where
B: hal::Backend,
{
let verts: Vec<[f32; 3]> = vec![[0.0, 0.0, 0.0], [100.0, 0.0, 0.0], [50.0, 100.0, 0.0]];
let indices = rendy::mesh::Indices::from(vec![0u32, 1, 2]);
// TODO: Mesh color... how do we want to handle this?
// It's a bit of an open question in ggez as well, so.
// For now the shader just uses the vertex color.
// It feels weird but ggez more or less requires both vertex
// colors and per-model colors.
// Unless you want to handle changing sprite colors by
// creating entirely new geometry for the sprite.
let vertices: Vec<_> = verts
.into_iter()
.map(|v| PosColorNorm {
position: rendy::mesh::Position::from(v),
color: [1.0, 1.0, 1.0, 1.0].into(),
normal: rendy::mesh::Normal::from([0.0, 0.0, 1.0]),
})
.collect();
let m = Mesh::<Backend>::builder()
.with_indices(indices)
.with_vertices(&vertices[..])
.build(queue_id, &factory)
.unwrap();
m
}
*/
/// Creates a shader builder from the given GLSL shader source texts.
///
/// Also takes names for the vertex and fragment shaders to be used
/// in debugging output.
pub fn load_shaders(vertex_src: &[u8], fragment_src: &[u8]) -> rendy::shader::ShaderSetBuilder {
use rendy::shader::SpirvShader;
let vert_cursor = io::Cursor::new(vertex_src);
let vert_words = hal::pso::read_spirv(vert_cursor)
.expect("Invalid SPIR-V buffer passed to load_shaders one way or another!");
let vertex = SpirvShader::new(vert_words, hal::pso::ShaderStageFlags::VERTEX, "main");
let frag_cursor = io::Cursor::new(fragment_src);
let frag_words = hal::pso::read_spirv(frag_cursor)
.expect("Invalid SPIR-V buffer passed to load_shaders one way or another!");
let fragment = SpirvShader::new(frag_words, hal::pso::ShaderStageFlags::FRAGMENT, "main");
let shader_builder: rendy::shader::ShaderSetBuilder =
rendy::shader::ShaderSetBuilder::default()
.with_vertex(&vertex)
.unwrap()
.with_fragment(&fragment)
.unwrap();
shader_builder
}
pub fn load_shader_files(
vertex_file: &str,
fragment_file: &str,
) -> rendy::shader::ShaderSetBuilder {
let vertex_src = std::fs::read(vertex_file).unwrap();
let fragment_src = std::fs::read(fragment_file).unwrap();
load_shaders(vertex_src.as_ref(), fragment_src.as_ref())
}
/*
Exploring API
General idea: render pass -> pipeline -> draw call -> instance
From Viral:
loop {
update_frame_data(); // This one writes into uniform buffers bound to frame level descriptor set
for pipeline in &pipelines {
pipeline.update_pipeline_specific_data(); // This one writes into uniform buffers bound to pipeline level descriptor set
for material in &pipeline.materials {
material.bind_material_descriptors_set();
for mesh in &material.meshes {
for object in &mesh.objects {
object.fill_instancing_data();
}
mesh.draw();
}
}
}
}
pub struct DrawCall {
// Mesh, texture, sampler info instance data.
}
/// Roughly corresponds to a RenderGroup
pub struct Pipeline {
// Draws
// Uniforms
// Shaders
}
pub struct GraphicsDevice {
// frames in flight...
// descriptor sets...
}
impl GraphicsDevice {
pub fn add_draw(&mut self, mesh: (), texture: (), sampler_info: (), instances: &[InstanceData]) {}
}
pub fn present() {}
*/
/// An initialized graphics device context,
/// with a window. The window itself should
/// be made optional later. We need it for
/// building a PresentNode but should be able
/// to manage without it and add one later.
pub struct GraphicsDevice<B>
where
B: hal::Backend,
{
// gfx-hal types
pub factory: Factory<B>,
pub queue_id: QueueId,
pub families: rendy::command::Families<B>,
}
impl<B> GraphicsDevice<B>
where
B: hal::Backend,
{
/*
Not sure this is useful after all...
We DO want to be able to modify the graph someday
and set up a new set of passes, but, not yet.
Issues to solve are how to handle the present node,
the color and depth buffers, etc.
Ok, the graph should separate out of this type.
Then we can also separat the winit window.
fn build_graph(&mut self) -> rendy::graph::Graph<B, Aux<B>> {
use rendy::graph::{present::PresentNode, render::*, GraphBuilder};
let mut graph_builder = GraphBuilder::<B, Aux<B>>::new();
// let color = graph_builder.create_image(
// window_kind,
// 1,
// factory.get_surface_format(&surface),
// Some(hal::command::ClearValue::Color([0.1, 0.2, 0.3, 1.0].into())),
// );
// let depth = graph_builder.create_image(
// window_kind,
// 1,
// hal::format::Format::D16Unorm,
// Some(hal::command::ClearValue::DepthStencil(
// hal::command::ClearDepthStencil(1.0, 0),
// )),
// );
let render_group_desc = MeshRenderGroupDesc::new();
let pass = graph_builder.add_node(
render_group_desc
.builder()
.into_subpass()
.with_color(self.color)
.with_depth_stencil(self.depth)
.into_pass(),
);
let surface = self.factory.create_surface(&self.window);
let present_builder =
PresentNode::builder(&self.factory, surface, self.color).with_dependency(pass);
let frames = present_builder.image_count();
let graph = graph_builder
.with_frames_in_flight(self.frame_count)
.build(&mut self.factory, &mut self.families, &self.aux)
.unwrap();
graph
}
*/
pub fn new() -> Self {
use rendy::factory::Config;
//use rendy::graph::{present::PresentNode, render::*, GraphBuilder};
//use rendy::hal::PhysicalDevice as _;
let config: Config = Default::default();
let (factory, families): (Factory<B>, _) = rendy::factory::init(config).unwrap();
//let width = 800u32;
//let height = 600u32;
//let window_kind = hal::image::Kind::D2(width, height, 1, 1);
// HACK suggested by Frizi, just use queue 0 for everything
// instead of getting it from `graph.node_queue(pass)`.
// Since we control in our `Config` what families we have
// and what they have, as long as we only ever use one family
// (which is probably fine) then we're prooooobably okay with
// this.
// TODO: Check and see if this has immproved now
let queue_id = QueueId {
family: families.family_by_index(0).id(),
index: 0,
};
Self {
factory,
families,
queue_id,
}
}
}
pub struct GraphicsWindowThing<B>
where
B: hal::Backend,
{
// winit types
pub window: winit::Window,
pub event_loop: winit::EventsLoop,
// Rendy types
pub graph: rendy::graph::Graph<B, Aux<B>>,
pub device: GraphicsDevice<B>,
pub depth: rendy::graph::ImageId,
pub color: rendy::graph::ImageId,
pub aux: Aux<B>,
}
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct DrawParam {
pub dest: Point2,
/*
/// A portion of the drawable to clip, as a fraction of the whole image.
/// Defaults to the whole image `(0,0 to 1,1)` if omitted.
pub src: Rect,
/// The position to draw the graphic expressed as a `Point2`.
pub dest: mint::Point2<f32>,
/// The orientation of the graphic in radians.
pub rotation: f32,
/// The x/y scale factors expressed as a `Vector2`.
pub scale: mint::Vector2<f32>,
/// An offset from the center for transform operations like scale/rotation,
/// with `0,0` meaning the origin and `1,1` meaning the opposite corner from the origin.
/// By default these operations are done from the top-left corner, so to rotate something
/// from the center specify `Point2::new(0.5, 0.5)` here.
pub offset: mint::Point2<f32>,
/// A color to draw the target with.
/// Default: white.
pub color: Color,
*/
}
pub fn draw(_ctx: &mut (), _target: (), _drawable: (), _param: DrawParam) -> Result<(), ()> {
Ok(())
}
impl<B> GraphicsWindowThing<B>
where
B: hal::Backend,
{
pub fn make_aux(
device: &mut GraphicsDevice<B>,
frames: u32,
width: f32,
height: f32,
) -> Aux<B> {
use hal::adapter::PhysicalDevice;
let heart_bytes =
include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/src/data/heart.png"));
let texture1 = make_texture(device, heart_bytes);
let object_mesh = Arc::new(make_quad_mesh(device));
let draws = vec![DrawCall::new(texture1, object_mesh.clone())];
let vertex_file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/data/mesh.vert.spv");
let fragment_file = concat!(env!("CARGO_MANIFEST_DIR"), "/src/data/mesh.frag.spv");
let align = device
.factory
.physical()
.limits()
.min_uniform_buffer_offset_alignment;
let width = width;
let height = height;
let aux = Aux {
frames: frames as _,
align,
draws,
camera: UniformData {
proj: Transform3::ortho(0.0, width, height, 0.0, 1.0, 200.0),
view: Transform3::create_translation(0.0, 0.0, 10.0),
},
shader: load_shader_files(vertex_file, fragment_file),
};
aux
}
pub fn new() -> Self {
use rendy::graph::{present::PresentNode, render::*, GraphBuilder};
use winit::{EventsLoop, WindowBuilder};
let mut event_loop = EventsLoop::new();
let window = WindowBuilder::new()
.with_title("Rendy example")
.build(&event_loop)
.unwrap();
event_loop.poll_events(|_| ());
let size = window
.get_inner_size()
.unwrap()
.to_physical(window.get_hidpi_factor());
let mut device = GraphicsDevice::<B>::new();
let mut graph_builder = GraphBuilder::<B, Aux<B>>::new();
let window_kind = hal::image::Kind::D2(size.width as u32, size.height as u32, 1, 1);
let surface: rendy::wsi::Surface<B> = device.factory.create_surface(&window);
let format = device.factory.get_surface_format(&surface);
let color = graph_builder.create_image(
window_kind,
1,
device.factory.get_surface_format(&surface),
Some(hal::command::ClearValue::Color([0.1, 0.2, 0.3, 1.0].into())),
);
let depth = graph_builder.create_image(
window_kind,
1,
hal::format::Format::D16Unorm,
Some(hal::command::ClearValue::DepthStencil(
hal::command::ClearDepthStencil(1.0, 0),
)),
);
let render_group_desc = MeshRenderGroupDesc::new();
let pass = graph_builder.add_node(
render_group_desc
.builder()
.into_subpass()
.with_color(color)
.with_depth_stencil(depth)
.into_pass(),
);
println!("Surface format is {:?}", format);
let present_builder =
PresentNode::builder(&device.factory, surface, color).with_dependency(pass);
let frames = present_builder.image_count();
graph_builder.add_node(present_builder);
let aux = Self::make_aux(&mut device, frames, size.width as f32, size.height as f32);
let graph = graph_builder
.with_frames_in_flight(frames)
.build(&mut device.factory, &mut device.families, &aux)
.unwrap();
Self {
window,
event_loop,
graph,
device,
color,
depth,
aux,
}
}
pub fn run(&mut self) {
use std::time;
use winit::{Event, WindowEvent};
let mut frames = 0u64..;
let mut rng = oorandom::Rand32::new(12345);
let mut should_close = false;
let started = time::Instant::now();
// TODO: Someday actually check against MAX_OBJECTS
while !should_close {
for _i in &mut frames {
self.device.factory.maintain(&mut self.device.families);
self.event_loop.poll_events(|event| match event {
Event::WindowEvent {
event: WindowEvent::CloseRequested,
..
} => should_close = true,
_ => (),
});
self.graph.run(
&mut self.device.factory,
&mut self.device.families,
&self.aux,
);
// Add another object
for draw_call in &mut self.aux.draws {
draw_call.add_object(&mut rng, 1024.0, 768.0);
}
if should_close {
break;
}
}
}
let finished = time::Instant::now();
let dt = finished - started;
let millis = dt.as_millis() as f64;
let fps = frames.start as f64 / (millis / 1000.0);
println!(
"{} frames over {} seconds; {} fps",
frames.start,
millis / 1000.0,
fps
);
}
pub fn dispose(mut self) {
// TODO: This doesn't actually dispose of everything right.
// Why not?
self.graph.dispose(&mut self.device.factory, &self.aux);
//self.device.factory.dispose(self.aux.
}
}
/// This is sorta squirrelly, it can't easily be a method
/// without us having to specify the backend type anyway,
/// soooooo.
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
pub fn new_vulkan_device() -> GraphicsDevice<rendy::vulkan::Backend> {
GraphicsDevice::new()
}
#[cfg(target_os = "macos")]
pub fn new_metal_device() -> GraphicsDevice<rendy::metal::Backend> {
GraphicsDevice::new()
}
#[cfg(target_os = "windows")]
pub fn new_dx_device() -> GraphicsDevice<rendy::dx12::Backend> {
GraphicsDevice::new()
}
*/
|
// source: "A Singly Linked List in Rust" by Ryan Levick on YouTube
// node struct containing some type T and a reference to next link
struct Node<T> {
element: T,
next: Link<T>,
}
// type specifier to make things prettier
type Link<T> = Option<Box<Node<T>>>;
// container for linked list containing a head and the length of how many links there are
pub struct LinkedList<T> {
head: Link<T>,
length: i32,
}
// implementation of linked list
impl<T> LinkedList<T> {
// new func instantiating a linked list with no head and a length of 0
fn new() -> LinkedList<T> {
LinkedList { head: None, length: 0, }
}
// push func to push new link onto linked list
fn push(&mut self, element: T) {
// takes old head from self
let old_head = self.head.take();
// instantiates new head link object
let new_head = Box::new(Node {
element,
next: old_head,
});
// sets self.head to the new head
self.head = Some(new_head);
// increment length
self.length += 1;
}
// pop func to pop link off of linked list
fn pop(&mut self) -> Option<T> {
// decrement length
self.length -= 1;
// take old head from self and map to return element
self.head.take().map(|n| {
// sets head to next element in list
self.head = n.next;
// returns popped element
n.element
})
}
// peek func to preview whats at the head
fn peek(&self) -> Option<&T> {
// returns reference to element if exists
self.head.as_ref().map(|n| &n.element)
}
}
|
use crate::error::Error;
pub struct Checksum<I: Iterator<Item = Result<u8, Error>>> {
source: I,
row: u32,
sum: u8,
}
impl<I: Iterator<Item = Result<u8, Error>>> From<I> for Checksum<I> {
fn from(source: I) -> Self {
Self {
source: source,
row: 1,
sum: 0,
}
}
}
impl<I: Iterator<Item = Result<u8, Error>>> Iterator for Checksum<I> {
type Item = Result<u8, Error>;
fn next(&mut self) -> Option<Self::Item> {
match self.source.next() {
item @ Some(Ok(b'\n')) => {
self.sum = 0;
self.row += 1;
item
}
item @ Some(Ok(b'\r')) => {
self.sum = 0;
item
}
Some(Ok(b'*')) => {
let mut checksum = 0;
loop {
let number = match self.source.next() {
Some(Ok(b'0')) => 0,
Some(Ok(b'1')) => 1,
Some(Ok(b'2')) => 2,
Some(Ok(b'3')) => 3,
Some(Ok(b'4')) => 4,
Some(Ok(b'5')) => 5,
Some(Ok(b'6')) => 6,
Some(Ok(b'7')) => 7,
Some(Ok(b'8')) => 8,
Some(Ok(b'9')) => 9,
Some(Ok(_)) if self.sum != checksum => {
break Some(Err(Error::Checksum(self.sum, checksum, self.row)))
}
item => break item,
};
if checksum != 0 {
checksum *= 10;
}
checksum += number;
}
}
Some(Ok(code)) => {
self.sum ^= code;
Some(Ok(code))
}
item => item,
}
}
}
|
struct Solution;
impl Solution {
pub fn can_jump(nums: Vec<i32>) -> bool {
let n = nums.len();
if n == 0 {
return true;
}
// 最远可以到达的位置
let mut max_dis = 0;
for (i, num) in nums.into_iter().enumerate() {
// 这个位置超过了最远可以到达的位置，后面都不可达了。
if i > max_dis {
break;
}
max_dis = max_dis.max(i + num as usize);
// 最远距离已经可以到达最后的位置了。
if max_dis >= n - 1 {
return true;
}
}
max_dis >= n - 1
}
// 这个实现有点慢。
pub fn can_jump_slow(nums: Vec<i32>) -> bool {
let n = nums.len();
if n == 0 {
return true;
}
// mark[i] 表示从 i 出发是否可以到最后一个位置。
let mut mark = vec![false; n];
mark[n - 1] = true; // 自己可以到自己。
for i in (0..n - 1).rev() {
// 从当前位置到最后一个位置的最远距离。
let mut max_dis = (nums[i] as usize).min(n - 1 - i);
// 如果从 i 经过 max_dis 到达的位置标记是 true，那么说明从 i 也可以到达最后的位置。
while max_dis > 0 {
if mark[i + max_dis] {
mark[i] = true;
break;
}
max_dis -= 1;
}
}
mark[0]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_can_jump() {
assert_eq!(Solution::can_jump(vec![2, 3, 1, 1, 4]), true);
assert_eq!(Solution::can_jump(vec![3, 2, 1, 0, 4]), false);
}
}
|
use near_contract_standards::non_fungible_token::core::NonFungibleTokenCore;
use near_contract_standards::non_fungible_token::NonFungibleToken;
use near_contract_standards::non_fungible_token::{Token, TokenId};
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::UnorderedSet;
use near_sdk::json_types::ValidAccountId;
use near_sdk::Balance;
use near_sdk::Gas;
use near_sdk::{
env, ext_contract, near_bindgen, AccountId, BorshStorageKey, PanicOnDefault, Promise,
PromiseOrValue, PromiseResult,
};
use std::convert::TryFrom;
near_sdk::setup_alloc!();
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
pub struct SendNFTContract {
nft: NonFungibleToken,
owner_id: AccountId,
tokens: UnorderedSet<(AccountId, TokenId)>,
}
#[derive(BorshSerialize, BorshStorageKey)]
enum StorageKey {
NonFungibleToken,
TokenAccountMapping,
TokenMetadata,
Enumeration,
Approval,
}
pub trait Ownable {
fn assert_owner(&self) {
assert_eq!(
env::predecessor_account_id(),
self.owner(),
"Ownable: predecessor is not the owner"
);
}
fn owner(&self) -> AccountId;
fn transfer_ownership(&mut self, owner: AccountId);
}
#[near_bindgen]
impl Ownable for SendNFTContract {
fn owner(&self) -> AccountId {
self.owner_id.clone()
}
fn transfer_ownership(&mut self, owner: AccountId) {
self.assert_owner();
self.owner_id = owner;
}
}
#[ext_contract(ext_self)]
trait ExtSelf {
fn nft_transfer(&mut self, account_id: AccountId, token_id: TokenId) -> Promise;
fn nft_transfer_callback(&mut self) -> Promise;
fn nft_batch_transfer(&mut self)-> Promise;
}
const GAS_FOR_ROYALTIES: Gas = 0;
const NO_DEPOSIT: Balance = 0;
#[near_bindgen]
impl SendNFTContract {
#[init]
pub fn new(owner_id: AccountId, mappings: Vec<(AccountId, TokenId)>) -> Self {
let owner = ValidAccountId::try_from(owner_id.clone()).expect("Invalid AccountId");
assert!(!env::state_exists(), "Already initialized");
let mut nft = NonFungibleToken::new(
StorageKey::NonFungibleToken,
owner.clone(),
Some(StorageKey::TokenMetadata),
Some(StorageKey::Enumeration),
Some(StorageKey::Approval),
);
for (_, token_id) in &mappings {
nft.mint(token_id.into(), owner.clone(), None);
}
let mut map = UnorderedSet::new(StorageKey::TokenAccountMapping);
map.extend(mappings);
Self {
owner_id,
tokens: map,
nft,
}
}
pub fn nft_batch_transfer(&mut self) ->bool {
self.assert_owner();
for (acc_id, t_id) in self.tokens.iter() {
//self.nft.nft_transfer_call(, token_id: TokenId, approval_id: Option<u64>, memo: Option<String>, msg: String)
ext_self::nft_transfer(
acc_id,
t_id,
&env::current_account_id(),
NO_DEPOSIT,
GAS_FOR_ROYALTIES,
)
.then(ext_self::nft_transfer_callback(
&env::current_account_id(),
NO_DEPOSIT,
GAS_FOR_ROYALTIES,
));
}
true
}
#[private]
pub fn nft_transfer(&mut self, account_id: AccountId, token_id: TokenId) {
//let account = ValidAccountId::try_from(account_id.clone()).unwrap();
self.nft.internal_transfer_unguarded(&token_id, &self.owner_id, &account_id);
}
#[private]
pub fn nft_transfer_callback(&mut self) -> bool {
match env::promise_result(0) {
PromiseResult::NotReady => unreachable!(),
PromiseResult::Successful(_) => true,
PromiseResult::Failed => env::panic(b"ERR_CALL_FAILED"),
}
}
}
#[cfg(test)]
mod tests {
#[test]
fn test_nft_batch_transfer() {
assert_eq!(2 + 2, 4);
}
}
|
#[derive(Clone, Debug)]
struct Body {
position: [f64; 3],
velocity: [f64; 3],
mass: f64,
}
/// Number of bodies modeled in the simulation
const BODIES_COUNT: usize = 5;
const SOLAR_MASS: f64 = 4. * std::f64::consts::PI * std::f64::consts::PI;
const DAYS_PER_YEAR: f64 = 365.24;
/// Number of body-body interactions
const INTERACTIONS: usize = BODIES_COUNT * (BODIES_COUNT - 1) / 2;
/// Initial state of the simulation
const STARTING_STATE: [Body; BODIES_COUNT] = [
// Sun
Body {
mass: SOLAR_MASS,
position: [0.; 3],
velocity: [0.; 3],
},
// Jupiter
Body {
position: [
4.841_431_442_464_72e0,
-1.160_320_044_027_428_4e0,
-1.036_220_444_711_231_1e-1,
],
velocity: [
1.660_076_642_744_037e-3 * DAYS_PER_YEAR,
7.699_011_184_197_404e-3 * DAYS_PER_YEAR,
-6.904_600_169_720_63e-5 * DAYS_PER_YEAR,
],
mass: 9.547_919_384_243_266e-4 * SOLAR_MASS,
},
// Saturn
Body {
position: [
8.343_366_718_244_58e0,
4.124_798_564_124_305e0,
-4.035_234_171_143_214e-1,
],
velocity: [
-2.767_425_107_268_624e-3 * DAYS_PER_YEAR,
4.998_528_012_349_172e-3 * DAYS_PER_YEAR,
2.304_172_975_737_639_3e-5 * DAYS_PER_YEAR,
],
mass: 2.858_859_806_661_308e-4 * SOLAR_MASS,
},
// Uranus
Body {
position: [
1.289_436_956_213_913_1e1,
-1.511_115_140_169_863_1e1,
-2.233_075_788_926_557_3e-1,
],
velocity: [
2.964_601_375_647_616e-3 * DAYS_PER_YEAR,
2.378_471_739_594_809_5e-3 * DAYS_PER_YEAR,
-2.965_895_685_402_375_6e-5 * DAYS_PER_YEAR,
],
mass: 4.366_244_043_351_563e-5 * SOLAR_MASS,
},
// Neptune
Body {
position: [
1.537_969_711_485_091_1e1,
-2.591_931_460_998_796_4e1,
1.792_587_729_503_711_8e-1,
],
velocity: [
2.680_677_724_903_893_2e-3 * DAYS_PER_YEAR,
1.628_241_700_382_423e-3 * DAYS_PER_YEAR,
-9.515_922_545_197_159e-5 * DAYS_PER_YEAR,
],
mass: 5.151_389_020_466_114_5e-5 * SOLAR_MASS,
},
];
/// Adjust the Sun's velocity to offset system momentum
fn offset_momentum(bodies: &mut [Body; BODIES_COUNT]) {
let (sun, planets) = bodies.split_first_mut().unwrap();
sun.velocity = [0.; 3];
for planet in planets {
for m in 0..3 {
sun.velocity[m] -= planet.velocity[m] * planet.mass / SOLAR_MASS;
}
}
}
// Compute `x` squared conveniently
fn sqr(x: f64) -> f64 {
x * x
}
/// Print the system energy
fn output_energy(bodies: &mut [Body; BODIES_COUNT]) {
let mut energy = 0.;
for (i, body) in bodies.iter().enumerate() {
// Add the kinetic energy for each body
energy += 0.5
* body.mass
* (sqr(body.velocity[0]) + sqr(body.velocity[1]) + sqr(body.velocity[2]));
// Add potential energy between this body and every other
for body2 in &bodies[i + 1..BODIES_COUNT] {
energy -= body.mass * body2.mass
/ f64::sqrt(
sqr(body.position[0] - body2.position[0])
+ sqr(body.position[1] - body2.position[1])
+ sqr(body.position[2] - body2.position[2]),
);
}
}
println!("{:.9}", energy);
}
/// Steps the simulation forward by one time step
fn advance(bodies: &mut [Body; BODIES_COUNT]) {
// Compute vectors between each unique pair of bodies
let mut position_deltas = [[0.; 3]; INTERACTIONS];
{
let mut k = 0;
for i in 0..BODIES_COUNT - 1 {
for j in i + 1..BODIES_COUNT {
for (m, pd) in position_deltas[k].iter_mut().enumerate() {
*pd = bodies[i].position[m] - bodies[j].position[m];
}
k += 1;
}
}
}
// Compute the `1/d^3` magnitude between each pair of bodies
let magnitudes = {
let mut magnitudes = [0.; INTERACTIONS];
for (i, mag) in magnitudes.iter_mut().enumerate() {
let distance_squared = sqr(position_deltas[i][2])
+ sqr(position_deltas[i][1])
+ sqr(position_deltas[i][0]);
*mag = 0.01 / (distance_squared * distance_squared.sqrt());
}
magnitudes
};
// Apply every other body's gravitation to each body's velocity
{
let mut k = 0;
for i in 0..BODIES_COUNT-1 {
for j in i+1..BODIES_COUNT {
let i_mass_mag = bodies[i].mass * magnitudes[k];
let j_mass_mag = bodies[j].mass * magnitudes[k];
for (m, pd) in position_deltas[k].iter().enumerate() {
bodies[i].velocity[m] -= *pd * j_mass_mag;
bodies[j].velocity[m] += *pd * i_mass_mag;
}
k += 1;
}
}
}
// Update each body's position
for body in bodies {
for (m, pos) in body.position.iter_mut().enumerate() {
*pos += 0.01 * body.velocity[m];
}
}
}
fn main() {
let c = std::env::args().nth(1).unwrap().parse().unwrap();
let mut solar_bodies = STARTING_STATE;
offset_momentum(&mut solar_bodies);
output_energy(&mut solar_bodies);
for _ in 0..c {
advance(&mut solar_bodies)
}
output_energy(&mut solar_bodies);
}
|
///// chapter 3 "using functions and control structures"
///// program section:
//
fn main() {
for n in 1..11 {
println!("the square of {} is {}", n, n * n);
}
}
///// output should be:
/*
*/// end of output
|
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn new(x: f64, y: f64, radius: f64) -> Circle {
Circle {
x: x,
y: y,
radius: radius,
}
}
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
fn grow(&self, increment: f64) -> Circle {
Circle { x: self.x, y: self.y, radius: self.radius + increment }
}
}
struct CircleBuilder {
x: f64,
y: f64,
radius: f64,
}
impl CircleBuilder {
fn new() -> CircleBuilder {
CircleBuilder { x: 0.0, y: 0.0, radius: 1.0, }
}
fn x(&mut self, cordinate: f64) -> &mut CircleBuilder {
self.x = cordinate;
self
}
fn y(&mut self, cordinate: f64) -> &mut CircleBuilder {
self.y = cordinate;
self
}
fn radius(&mut self, cordinate: f64) -> &mut CircleBuilder {
self.radius = cordinate;
self
}
fn finalize(&self) -> Circle {
Circle {x: self.x, y: self.y, radius: self.radius}
}
}
fn main() {
let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
println!("{}",c.area());
println!("{}",c.grow(2.0).area());
println!("{}", Circle::new(1.0, 1.0, 2.0).area());
let d = CircleBuilder::new()
.x(1.0)
.y(2.0)
.radius(2.0)
.finalize();
println!("{}",d.area());
}
|
// This file is part of lock-free-multi-producer-single-consumer-ring-buffer. 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/lock-free-multi-producer-single-consumer-ring-buffer/master/COPYRIGHT. No part of lock-free-multi-producer-single-consumer-ring-buffer, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2017 - 2019 The developers of lock-free-multi-producer-single-consumer-ring-buffer. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/lock-free-multi-producer-single-consumer-ring-buffer/master/COPYRIGHT.
#[derive(Debug)]
struct VolatileRingBufferOffset(UnsafeCell<RingBufferOffset>);
impl VolatileRingBufferOffset
{
/// `x = self`.
#[inline(always)]
pub(crate) fn read(&self) -> RingBufferOffset
{
unsafe { (self.unsafe_cell_contents() as *const RingBufferOffset).read_volatile() }
}
/// `self = value`.
#[inline(always)]
pub(crate) fn write(&mut self, value: RingBufferOffset)
{
unsafe { self.unsafe_cell_contents().write_volatile(value) }
}
/// `self &= and_equals_value`.
#[inline(always)]
pub(crate) fn and_equals(&mut self, and_equals_value: RingBufferOffset)
{
let value = self.read() & and_equals_value;
self.write(value)
}
#[inline(always)]
pub(crate) fn atomic_compare_and_exchange_weak(&mut self, old: RingBufferOffset, source: RingBufferOffset) -> bool
{
let (_new, ok) = unsafe { atomic_cxchgweak(self.unsafe_cell_contents(), old, source) };
ok
}
#[inline(always)]
fn unsafe_cell_contents(&self) -> *mut RingBufferOffset
{
self.0.get()
}
}
|
mod Union_Find;
mod Modint;
fn main() {
println!("Hello, world!");
(0..n).map(|_| read()).collect()
}
|
use pyo3::prelude::*;
pub fn register_module(py: Python<'_>, parent_module: &PyModule) -> PyResult<()>
{
let single_chain = PyModule::new(py, "single_chain")?;
super::ideal::py::register_module(py, single_chain)?;
super::fjc::py::register_module(py, single_chain)?;
super::efjc::py::register_module(py, single_chain)?;
super::swfjc::py::register_module(py, single_chain)?;
super::ufjc::py::register_module(py, single_chain)?;
super::wlc::py::register_module(py, single_chain)?;
parent_module.add_submodule(single_chain)?;
Ok(())
}
|
use hyper::status::StatusCode;
use super::errors::*;
use super::msg;
pub trait IntoResult {
type Item;
fn into_result(self, StatusCode) -> Result<Self::Item>;
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AccessTokenResponse {
res_code: u64,
res_message: Option<String>,
state: String,
access_token: Option<String>,
expires_in: Option<u64>,
}
impl IntoResult for AccessTokenResponse {
type Item = msg::AccessToken;
fn into_result(self, http_status: StatusCode) -> Result<Self::Item> {
if self.res_code == 0 {
Ok(msg::AccessToken {
state: self.state,
token: self.access_token.unwrap(),
expires_in: self.expires_in.unwrap(),
})
} else {
Err(ErrorKind::ApiError(http_status,
self.res_code,
Some(self.state),
self.res_message)
.into())
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SmsTokenResponse {
res_code: u64,
res_message: Option<String>,
token: Option<String>,
}
impl IntoResult for SmsTokenResponse {
type Item = String;
fn into_result(self, http_status: StatusCode) -> Result<Self::Item> {
if self.res_code == 0 && self.token.is_some() {
Ok(self.token.unwrap())
} else {
Err(ErrorKind::ApiError(http_status, self.res_code, None, self.res_message).into())
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SmsCodeResponse {
res_code: u64,
res_message: Option<String>,
create_at: Option<u64>,
identifier: Option<String>,
}
impl IntoResult for SmsCodeResponse {
type Item = msg::SentSmsCode;
fn into_result(self, http_status: StatusCode) -> Result<Self::Item> {
if self.res_code == 0 && self.create_at.is_some() && self.identifier.is_some() {
Ok(msg::SentSmsCode {
send_time: self.create_at.unwrap(),
sms_id: self.identifier.unwrap(),
})
} else {
Err(ErrorKind::ApiError(http_status, self.res_code, None, self.res_message).into())
}
}
}
|
use std::collections::{HashMap, HashSet};
use crate::config::{Border, Borders, Position};
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub(crate) struct BordersConfig<T> {
global: Option<T>,
borders: Borders<T>,
cells: BordersMap<T>,
horizontals: HashMap<usize, HorizontalLine<T>>,
verticals: HashMap<usize, VerticalLine<T>>,
layout: BordersLayout,
}
impl<T: std::fmt::Debug> BordersConfig<T> {
pub(crate) fn insert_border(&mut self, pos: Position, border: Border<T>) {
if let Some(c) = border.top {
self.cells.horizontal.insert(pos, c);
self.layout.horizontals.insert(pos.0);
}
if let Some(c) = border.bottom {
self.cells.horizontal.insert((pos.0 + 1, pos.1), c);
self.layout.horizontals.insert(pos.0 + 1);
}
if let Some(c) = border.left {
self.cells.vertical.insert(pos, c);
self.layout.verticals.insert(pos.1);
}
if let Some(c) = border.right {
self.cells.vertical.insert((pos.0, pos.1 + 1), c);
self.layout.verticals.insert(pos.1 + 1);
}
if let Some(c) = border.left_top_corner {
self.cells.intersection.insert((pos.0, pos.1), c);
self.layout.horizontals.insert(pos.0);
self.layout.verticals.insert(pos.1);
}
if let Some(c) = border.right_top_corner {
self.cells.intersection.insert((pos.0, pos.1 + 1), c);
self.layout.horizontals.insert(pos.0);
self.layout.verticals.insert(pos.1 + 1);
}
if let Some(c) = border.left_bottom_corner {
self.cells.intersection.insert((pos.0 + 1, pos.1), c);
self.layout.horizontals.insert(pos.0 + 1);
self.layout.verticals.insert(pos.1);
}
if let Some(c) = border.right_bottom_corner {
self.cells.intersection.insert((pos.0 + 1, pos.1 + 1), c);
self.layout.horizontals.insert(pos.0 + 1);
self.layout.verticals.insert(pos.1 + 1);
}
}
pub(crate) fn remove_border(&mut self, pos: Position, shape: (usize, usize)) {
let (count_rows, count_cols) = shape;
self.cells.horizontal.remove(&pos);
self.cells.horizontal.remove(&(pos.0 + 1, pos.1));
self.cells.vertical.remove(&pos);
self.cells.vertical.remove(&(pos.0, pos.1 + 1));
self.cells.intersection.remove(&pos);
self.cells.intersection.remove(&(pos.0 + 1, pos.1));
self.cells.intersection.remove(&(pos.0, pos.1 + 1));
self.cells.intersection.remove(&(pos.0 + 1, pos.1 + 1));
// clean up the layout.
if !self.check_is_horizontal_set(pos.0, count_rows) {
self.layout.horizontals.remove(&pos.0);
}
if !self.check_is_horizontal_set(pos.0 + 1, count_rows) {
self.layout.horizontals.remove(&(pos.0 + 1));
}
if !self.check_is_vertical_set(pos.1, count_cols) {
self.layout.verticals.remove(&pos.1);
}
if !self.check_is_vertical_set(pos.1 + 1, count_cols) {
self.layout.verticals.remove(&(pos.1 + 1));
}
}
pub(crate) fn get_border(&self, pos: Position, shape: (usize, usize)) -> Border<&T> {
Border {
top: self.get_horizontal(pos, shape.0),
bottom: self.get_horizontal((pos.0 + 1, pos.1), shape.0),
left: self.get_vertical(pos, shape.1),
left_top_corner: self.get_intersection(pos, shape),
left_bottom_corner: self.get_intersection((pos.0 + 1, pos.1), shape),
right: self.get_vertical((pos.0, pos.1 + 1), shape.1),
right_top_corner: self.get_intersection((pos.0, pos.1 + 1), shape),
right_bottom_corner: self.get_intersection((pos.0 + 1, pos.1 + 1), shape),
}
}
pub(crate) fn insert_horizontal_line(&mut self, row: usize, line: HorizontalLine<T>) {
if line.left.is_some() {
self.layout.left = true;
}
// todo: when we delete lines these are still left set; so has_horizontal/vertical return true in some cases;
// it shall be fixed, but maybe we can improve the logic as it got a bit complicated.
if line.right.is_some() {
self.layout.right = true;
}
if line.intersection.is_some() {
self.layout.inner_verticals = true;
}
self.horizontals.insert(row, line);
self.layout.horizontals.insert(row);
}
pub(crate) fn get_horizontal_line(&self, row: usize) -> Option<&HorizontalLine<T>> {
self.horizontals.get(&row)
}
pub(crate) fn remove_horizontal_line(&mut self, row: usize, count_rows: usize) {
self.horizontals.remove(&row);
self.layout.horizontals.remove(&row);
if self.has_horizontal(row, count_rows) {
self.layout.horizontals.insert(row);
}
}
pub(crate) fn insert_vertical_line(&mut self, row: usize, line: VerticalLine<T>) {
if line.top.is_some() {
self.layout.top = true;
}
if line.bottom.is_some() {
self.layout.bottom = true;
}
self.verticals.insert(row, line);
self.layout.verticals.insert(row);
}
pub(crate) fn get_vertical_line(&self, row: usize) -> Option<&VerticalLine<T>> {
self.verticals.get(&row)
}
pub(crate) fn remove_vertical_line(&mut self, col: usize, count_columns: usize) {
self.verticals.remove(&col);
self.layout.verticals.remove(&col);
if self.has_vertical(col, count_columns) {
self.layout.verticals.insert(col);
}
}
pub(crate) fn set_borders(&mut self, borders: Borders<T>) {
self.borders = borders;
}
pub(crate) fn get_borders(&self) -> &Borders<T> {
&self.borders
}
pub(crate) fn get_global(&self) -> Option<&T> {
self.global.as_ref()
}
pub(crate) fn set_global(&mut self, value: T) {
self.global = Some(value);
}
pub(crate) fn get_vertical(&self, pos: Position, count_cols: usize) -> Option<&T> {
self.cells
.vertical
.get(&pos)
.or_else(|| self.verticals.get(&pos.1).and_then(|l| l.main.as_ref()))
.or({
if pos.1 == count_cols {
self.borders.right.as_ref()
} else if pos.1 == 0 {
self.borders.left.as_ref()
} else {
self.borders.vertical.as_ref()
}
})
.or(self.global.as_ref())
}
pub(crate) fn get_horizontal(&self, pos: Position, count_rows: usize) -> Option<&T> {
self.cells
.horizontal
.get(&pos)
.or_else(|| self.horizontals.get(&pos.0).and_then(|l| l.main.as_ref()))
.or({
if pos.0 == 0 {
self.borders.top.as_ref()
} else if pos.0 == count_rows {
self.borders.bottom.as_ref()
} else {
self.borders.horizontal.as_ref()
}
})
.or(self.global.as_ref())
}
pub(crate) fn get_intersection(
&self,
pos: Position,
(count_rows, count_cols): (usize, usize),
) -> Option<&T> {
let use_top = pos.0 == 0;
let use_bottom = pos.0 == count_rows;
let use_left = pos.1 == 0;
let use_right = pos.1 == count_cols;
if let Some(c) = self.cells.intersection.get(&pos) {
return Some(c);
}
let hl_c = self.horizontals.get(&pos.0).and_then(|l| {
if use_left && l.left.is_some() {
l.left.as_ref()
} else if use_right && l.right.is_some() {
l.right.as_ref()
} else if !use_right && !use_left && l.intersection.is_some() {
l.intersection.as_ref()
} else {
None
}
});
if let Some(c) = hl_c {
return Some(c);
}
let vl_c = self.verticals.get(&pos.1).and_then(|l| {
if use_top && l.top.is_some() {
l.top.as_ref()
} else if use_bottom && l.bottom.is_some() {
l.bottom.as_ref()
} else if !use_top && !use_bottom && l.intersection.is_some() {
l.intersection.as_ref()
} else {
None
}
});
if let Some(c) = vl_c {
return Some(c);
}
let borders_c = {
if use_top && use_left {
self.borders.top_left.as_ref()
} else if use_top && use_right {
self.borders.top_right.as_ref()
} else if use_bottom && use_left {
self.borders.bottom_left.as_ref()
} else if use_bottom && use_right {
self.borders.bottom_right.as_ref()
} else if use_top {
self.borders.top_intersection.as_ref()
} else if use_bottom {
self.borders.bottom_intersection.as_ref()
} else if use_left {
self.borders.left_intersection.as_ref()
} else if use_right {
self.borders.right_intersection.as_ref()
} else {
self.borders.intersection.as_ref()
}
};
if let Some(c) = borders_c {
return Some(c);
}
self.global.as_ref()
}
pub(crate) fn has_horizontal(&self, row: usize, count_rows: usize) -> bool {
self.global.is_some()
|| (row == 0 && self.borders.has_top())
|| (row == count_rows && self.borders.has_bottom())
|| (row > 0 && row < count_rows && self.borders.has_horizontal())
|| self.is_horizontal_set(row, count_rows)
}
pub(crate) fn has_vertical(&self, col: usize, count_cols: usize) -> bool {
self.global.is_some()
|| (col == 0 && self.borders.has_left())
|| (col == count_cols && self.borders.has_right())
|| (col > 0 && col < count_cols && self.borders.has_vertical())
|| self.is_vertical_set(col, count_cols)
}
fn is_horizontal_set(&self, row: usize, count_rows: usize) -> bool {
(row == 0 && self.layout.top)
|| (row == count_rows && self.layout.bottom)
|| (row > 0 && row < count_rows && self.layout.inner_horizontals)
|| self.layout.horizontals.contains(&row)
}
fn is_vertical_set(&self, col: usize, count_cols: usize) -> bool {
(col == 0 && self.layout.left)
|| (col == count_cols && self.layout.right)
|| (col > 0 && col < count_cols && self.layout.inner_verticals)
|| self.layout.verticals.contains(&col)
}
fn check_is_horizontal_set(&self, row: usize, count_rows: usize) -> bool {
(row == 0 && self.layout.top)
|| (row == count_rows && self.layout.bottom)
|| (row > 0 && row < count_rows && self.layout.inner_horizontals)
|| self.cells.horizontal.keys().any(|&p| p.0 == row)
|| self.cells.intersection.keys().any(|&p| p.0 == row)
}
fn check_is_vertical_set(&self, col: usize, count_cols: usize) -> bool {
(col == 0 && self.layout.left)
|| (col == count_cols && self.layout.right)
|| (col > 0 && col < count_cols && self.layout.inner_verticals)
|| self.cells.vertical.keys().any(|&p| p.1 == col)
|| self.cells.intersection.keys().any(|&p| p.1 == col)
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct BordersMap<T> {
vertical: HashMap<Position, T>,
horizontal: HashMap<Position, T>,
intersection: HashMap<Position, T>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct BordersLayout {
left: bool,
right: bool,
top: bool,
bottom: bool,
inner_verticals: bool,
inner_horizontals: bool,
horizontals: HashSet<usize>,
verticals: HashSet<usize>,
}
/// A structure for a custom horizontal line.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
pub struct HorizontalLine<T> {
/// Line character.
pub main: Option<T>,
/// Line intersection character.
pub intersection: Option<T>,
/// Left intersection character.
pub left: Option<T>,
/// Right intersection character.
pub right: Option<T>,
}
impl<T> HorizontalLine<T> {
/// Verifies if the line has any setting set.
pub const fn is_empty(&self) -> bool {
self.main.is_none()
&& self.intersection.is_none()
&& self.left.is_none()
&& self.right.is_none()
}
}
/// A structure for a vertical line.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
pub struct VerticalLine<T> {
/// Line character.
pub main: Option<T>,
/// Line intersection character.
pub intersection: Option<T>,
/// Left intersection character.
pub top: Option<T>,
/// Right intersection character.
pub bottom: Option<T>,
}
impl<T> VerticalLine<T> {
/// Verifies if the line has any setting set.
pub const fn is_empty(&self) -> bool {
self.main.is_none()
&& self.intersection.is_none()
&& self.top.is_none()
&& self.bottom.is_none()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_insert_border() {
let mut borders = BordersConfig::<char>::default();
borders.insert_border((0, 0), Border::filled('x'));
assert_eq!(borders.get_border((0, 0), (10, 10)), Border::filled(&'x'));
assert_eq!(borders.get_border((0, 0), (0, 0)), Border::filled(&'x'));
assert!(borders.is_horizontal_set(0, 10));
assert!(borders.is_horizontal_set(1, 10));
assert!(!borders.is_horizontal_set(2, 10));
assert!(borders.is_vertical_set(0, 10));
assert!(borders.is_vertical_set(1, 10));
assert!(!borders.is_vertical_set(2, 10));
assert!(borders.is_horizontal_set(0, 0));
assert!(borders.is_horizontal_set(1, 0));
assert!(!borders.is_horizontal_set(2, 0));
assert!(borders.is_vertical_set(0, 0));
assert!(borders.is_vertical_set(1, 0));
assert!(!borders.is_vertical_set(2, 0));
}
#[test]
fn test_insert_border_override() {
let mut borders = BordersConfig::<char>::default();
borders.insert_border((0, 0), Border::filled('x'));
borders.insert_border((1, 0), Border::filled('y'));
borders.insert_border((0, 1), Border::filled('w'));
borders.insert_border((1, 1), Border::filled('q'));
assert_eq!(
borders.get_border((0, 0), (10, 10)).copied(),
Border::full('x', 'y', 'x', 'w', 'x', 'w', 'y', 'q')
);
assert_eq!(
borders.get_border((0, 1), (10, 10)).copied(),
Border::full('w', 'q', 'w', 'w', 'w', 'w', 'q', 'q')
);
assert_eq!(
borders.get_border((1, 0), (10, 10)).copied(),
Border::full('y', 'y', 'y', 'q', 'y', 'q', 'y', 'q')
);
assert_eq!(
borders.get_border((1, 1), (10, 10)).copied(),
Border::filled('q')
);
assert!(borders.is_horizontal_set(0, 10));
assert!(borders.is_horizontal_set(1, 10));
assert!(borders.is_horizontal_set(2, 10));
assert!(!borders.is_horizontal_set(3, 10));
assert!(borders.is_vertical_set(0, 10));
assert!(borders.is_vertical_set(1, 10));
assert!(borders.is_vertical_set(2, 10));
assert!(!borders.is_vertical_set(3, 10));
}
#[test]
fn test_set_global() {
let mut borders = BordersConfig::<char>::default();
borders.insert_border((0, 0), Border::filled('x'));
borders.set_global('l');
assert_eq!(borders.get_border((0, 0), (10, 10)), Border::filled(&'x'));
assert_eq!(borders.get_border((2, 0), (10, 10)), Border::filled(&'l'));
assert!(borders.is_horizontal_set(0, 10));
assert!(borders.is_horizontal_set(1, 10));
assert!(!borders.is_horizontal_set(2, 10));
assert!(borders.is_vertical_set(0, 10));
assert!(borders.is_vertical_set(1, 10));
assert!(!borders.is_vertical_set(2, 10));
assert!(borders.is_horizontal_set(0, 0));
assert!(borders.is_horizontal_set(1, 0));
assert!(!borders.is_horizontal_set(2, 0));
assert!(borders.is_vertical_set(0, 0));
assert!(borders.is_vertical_set(1, 0));
assert!(!borders.is_vertical_set(2, 0));
}
}
|
use std::fs::File;
use std::io::{BufReader,BufRead};
use std::collections::{HashMap,HashSet};
use std::iter::FromIterator;
fn is_unique(line: &String) -> bool {
let mut word_map = HashMap::new();
for word in line.split_whitespace() {
let count = word_map.entry(word.to_string()).or_insert(0);
*count += 1;
}
word_map.values().filter(|&count| *count > 1).count() == 0
}
fn is_not_anagram(line: &String) -> bool {
let mut encountered = HashSet::new();
for word in line.split_whitespace() {
let mut chars: Vec<_> = word.chars().collect();
chars.sort();
let sorted_word = String::from_iter(chars);
if encountered.contains(&sorted_word) {
return false;
} else {
encountered.insert(sorted_word.to_string());
}
}
true
}
fn part_one() {
let file = File::open("input.txt").unwrap();
let non_duplicates = BufReader::new(&file)
.lines()
.filter_map(Result::ok)
.filter(is_unique)
.count();
assert_eq!(337, non_duplicates);
}
fn part_two() {
let file = File::open("input.txt").unwrap();
let non_anagrams = BufReader::new(&file)
.lines()
.filter_map(Result::ok)
.filter(is_not_anagram)
.count();
assert_eq!(231, non_anagrams);
}
fn main() {
part_one();
part_two();
}
|
struct Solution;
/// https://leetcode.com/problems/power-of-two/
impl Solution {
pub fn is_power_of_two(n: i32) -> bool {
Solution::iterative(n)
}
/// 0 ms 2 MB
fn bit(n: i32) -> bool {
// should use <= because (n & (i32::min_value() - 1)) = true
if n <= 0 {
return false;
}
(n & (n - 1)) == 0
}
/// 0 ms 2 MB
fn iterative(n: i32) -> bool {
if n <= 0 || n % 2 == 1 {
return false;
}
if n == 1 {
return true;
}
let mut n = n;
while n != 2 {
if n & 1 == 1 {
return false;
}
n >>= 1;
}
true
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test() {
assert_eq!(Solution::is_power_of_two(1), true);
assert_eq!(Solution::is_power_of_two(16), true);
assert_eq!(Solution::is_power_of_two(3), false);
assert_eq!(Solution::is_power_of_two(5), false);
assert_eq!(Solution::is_power_of_two(-1), false);
assert_eq!(Solution::is_power_of_two(-2), false);
}
}
|
#![allow(non_snake_case)]
#![allow(improper_ctypes)]
#![allow(unused_imports)]
use super::types::*;
use super::wnd::*;
use libc::{c_int, c_uint, c_void};
#[link(name = "user32")]
#[link(name = "comctl32")]
#[link(name = "gdi32")]
/*
Type | S/U | x86 | x64
----------------------------+-----+--------+-------
BYTE, BOOLEAN | U | 8 bit | 8 bit
----------------------------+-----+--------+-------
SHORT | S | 16 bit | 16 bit
USHORT, WORD | U | 16 bit | 16 bit
----------------------------+-----+--------+-------
INT, LONG | S | 32 bit | 32 bit
UINT, ULONG, DWORD | U | 32 bit | 32 bit
----------------------------+-----+--------+-------
INT_PTR, LONG_PTR, LPARAM | S | 32 bit | 64 bit
UINT_PTR, ULONG_PTR, WPARAM | U | 32 bit | 64 bit
----------------------------+-----+--------+-------
LONGLONG | S | 64 bit | 64 bit
ULONGLONG, QWORD | U | 64 bit | 64 bit
*/
extern "stdcall"{
pub fn GetModuleHandleW(n:* const u16) ->HINSTANCE;
//pub fn RegisterClassExA(cls:* const WNDCLASSEX)->c_int;
pub fn RegisterClassExW(cls:* const WNDCLASSEXW)->int;
pub fn CreateWindowExW(exStyle:u32, name:* const u16, title: * const u16, style: u32 , x: int, y:int,w:int,h:int,parent:DWnd, hMenu:HMENU,hInstance:HINSTANCE,lParam:LPARAM) ->DWnd;
pub fn DefWindowProcW(hWnd:DWnd, msg:u32, wparam:WPARAM, lparam:LPARAM)->c_int;
pub fn ShowWindow(hWnd: DWnd, mode:c_int)->c_int;
pub fn GetLastError()->u32;
pub fn CallWindowProcW(wndProc:WndProc, hWnd:DWnd, msg:u32, wparam:WPARAM, lparam:LPARAM)->c_int;
pub fn InitCommonControlsEx(icex:* const INITCOMMONCONTROLSEX);
pub fn GetClassLongA(hWnd: DWnd, nindex:int)->int;
pub fn GetCurrentThreadId()->c_int;
// Window Hook
pub fn SetWindowsHookExA(hookID: int, hookfn: WindowHookfn,hmod:c_int, threadId:c_int)->int;
pub fn CallNextHookEx(hookID: int, code:int,wparam:* const c_void, lparam:* const c_void)->int;
pub fn UnhookWindowsHookEx(hookID: int)->int;
// WindowLong-- Only 32 bit
#[cfg(target_word_size = "32")]
pub fn GetWindowLongW(hwnd:DWnd, index: i32) -> * const c_void;
#[cfg(target_word_size = "32")]
pub fn SetWindowLongW(hwnd:DWnd, index: i32, value: * const c_void)->* const c_void;
#[cfg(target_word_size = "64")]
pub fn GetWindowLongPtrW(hwnd:DWnd, index: i32) -> * const c_void;
#[cfg(target_word_size = "64")]
pub fn SetWindowLongPtrW(hwnd:DWnd, index: i32, value: * const c_void) -> * const c_void;
//
pub fn GetActiveWindow()->DWnd;
pub fn MessageBoxW(parent:DWnd,string:* const u16,title:* const u16, flags: u32)->int;
//GDI
pub fn GetStockObject(index:c_int)->c_int;
}
|
use crate::bucket::Bucket;
use std::iter::Iterator;
use std::slice;
/// An iterator over the pairs stored in a BiMap.
pub struct Iter<'a, L, R, B>
where
L: 'a,
R: 'a,
B: 'a,
{
left_data: slice::Iter<'a, Bucket<L, usize, B>>,
right_data: &'a [Bucket<R, usize, B>],
}
impl<'a, L, R, B> Iter<'a, L, R, B> {
pub fn new(
left_data: slice::Iter<'a, Bucket<L, usize, B>>,
right_data: &'a [Bucket<R, usize, B>],
) -> Self {
Iter {
left_data,
right_data,
}
}
}
impl<'a, L, R, B> Iterator for Iter<'a, L, R, B>
where
L: 'a,
R: 'a,
{
type Item = (&'a L, &'a R);
fn next(&mut self) -> Option<Self::Item> {
let &mut Iter {
ref mut left_data,
right_data,
} = self;
left_data
.filter_map(|bucket| bucket.data.as_ref())
.map(|&(ref key, value, _)| (key, &right_data[value].data.as_ref().unwrap().0))
.next()
}
}
/// An owning iterator over the pairs stored in a BiMap.
pub struct IntoIter<L, R, B> {
left_data: Box<[Bucket<L, usize, B>]>,
right_data: Box<[Bucket<R, usize, B>]>,
index: usize,
}
impl<L, R, B> IntoIter<L, R, B> {
pub(crate) fn new(
left_data: Box<[Bucket<L, usize, B>]>,
right_data: Box<[Bucket<R, usize, B>]>,
) -> Self {
IntoIter {
left_data,
right_data,
index: 0,
}
}
}
impl<L, R, B> Iterator for IntoIter<L, R, B> {
type Item = (L, R);
fn next(&mut self) -> Option<Self::Item> {
let &mut IntoIter {
ref mut left_data,
ref mut right_data,
ref mut index,
} = self;
loop {
if *index >= left_data.len() {
break None;
}
if left_data[*index].data.is_some() {
let (left, right_index, ..) = left_data[*index].data.take().unwrap();
let (right, ..) = right_data[right_index].data.take().unwrap();
*index += 1;
break Some((left, right));
}
*index += 1;
}
}
}
|
pub use self::rc_slice::RcSlice;
use std::io::{self, BufRead, Write};
pub fn prompt<P: ?Sized + AsRef<str>>(prompt: &P) -> Option<String> {
let printed = write!(io::stdout(), "{}", prompt.as_ref());
let flushed = io::stdout().flush();
let mut buffer = String::new();
let read = io::stdin().read_line(&mut buffer);
match (printed, flushed, read) {
(Ok(_), Ok(_), Ok(0)) => None,
(Ok(_), Ok(_), Ok(_)) => Some(buffer),
_ => None,
}
}
pub mod rc_slice {
#![allow(unused)]
use std::rc::Rc;
use {Value, rc_to_usize};
#[derive(Clone)]
pub struct RcSlice {
data: Rc<Vec<Value>>,
start: usize,
len: usize,
}
impl RcSlice {
pub fn empty() -> RcSlice {
RcSlice::new(vec![])
}
pub fn new(v: Vec<Value>) -> RcSlice {
let len = v.len();
RcSlice {
data: Rc::new(v),
start: 0,
len: len,
}
}
pub fn tail(&self) -> RcSlice {
self.slice(1, self.len)
}
pub fn init(&self) -> RcSlice {
self.slice(0, self.len - 1)
}
pub fn len(&self) -> usize {
self.len
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
pub fn slice(&self, from: usize, to: usize) -> RcSlice {
// TODO: make this checked subtractions
let len = to - from;
RcSlice {
data: self.data.clone(),
start: from,
len: len,
}
}
pub fn get_slice(&self) -> &[Value] {
&self.data[self.start..self.start + self.len]
}
pub fn add(&self, v: Value) -> RcSlice {
let mut data: Vec<_> = (*self.data).clone();
data.push(v);
RcSlice::new(data)
}
pub fn add_all<I>(&self, i: I) -> RcSlice
where I: Iterator<Item = Value>
{
let mut data: Vec<_> = (*self.data).clone();
data.extend(i);
RcSlice::new(data)
}
}
impl PartialEq for RcSlice {
fn eq(&self, other: &RcSlice) -> bool {
// lengths *have* to be equal
self.len == other.len &&
((rc_to_usize(&self.data) == rc_to_usize(&self.data) && self.start == other.start) ||
self.get_slice() == other.get_slice())
}
}
impl Eq for RcSlice {}
impl ::std::hash::Hash for RcSlice {
fn hash<H>(&self, state: &mut H)
where H: ::std::hash::Hasher
{
self.get_slice().hash(state)
}
}
}
|
use collector::Collector;
use DocId;
use Result;
use Score;
use SegmentLocalId;
use SegmentReader;
/// Collector that does nothing.
/// This is used in the chain Collector and will hopefully
/// be optimized away by the compiler.
pub struct DoNothingCollector;
impl Collector for DoNothingCollector {
#[inline]
fn set_segment(&mut self, _: SegmentLocalId, _: &SegmentReader) -> Result<()> {
Ok(())
}
#[inline]
fn collect(&mut self, _doc: DocId, _score: Score) {}
#[inline]
fn requires_scoring(&self) -> bool {
false
}
}
/// Zero-cost abstraction used to collect on multiple collectors.
/// This contraption is only usable if the type of your collectors
/// are known at compile time.
///
/// ```rust
/// #[macro_use]
/// extern crate tantivy;
/// use tantivy::schema::{SchemaBuilder, TEXT};
/// use tantivy::{Index, Result};
/// use tantivy::collector::{CountCollector, TopCollector, chain};
/// use tantivy::query::QueryParser;
///
/// # fn main() { example().unwrap(); }
/// fn example() -> Result<()> {
/// let mut schema_builder = SchemaBuilder::new();
/// let title = schema_builder.add_text_field("title", TEXT);
/// let schema = schema_builder.build();
/// let index = Index::create_in_ram(schema);
/// {
/// let mut index_writer = index.writer(3_000_000)?;
/// index_writer.add_document(doc!(
/// title => "The Name of the Wind",
/// ));
/// index_writer.add_document(doc!(
/// title => "The Diary of Muadib",
/// ));
/// index_writer.add_document(doc!(
/// title => "A Dairy Cow",
/// ));
/// index_writer.add_document(doc!(
/// title => "The Diary of a Young Girl",
/// ));
/// index_writer.commit().unwrap();
/// }
///
/// index.load_searchers()?;
/// let searcher = index.searcher();
///
/// {
/// let mut top_collector = TopCollector::with_limit(2);
/// let mut count_collector = CountCollector::default();
/// {
/// let mut collectors = chain().push(&mut top_collector).push(&mut count_collector);
/// let query_parser = QueryParser::for_index(&index, vec![title]);
/// let query = query_parser.parse_query("diary")?;
/// searcher.search(&*query, &mut collectors).unwrap();
/// }
/// assert_eq!(count_collector.count(), 2);
/// assert!(top_collector.at_capacity());
/// }
///
/// Ok(())
/// }
/// ```
pub struct ChainedCollector<Left: Collector, Right: Collector> {
left: Left,
right: Right,
}
impl<Left: Collector, Right: Collector> ChainedCollector<Left, Right> {
/// Adds a collector
pub fn push<C: Collector>(self, new_collector: &mut C) -> ChainedCollector<Self, &mut C> {
ChainedCollector {
left: self,
right: new_collector,
}
}
}
impl<Left: Collector, Right: Collector> Collector for ChainedCollector<Left, Right> {
fn set_segment(
&mut self,
segment_local_id: SegmentLocalId,
segment: &SegmentReader,
) -> Result<()> {
self.left.set_segment(segment_local_id, segment)?;
self.right.set_segment(segment_local_id, segment)?;
Ok(())
}
fn collect(&mut self, doc: DocId, score: Score) {
self.left.collect(doc, score);
self.right.collect(doc, score);
}
fn requires_scoring(&self) -> bool {
self.left.requires_scoring() || self.right.requires_scoring()
}
}
/// Creates a `ChainedCollector`
pub fn chain() -> ChainedCollector<DoNothingCollector, DoNothingCollector> {
ChainedCollector {
left: DoNothingCollector,
right: DoNothingCollector,
}
}
#[cfg(test)]
mod tests {
use super::*;
use collector::{Collector, CountCollector, TopCollector};
#[test]
fn test_chained_collector() {
let mut top_collector = TopCollector::with_limit(2);
let mut count_collector = CountCollector::default();
{
let mut collectors = chain().push(&mut top_collector).push(&mut count_collector);
collectors.collect(1, 0.2);
collectors.collect(2, 0.1);
collectors.collect(3, 0.5);
}
assert_eq!(count_collector.count(), 3);
assert!(top_collector.at_capacity());
}
}
|
use std::cell::RefCell;
use std::rc::Rc;
use skulpin::skia_safe::*;
use skulpin::CoordinateSystemHelper;
// colors
pub fn hex_color4f(hex: u32) -> Color4f {
let r = ((hex >> 24) & 0xFF) as f32 / 255.0;
let g = ((hex >> 16) & 0xFF) as f32 / 255.0;
let b = ((hex >> 8) & 0xFF) as f32 / 255.0;
let a = (hex & 0xFF) as f32 / 255.0;
Color4f::new(r, g, b, a)
}
// conversions
pub fn get_window_size(coordinate_system_helper: &CoordinateSystemHelper) -> (f32, f32) {
let logical_size = coordinate_system_helper.window_logical_size();
(logical_size.width as _, logical_size.height as _)
}
// resources
pub type RcFont = Rc<RefCell<Font>>;
pub fn new_rc_font(data: &[u8], default_size: f32) -> RcFont {
let typeface = Typeface::from_data(Data::new_copy(data), None).expect("failed to load font");
Rc::new(RefCell::new(Font::new(typeface, default_size)))
}
// math
pub fn quantize(value: f32, step: f32) -> f32 {
step * (value / step + 0.5).floor()
}
pub fn lerp(v0: f32, v1: f32, t: f32) -> f32 {
(1.0 - t) * v0 + t * v1
}
pub fn lerp_point(p0: impl Into<Point>, p1: impl Into<Point>, t: f32) -> Point {
let p0 = p0.into();
let p1 = p1.into();
Point::new(lerp(p0.x, p1.x, t), lerp(p0.y, p1.y, t))
}
|
// Generated by `scripts/generate.js`
pub type VkGeometryFlags = super::super::khr::VkGeometryFlags;
#[doc(hidden)]
pub type RawVkGeometryFlags = super::super::khr::RawVkGeometryFlags; |
extern crate disrusm;
use disrusm::*;
use std::time::Instant;
fn main() {
/*
use std::fs::File;
use std::io::prelude::Read;
let mut f: File = File::open("mqljdr.sect").unwrap();
let mut bytes: Vec<u8> = vec![];
f.read_to_end(&mut bytes).unwrap();
do_it(&bytes);
*/
do_it(b"\xeb\x05\x43\x41\x42\xeb\x0b\xeb\x02\xeb\xf7\xb8\x07\x00\x00\x00\xeb\xf7\xc3");
do_it(b"\xeb\x05\x43\x41\x42\xeb\x12\xeb\x02\xeb\xf7\x2d\x78\x56\x34\x12\x75\x07\xb8\x07\x00\x00\x00\xeb\xf0\xc3");
do_it(b"\x90\xeb\x09\x90\x43\x90\x41\x90\x42\x90\xeb\x0f\x90\xeb\x03\x90\xeb\xf1\x90\xb8\x07\x00\x00\x00\x90\xeb\xf4\x90\xc3");
do_it(b"\x90\xeb\x09\x90\x43\x90\x41\x90\x42\x90\xeb\x16\x90\xeb\x03\x90\xeb\xf1\x90\x2d\x78\x56\x34\x12\x75\x08\xb8\x07\x00\x00\x00\x90\xeb\xed\x90\xc3");
do_it(b"\x66\x87\xf9\x5b\x81\xec\xc0\x00\x00\x00\xeb\x00\x01\xc7\x21\xcf\x89\xe7\xeb\x00\x89\xf3\x20\xf1\xf9\x03\x75\x00\xeb\x00\x10\xf8\x8a\x46\xff\x66\x41\x28\xd8\x41\x34\xd8\xeb\x00\xb5\x26\x4e\x49\x28\xc3\x80\xf5\x67\xc3");
do_it(b"\xeb\x00\xeb\x00\xeb\x00\xeb\x00\xc3");
}
fn do_it(bytes: &[u8]) {
let start = Instant::now();
let base = 0x40_1000; //0xD079000; // 0x40_1000;
let mut ip = 0x40_1000; //0xD11ABC4;
let mut blocks: Vec<Vec<Mnem>> = vec![];
let mut block: Vec<Mnem> = vec![];
let mut mnems: Vec<Mnem> = Vec::with_capacity(0x80);
let mut xrefs: Vec<(u32, u32)> = Vec::with_capacity(0x80);
loop {
let r = ip - base;
let len = bytes[r as usize..].len();
let x86bytes = &bytes[r as usize..r as usize + if len < 15 { len } else { 15 }];
if x86bytes.is_empty() {
break;
}
let mnem = x86(x86bytes, ip);
// // println!("{:X}\t\t\t{}", mnem.ip, mnem.to_str());
if mnem.instr == Instr::Add
&& mnem.op[0].val == OperandE::MemReg32Eax
&& mnem.op[1].val == OperandE::Reg8Al
{
break;
}
mnems.push(mnem);
if mnem.instr.is_cfg_delim() && mnem.instr != Instr::Ret && mnem.instr != Instr::Call {
let num = mnem.op[0].num;
// if num != 0 {
if mnem.instr == Instr::Call {
if num < 0x100 {
// println!(
// "add xref1 {:X} -> {:X}",
// ip,
// u32::from(num as u8) + mnem.ip + u32::from(mnem.len)
//);
xrefs.push((ip, u32::from(num as u8) + mnem.ip + u32::from(mnem.len)));
} else {
// println!(
// "add xref2 {:X} -> {:X}",
// ip,
// ((num as u32) as u32) + mnem.ip + u32::from(mnem.len)
//);
xrefs.push((ip, ((num as u32) as u32) + mnem.ip + u32::from(mnem.len)));
}
} else if mnem.instr == Instr::Jmp && mnem.get_flag(MnemFlags::IsStrangeFmt) {
// println!("add xref3 {:X} -> {:X}", ip, num);
xrefs.push((ip, num));
} else if num < 0x100 {
// println!(
// "add xref4 {:X} -> {:X}",
// ip,
// ((num as i8) as u32) + mnem.ip + u32::from(mnem.len)
//);
xrefs.push((ip, ((num as i8) as u32) + mnem.ip + u32::from(mnem.len)));
} else {
// println!("{}", "WTF!!!");
// println!(
// "add xref5 {:X} -> {:X}",
// ip,
// ((num as i32) as u32) + mnem.ip + u32::from(mnem.len)
//);
xrefs.push((ip, ((num as i32) as u32) + mnem.ip + u32::from(mnem.len)));
}
// }
if mnem.instr.is_jcc() {
// println!("add xref6 {:X} -> {:X}", ip, mnem.ip + u32::from(mnem.len));
xrefs.push((ip, mnem.ip + u32::from(mnem.len)));
}
}
ip += u32::from(mnem.len);
if mnem.instr == Instr::Jmp {
// ip = mnem.op[0].num + mnem.ip + u32::from(mnem.len);
} else {
// ip += u32::from(mnem.len);
}
// // println!("ip = {:X}, len = {:X}", ip, bytes.len());
if ip - base >= bytes.len() as u32 {
break;
}
if mnem.instr == Instr::Ret {
break;
}
}
let elapsed = start.elapsed();
let ms = (elapsed.as_secs() * 1_000) + u64::from(elapsed.subsec_millis());
println!("disasm only {:5} ms", ms);
let start = Instant::now();
let mut prev_is_delim = false;
let mut is_ended = true;
for mnem in &mnems {
is_ended = false;
let mut is_block: bool = false;
let mut need_loc = true;
let mut need_push = false;
let mut push_it = (0xFFFFFFFF, 0xFFFFFFFF);
for xref in &xrefs {
if xref.1 == mnem.ip as u32 && need_loc {
if !prev_is_delim {
if !block.is_empty() {
blocks.push(block.clone());
need_push = true;
let last_idx = block.len() - 1;
push_it = (
block[last_idx].ip,
block[last_idx].ip + u32::from(block[last_idx].len),
);
}
block.clear();
}
need_loc = false;
is_block = true;
}
}
if need_push {
// println!("add xref7 {:X} -> {:X}", push_it.0, push_it.1);
xrefs.push(push_it);
}
prev_is_delim = false;
block.push(*mnem);
if mnem.instr.is_cfg_delim() && mnem.instr != Instr::Call {
prev_is_delim = true;
if !block.is_empty() {
blocks.push(block.clone());
}
block.clear();
if !is_block || (mnem.instr == Instr::Jmp && mnem.get_flag(MnemFlags::IsStrangeFmt)) {}
if mnem.instr != Instr::Ret {
is_ended = true;
}
}
}
if !is_ended {
if !block.is_empty() {
blocks.push(block.clone());
}
block.clear();
}
let elapsed = start.elapsed();
let ms = (elapsed.as_secs() * 1_000) + u64::from(elapsed.subsec_millis());
println!("prepare blocks {:5} ms", ms);
// println!(
// "mnems: {}, xrefs: {}, basic blocks: {}",
// mnems.len(),
// xrefs.len(),
// blocks.len(),
//);
/*
// println!("\ndisasm:\n/");
let mut prev_is_delim = false;
let mut is_ended = true;
for mnem in &mnems {
is_ended = false;
let mut is_block: bool = false;
let mut need_loc = true;
let mut xrefs_num = 0;
for xref in &xrefs {
if xref.1 == mnem.ip as u32 {
if need_loc {
if prev_is_delim {
// print!("| \tloc_{:X}:", mnem.ip);
} else {
// print!("\\\n/\n| \tloc_{:X}:", mnem.ip);
blocks.push(block.clone());
block.clear();
}
// print!("\t\t\t\t; xref from:");
need_loc = false;
is_block = true;
}
let delim = if xrefs_num == 0 { "" } else { "," };
// print!("{} 0x{:X}", delim, xref.0);
xrefs_num += 1;
}
}
if xrefs_num > 0 {
// println!();
}
prev_is_delim = false;
// print!("| 0x{:02X} ", mnem.ip);
if mnem.to_str() == "Not Supported!" {
// print!(
"{:02X?} ",
mnem.bytes[..mnem.len as usize].to_vec()
)
}
// print!("{}", mnem.to_str());
let (op0, op1) = (mnem.op[0], mnem.op[1]);
let mut cmt = if op0.val == OperandE::MemOffReg32Ebp
|| op0.val == OperandE::MemReg32Ebp
|| (op0.val == OperandE::SIB
&& (op0.sib.val[0] == OperandE::Reg32Ebp || op0.sib.val[1] == OperandE::Reg32Ebp))
{
let num = op0.num;
if (num as i8) < 0 {
// print!("\t; var_{:X}", -(num as i8));
} else {
// print!("\t; arg_{:X}", num - 8);
}
true
} else {
false
};
if op1.val == OperandE::MemOffReg32Ebp
|| op1.val == OperandE::MemReg32Ebp
|| (op1.val == OperandE::SIB
&& (op1.sib.val[0] == OperandE::Reg32Ebp || op1.sib.val[1] == OperandE::Reg32Ebp))
{
let num = op1.num;
if cmt {
if (num as i8) < 0 {
// print!(", var_{:X}", -(num as i8));
} else {
// print!(", arg_{:X}", num - 8);
}
} else if (num as i8) < 0 {
// print!("\t; var_{:X}", -(num as i8));
} else {
// print!("\t; arg_{:X}", num - 8);
}
}
// println!();
block.push(*mnem);
if mnem.instr.is_cfg_delim() && mnem.instr != Instr::Call {
prev_is_delim = true;
blocks.push(block.clone());
block.clear();
if !is_block || (mnem.instr == Instr::Jmp && mnem.get_flag(MnemFlags::IsStrangeFmt)) {
// println!("\\");
}
// if mnem.instr != Instr::Ret {
// println!("/");
is_ended = true;
// }
}
}
if !is_ended {
blocks.push(block.clone());
block.clear();
// println!("\\");
}
*/
/*
for block in &blocks {
if !block.is_empty() {
// println!("/");
for mnem in block {
// println!("| {}", mnem.to_str());
}
// println!("\\");
} else {
// println!("Empty block. WTF???");
}
}
*/
let start = Instant::now();
let mut cfg_blocks: Vec<CfgBlock> = vec![];
for block in &blocks {
let mut cfg_block = CfgBlock::new();
let last_idx = block.len() - 1;
let (start, end) = (
block[0].ip,
block[last_idx].ip + u32::from(block[last_idx].len) - 1,
);
cfg_block.start_end = (start, end);
let num: u32 = block[last_idx].op[0].num;
if block[last_idx].instr.is_jcc() {
cfg_block.jmp_to = (
((num as i8) as u32) + block[last_idx].ip + u32::from(block[last_idx].len),
u32::from(block[last_idx].len) + block[last_idx].ip,
);
} else if block[last_idx].instr == Instr::Jmp {
if num < 0x100 {
cfg_block.jmp_to = (
block[last_idx].ip + ((num as i8) as u32) + u32::from(block[last_idx].len),
0,
);
} else {
cfg_block.jmp_to = (block[last_idx].ip + num + u32::from(block[last_idx].len), 0);
}
} else {
cfg_block.jmp_to = (block[last_idx].ip + u32::from(block[last_idx].len), 0);
}
for xref in &xrefs {
if cfg_block.is_ea_in_block(xref.0) {
// println!("add cfg xrefs_from -> {:X} -> {:X}", xref.0, xref.1);
cfg_block.xrefs_from.push((xref.0, xref.1));
}
if cfg_block.is_ea_in_block(xref.1) {
// println!("add cfg xrefs_to -> {:X} -> {:X}", xref.0, xref.1);
cfg_block.xrefs_to.push((xref.0, xref.1));
}
}
cfg_block.mnems = block.to_vec();
cfg_blocks.push(cfg_block);
}
// println!("all xrefs -> {:X?}", xrefs);
let len = cfg_blocks.len();
let cfg_blocks2 = cfg_blocks.clone();
for block in &mut cfg_blocks {
for idx in 0..len {
if cfg_blocks2[idx].is_ea_in_block(block.jmp_to.0) {
// println!("add jmp_to_block1 -> {} -> {:X}", idx, block.jmp_to.0);
block.jmp_to_block.0 = idx as u32;
}
if cfg_blocks2[idx].is_ea_in_block(block.jmp_to.1) {
// println!("add jmp_to_block2 -> {} -> {:X}", idx, block.jmp_to.1);
block.jmp_to_block.1 = idx as u32;
}
}
}
let elapsed = start.elapsed();
println!(
"setup cfg-blocks {:5} ms",
(elapsed.as_secs() * 1_000) + u64::from(elapsed.subsec_millis())
);
// build_graph(&cfg_blocks);
// println!("\nbefore simplify:");
let mnem2ir = Mnem2Ir::new();
for block in &cfg_blocks {
// println!("/");
for mnem in &block.mnems {
mnem2ir.convert(&mnem);
}
// println!("\\\n");
}
// println!(
// "xrefs_to -> {:X?}",
// cfg_blocks[cfg_blocks.len() - 1].xrefs_to
//);
let start = Instant::now();
let simplify = simplify_cfg(&mut cfg_blocks);
let elapsed = start.elapsed();
println!(
"\nsimplify {:5} ms or {:5.0} (ns/100)",
(elapsed.as_secs() * 1_000) + u64::from(elapsed.subsec_millis()),
elapsed.subsec_nanos() / 1_000,
);
println!("\nafter simplify:");
println!(
"removed jmp's: {}, nop's: {}, block's: {}",
simplify.0, simplify.1, simplify.2
);
let mnem2ir = Mnem2Ir::new();
for block in &cfg_blocks {
// println!("/");
for mnem in &block.mnems {
mnem2ir.convert(&mnem);
}
// println!("\\\n");
}
build_graph(&cfg_blocks);
}
fn build_graph(cfg_blocks: &Vec<CfgBlock>) {
println!("digraph fnc {{");
for (i, block) in cfg_blocks.iter().enumerate() {
let ea_0 = block.jmp_to_block.0;
let ea_1 = block.jmp_to_block.1;
let mut my_str = String::with_capacity(0x100);
let block2 = block.clone();
let len = block2.mnems.len();
for (idx, mnem) in block2.mnems.iter().enumerate() {
let tmp = format!("{:X}: {}", mnem.ip, mnem.to_str());
my_str.push_str(&tmp);
if len > 0 && idx < len - 1 {
my_str.push_str("\\n");
}
}
if ea_0 != 0xFFFFFFFF {
println!(
" \"{}\"[label=\"{} => {}\"]\n \"{}\" -> \"{}\"",
i, i, my_str, i, ea_0
);
}
if ea_1 != 0xFFFFFFFF {
println!(
" \"{}\"[label=\"{} => {}\"]\n \"{}\" -> \"{}\"",
i, i, my_str, i, ea_1
);
}
if ea_0 == 0xFFFFFFFF && ea_1 == 0xFFFFFFFF {
println!(" \"{}\"[label=\"{} => {}\"]\n \"{}\"", i, i, my_str, i);
}
}
println!("}}");
}
fn simplify_cfg(blocks: &mut Vec<CfgBlock>) -> (u32, u32, u32) {
let mut cou_removed_jmp = 0;
let mut cou_removed_nop = 0;
let mut cou_removed_clear_block = 0;
let mut cou1 = 0;
'simplify_jmp: loop {
// println!("simplify_cfg -> loop");
let blocks_copy = blocks.clone();
let blocks_len = blocks_copy.len();
while cou1 < blocks_len {
let jmp_idx = blocks_copy[cou1].jmp_to_block.0;
if jmp_idx != 0xFFFFFFFF {
// println!("simplify_cfg -> find jmp_idx -> {}", jmp_idx);
for cou2 in 0..blocks_len {
if cou2 as u32 == jmp_idx {
// println!("simplify_cfg -> found jmp_idx! -> {}", cou2);
let mut copy = blocks_copy[cou1].mnems.clone();
// println!(
// "cond is -> {:X?}, {}, {}",
// blocks_copy[cou2].xrefs_to,
// blocks_copy[cou2].xrefs_to.len(),
// blocks_copy[cou2].xrefs_to.len() < 2
//);
if blocks_copy[cou1].xrefs_from.len() != 1
|| blocks_copy[cou2].xrefs_to.len() > 1
{
// println!(
// "simplify_cfg -> condition is FAIL!((( -> {:X?} -> {:X?}\n",
// blocks_copy[cou1].xrefs_from, blocks_copy[cou2].xrefs_to,
//);
continue;
}
// println!("simplify_cfg -> condition is ok!");
if copy[copy.len() - 1].instr != Instr::Jmp {
// println!(
// "simplify not jmp -> {:?} -> {:X?}",
// copy[copy.len() - 1].instr,
// copy[copy.len() - 1].ip
//);
// cou1 = 0;
continue;
} else {
// println!(
// "simplify jmp -> {:?} -> {:X?}",
// copy[copy.len() - 1].instr,
// copy[copy.len() - 1].ip
//);
blocks[cou1] = blocks[cou2].clone();
copy.pop();
copy.extend_from_slice(&blocks[cou2].mnems);
blocks[cou1].mnems = copy;
blocks[cou2].clear();
let mut jmp_to: Vec<u32> = vec![];
for (idx, block2) in blocks_copy.iter().enumerate() {
if block2.jmp_to_block.0 == cou2 as u32
|| block2.jmp_to_block.1 == cou2 as u32
{
jmp_to.push(idx as u32);
}
}
for idx in &jmp_to {
if blocks[*idx as usize].jmp_to_block.0 == cou2 as u32 {
blocks[*idx as usize].jmp_to_block.0 = cou1 as u32;
}
if blocks[*idx as usize].jmp_to_block.1 == cou2 as u32 {
blocks[*idx as usize].jmp_to_block.1 = cou1 as u32;
}
// println!("to block {} jmp {}\n", cou2, idx);
}
cou_removed_jmp += 1;
}
cou1 -= 1;
continue 'simplify_jmp;
}
}
}
cou1 += 1;
// println!("loc1 cou1/blocks_len = {}/{}", cou1, blocks_len);
}
break;
}
let mut remove_arr: Vec<usize> = vec![];
'remove_nop: loop {
let mut need = false;
let mut block_idx = 0;
'search_for_nop: for (idx, block) in blocks.iter().enumerate() {
for i in 0..block.mnems.len() {
if block.mnems[i].instr == Instr::Nop {
need = true;
block_idx = idx;
remove_arr.push(i);
break 'search_for_nop;
}
if block.mnems[i].instr.is_jcc() {
need = true;
block_idx = idx;
remove_arr.push(i);
break 'search_for_nop;
}
// .mqljdr:0D11AE80 B8 AB+ add reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ sub reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ or reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ xor reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ rol reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ ror reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ shl reg1, 0
//
// .mqljdr:0D11AE80 B8 AB+ shr reg1, 0
if (block.mnems[i].instr == Instr::Add
|| block.mnems[i].instr == Instr::Sub
|| block.mnems[i].instr == Instr::Or
|| block.mnems[i].instr == Instr::Xor
|| block.mnems[i].instr == Instr::Rol
|| block.mnems[i].instr == Instr::Ror
|| block.mnems[i].instr == Instr::Shl
|| block.mnems[i].instr == Instr::Shr)
&& block.mnems[i].op[1].val.is_num()
&& block.mnems[i].op[1].num == 0
{
need = true;
block_idx = idx;
remove_arr.push(i);
break 'search_for_nop;
}
// .mqljdr:0D11AE89 F6 D9 neg reg1
// .mqljdr:0D11AE8B F6 D9 neg reg1
if block.mnems[i].instr == Instr::Neg
&& block.mnems[i + 1].instr == Instr::Neg
&& block.mnems[i].op[0].val == block.mnems[i + 1].op[0].val
{
need = true;
block_idx = idx;
remove_arr.push(i);
remove_arr.push(i + 1);
break 'search_for_nop;
}
// .mqljdr:0D11AE7F 50 push reg1
// .mqljdr:0D11AE80 B8 AB+ mov reg1, 57076CABh
// .mqljdr:0D11AE85 58 pop reg1
if block.mnems[i].instr == Instr::Push
&& block.mnems[i + 1].instr == Instr::Mov
&& block.mnems[i + 2].instr == Instr::Pop
&& block.mnems[i].op[0].val == block.mnems[i + 1].op[0].val
&& block.mnems[i + 1].op[0].val == block.mnems[i + 2].op[0].val
{
need = true;
block_idx = idx;
remove_arr.push(i);
remove_arr.push(i + 1);
remove_arr.push(i + 2);
break 'search_for_nop;
}
// .mqljdr:0D11AE21 8B DB mov reg1, reg1
//
// .mqljdr:0D11B0E9 87 ED xchg reg1, reg1
//
// .mqljdr:0D11B0E9 87 ED or reg1, reg1
//
// .mqljdr:0D11B0E9 87 ED and reg1, reg1
if (block.mnems[i].instr == Instr::Mov
|| block.mnems[i].instr == Instr::Xchg
|| block.mnems[i].instr == Instr::Or
|| block.mnems[i].instr == Instr::And)
&& block.mnems[i].op[0].val == block.mnems[i].op[1].val
{
need = true;
block_idx = idx;
remove_arr.push(i);
break 'search_for_nop;
}
// .mqljdr:0D11B1BF 86 C8 xchg reg1, reg2
// .mqljdr:0D11B1C1 86 C8 xchg reg1, reg2
//
// .mqljdr:0D11B1BF 86 C8 xchg reg1, reg2
// .mqljdr:0D11B1C1 86 C8 xchg reg2, reg1
if block.mnems[i].instr == Instr::Xchg
&& block.mnems[i + 1].instr == Instr::Xchg
&& ((block.mnems[i].op[0].val == block.mnems[i + 1].op[0].val
&& block.mnems[i].op[1].val == block.mnems[i + 1].op[1].val)
|| (block.mnems[i].op[0].val == block.mnems[i + 1].op[1].val
&& block.mnems[i].op[1].val == block.mnems[i + 1].op[0].val))
{
need = true;
block_idx = idx;
remove_arr.push(i);
remove_arr.push(i + 1);
break 'search_for_nop;
}
// .mqljdr:0D11B26A 4E dec reg1
// .mqljdr:0D11B26B 46 inc reg1
//
// .mqljdr:0D11B26B 46 inc reg1
// .mqljdr:0D11B26A 4E dec reg1
//
// .mqljdr:0D11B26B 46 push reg1
// .mqljdr:0D11B26A 4E pop reg1
if ((block.mnems[i].instr == Instr::Inc && block.mnems[i + 1].instr == Instr::Dec)
|| (block.mnems[i].instr == Instr::Dec
&& block.mnems[i + 1].instr == Instr::Inc)
|| (block.mnems[i].instr == Instr::Push
&& block.mnems[i + 1].instr == Instr::Pop))
&& block.mnems[i].op[0].val == block.mnems[i + 1].op[0].val
{
need = true;
block_idx = idx;
remove_arr.push(i);
remove_arr.push(i + 1);
break 'search_for_nop;
}
/*
.mqljdr:0D11B109 66 C1+ rol bp, 96
.mqljdr:0D11B0A8 C1 CC+ ror esp, 160
.mqljdr:0D11AD15 C1 E2+ shl edx, 64
.mqljdr:0D11AD43 C1 ED+ shr ebp, 32
.mqljdr:0D11B1F5 C1 F7+ sal edi, 192 // ???
*/
if (block.mnems[i].instr == Instr::Rol
|| block.mnems[i].instr == Instr::Ror
|| block.mnems[i].instr == Instr::Shl
|| block.mnems[i].instr == Instr::Shr)
&& block.mnems[i].op[1].is_num()
&& block.mnems[i].op[0].size() != 0
&& block.mnems[i].op[1].num % block.mnems[i].op[0].size() == 0
{
need = true;
block_idx = idx;
remove_arr.push(i);
break 'search_for_nop;
}
/*
.mqljdr:0D11B12A 25 FF+ and eax, 0FFFFFFFFh
.mqljdr:0D11ADFE 66 83+ and sp, 0FFFFh
*/
if block.mnems[i].instr == Instr::And
&& block.mnems[i].op[0].is_reg()
&& block.mnems[i].op[1].is_num()
&& ((block.mnems[i].op[0].size() == 8 && block.mnems[i].op[0].num == 0xFF)
|| (block.mnems[i].op[0].size() == 16
&& block.mnems[i].op[0].num == 0xFFFF)
|| (block.mnems[i].op[0].size() == 32
&& block.mnems[i].op[0].num == 0xFFFFFFFF))
{
need = true;
block_idx = idx;
remove_arr.push(i);
break 'search_for_nop;
}
// .mqljdr:0D11B2E8 52 push edx
// .mqljdr:0D11B2E9 6A 96 push 0FFFFFF96h
// .mqljdr:0D11B2EB 5A pop edx
// .mqljdr:0D11B2EC 5A pop edx
if block.mnems[i].instr == Instr::Push
&& block.mnems[i + 1].instr == Instr::Push
&& block.mnems[i + 2].instr == Instr::Pop
&& block.mnems[i + 2].instr == Instr::Pop
&& block.mnems[i].op[0].val == block.mnems[i + 2].op[0].val
&& block.mnems[i + 2].op[0].val == block.mnems[i + 3].op[0].val
{
need = true;
block_idx = idx;
remove_arr.push(i);
remove_arr.push(i + 1);
remove_arr.push(i + 2);
remove_arr.push(i + 3);
break 'search_for_nop;
}
/*
.mqljdr:0D11AE2A 70 03 jo short loc_D11AE2F
.mqljdr:0D11B2DE 52 push edx
.mqljdr:0D11B2DF 66 A9+ test ax, 4BBDh
.mqljdr:0D11B2E3 5A pop edx
.mqljdr:0D11B34C 73 08 jnb short loc_D11B356
.mqljdr:0D11B34E 74 06 jz short loc_D11B356
.mqljdr:0D11B69F 7A 07 jp short loc_D11B6A8
.mqljdr:0D11B6A1 7A 05 jp short loc_D11B6A8
.mqljdr:0D11B6A8 70 05 jo short loc_D11B6AF
.mqljdr:0D11B6AA 77 03 ja short loc_D11B6AF
.mqljdr:0D11B3BE 8D 1B lea ebx, [ebx]
.mqljdr:0D11B6FA 55 push ebp
.mqljdr:0D11B6FB 66 BD+ mov bp, 0E6F3h
.mqljdr:0D11B6FF 5D pop ebp
.mqljdr:0D11B812 77 05 ja short loc_D11B819
.mqljdr:0D11B814 7B 03 jnp short loc_D11B819
.mqljdr:0D11BD21 D9 D0 fnop
*/
//
}
}
if need {
let mut r_num = 0;
for i in &remove_arr {
// println!(
// "remove: {:X} -> {}",
// blocks[block_idx].mnems[*i - r_num].ip,
// blocks[block_idx].mnems[*i - r_num].to_str()
// );
blocks[block_idx].mnems.remove(*i - r_num);
r_num += 1;
}
cou_removed_nop += 1;
// println!("loc2 cou_removed_nop = {}", cou_removed_nop);
remove_arr.clear();
continue 'remove_nop;
} else {
break 'remove_nop;
}
}
cou_removed_jmp += simplify_cfg_jmp(blocks);
'remove_clear_blocks: loop {
let mut need = false;
let mut block_idx = 0;
'search_for_clear_block: for (idx, block) in blocks.iter().enumerate() {
if block.mnems.is_empty() {
need = true;
block_idx = idx;
break 'search_for_clear_block;
}
}
if need {
blocks.remove(block_idx);
for (idx, block) in blocks.clone().iter().enumerate() {
if block.jmp_to_block.0 >= block_idx as u32 && block.jmp_to_block.0 != 0xFFFFFFFF {
blocks[idx].jmp_to_block.0 -= 1;
}
if block.jmp_to_block.1 >= block_idx as u32 && block.jmp_to_block.1 != 0xFFFFFFFF {
blocks[idx].jmp_to_block.1 -= 1;
}
}
cou_removed_clear_block += 1;
// println!("loc3 cou_removed_clear_block = {}", cou_removed_clear_block);
continue 'remove_clear_blocks;
} else {
break 'remove_clear_blocks;
}
}
(cou_removed_jmp, cou_removed_nop, cou_removed_clear_block)
}
fn simplify_cfg_jmp(blocks: &mut Vec<CfgBlock>) -> u32 {
let mut cou_removed_jmp = 0;
let mut cou1 = 0;
'simplify_jmp: loop {
// println!("simplify_cfg -> loop");
let blocks_copy = blocks.clone();
let blocks_len = blocks_copy.len();
while cou1 < blocks_len {
let jmp_idx = blocks_copy[cou1].jmp_to_block.0;
if jmp_idx != 0xFFFFFFFF {
// println!("simplify_cfg -> find jmp_idx -> {}", jmp_idx);
for cou2 in 0..blocks_len {
if cou2 as u32 == jmp_idx {
// println!("simplify_cfg -> found jmp_idx! -> {}", cou2);
// println!(
// "cond is -> {:X?}, {}, {}",
// blocks_copy[cou2].xrefs_to,
// blocks_copy[cou2].xrefs_to.len(),
// blocks_copy[cou2].xrefs_to.len() < 2
//);
if blocks_copy[cou1].mnems.len() == 1
&& blocks_copy[cou1].mnems[0].instr == Instr::Jmp
&& blocks_copy[cou1].xrefs_to.len() == 1
&& blocks_copy[cou1].xrefs_from.len() == 1
{
// println!("simplify jmp only -> {}", cou1);
let jmp_to = blocks_copy[cou1].jmp_to_block;
for cou3 in 0..blocks_len {
if blocks[cou3].jmp_to_block.0 == cou1 as u32 {
// println!("cou1 = {}, cou2 = {}, cou3 = {}", cou1, cou2, cou3);
// println!("set {} to {}", cou3, jmp_to.0);
blocks[cou3].jmp_to_block.0 = jmp_to.0;
}
if blocks[cou3].jmp_to_block.1 == cou1 as u32 {
// println!("cou1 = {}, cou2 = {}, cou3 = {}", cou1, cou2, cou3);
// println!("set {} to {}", cou3, jmp_to.0);
blocks[cou3].jmp_to_block.1 = jmp_to.0;
}
}
blocks[cou1].clear();
cou_removed_jmp += 1;
continue;
}
cou1 += 1;
// println!("loc4 cou1 = {}/{}", cou1, blocks_len);
continue 'simplify_jmp;
}
}
}
cou1 += 1;
// println!("loc4 cou1 = {}/{}", cou1, blocks_len);
}
break;
}
cou_removed_jmp
}
/*
// println!(
"loop {} -> cou2 {} -> to {:X?} -> from {:X?}",
cou_removed_jmp,
cou2,
blocks_copy[cou2].xrefs_to,
blocks_copy[cou2].xrefs_from
);
let mnem2ir = Mnem2Ir::new();
// println!("after loop {}", cou_removed_jmp);
for block in blocks.clone() {
// println!("/");
for mnem in &block.mnems {
mnem2ir.convert(&mnem);
}
// println!("\\");
}
*/
#[derive(Clone, Debug)]
pub struct CfgBlock {
mnems: Vec<Mnem>,
start_end: (u32, u32),
jmp_to: (u32, u32),
jmp_to_block: (u32, u32),
xrefs_to: Vec<(u32, u32)>,
xrefs_from: Vec<(u32, u32)>,
}
impl CfgBlock {
pub fn new() -> CfgBlock {
CfgBlock {
mnems: vec![],
start_end: (0xFFFFFFFF, 0xFFFFFFFF),
jmp_to: (0xFFFFFFFF, 0xFFFFFFFF),
jmp_to_block: (0xFFFFFFFF, 0xFFFFFFFF),
xrefs_to: vec![],
xrefs_from: vec![],
}
}
pub fn is_ea_in_block(&self, ea: u32) -> bool {
// // println!(
// "is_ea_in_block -> {:X} -> {:X} && {:X} -> {}",
// ea,
// self.start_end.0,
// self.start_end.1,
// ea >= self.start_end.0 && ea <= self.start_end.1
// );
ea >= self.start_end.0 && ea <= self.start_end.1
}
pub fn clear(&mut self) {
self.mnems = vec![];
self.start_end = (0xFFFFFFFF, 0xFFFFFFFF);
self.jmp_to = (0xFFFFFFFF, 0xFFFFFFFF);
self.jmp_to_block = (0xFFFFFFFF, 0xFFFFFFFF);
self.xrefs_to = vec![];
self.xrefs_from = vec![];
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[allow(dead_code)]
pub enum IrInstr {
ES,
None,
}
#[derive(Copy, Clone, Debug)]
pub struct Mnem2Ir {}
impl Mnem2Ir {
pub fn new() -> Mnem2Ir {
Mnem2Ir {}
}
pub fn convert(self, mnem: &Mnem) {
// println!("| ; 0x{:X} {}", mnem.ip, mnem.to_str());
/*
match mnem.instr {
/*R4 -= 4;
[R4] = SRC;*/
Instr::Push => {
/*
// println!("| sub R4, 4");
// println!("| mov [R4], {}", self.op2ir(&mnem, 0));
*/
// println!("| push {}", self.op2ir(&mnem, 0));
}
/*DST = [R4];
R4 += 4;*/
Instr::Pop => {
/*
// println!("| mov {}, [R4]", self.op2ir(&mnem, 0));
// println!("| add R4, 4");
*/
// println!("| pop {}", self.op2ir(&mnem, 0));
}
/*op0 = op1;*/
Instr::Mov => {
// println!("| mov {}, {}", self.op2ir(&mnem, 0), self.op2ir(&mnem, 1));
}
/*op0 += op1;
OF, SF, ZF, AF, CF, and PF flags are set according result*/
Instr::Add => {
// println!("| add {}, {}", self.op2ir(&mnem, 0), self.op2ir(&mnem, 1));
// println!(
"| set OF, ({} + {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set SF, ({} + {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set ZF, ({} + {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set AF, ({} + {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set CF, ({} + {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set PF, ({} + {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
}
/*op0 -= op1;
OF, SF, ZF, AF, PF, and CF flags are set according result*/
Instr::Sub => {
// println!("| sub {}, {}", self.op2ir(&mnem, 0), self.op2ir(&mnem, 1));
// println!(
"| set OF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set SF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set ZF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set AF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set PF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set CF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
}
/*op0 &= op1;
OF and CF flags cleared
SF, ZF, and PF flags are set according result
state of AF flag is undefined*/
Instr::And => {
// println!("| and {}, {}", self.op2ir(&mnem, 0), self.op2ir(&mnem, 1));
// println!("| clear OF, and");
// println!("| clear CF, and");
// println!(
"| set SF, ({} & {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set ZF, ({} & {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set PF, ({} & {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!("| undefine AF, and");
}
/*op0 |= op1
OF and CF flags cleared
SF, ZF, and PF flags are set according resul
state of AF flag is undefined*/
Instr::Or => {
// println!("| or {}, {}", self.op2ir(&mnem, 0), self.op2ir(&mnem, 1));
// println!("| clear OF, or");
// println!("| clear CF, or");
// println!(
"| set SF, ({} | {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set ZF, ({} | {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set PF, ({} | {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!("| undefine AF, or");
}
/*op0 ^= op1;
OF and CF flags cleared
SF, ZF, and PF flags are set according result
state of AF flag is undefined*/
Instr::Xor => {
// if mnem.op[0].val == mnem.op[1].val {
// // println!("| mov {}, 0", self.op2ir(&mnem, 0));
// } else {
// println!("| xor {}, {}", self.op2ir(&mnem, 0), self.op2ir(&mnem, 1));
// }
// println!("| clear OF, xor");
// println!("| clear CF, xor");
// println!(
"| set SF, ({} ^ {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set ZF, ({} ^ {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set PF, ({} ^ {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!("| undefine AF, xor");
}
/*IP = op1*/
Instr::Jmp => {
// println!("| jmp {}", self.op2ir(&mnem, 0));
}
/*if CF==1 then IP = op1*/
Instr::Jb => {
// println!("| jcc CF==1, {}", self.op2ir(&mnem, 0));
}
/*if CF==1 || ZF==1 then IP = op1*/
Instr::Jbe => {
// println!("| jcc (CF==1 || ZF==1), {}", self.op2ir(&mnem, 0));
}
/*if SF!=ofn IP = op1*/
Instr::Jl => {
// println!("| jcc SF!=OF, {}", self.op2ir(&mnem, 0));
}
/*if ZF==1 || SF!=ofn IP = op1*/
Instr::Jle => {
// println!("| jcc (ZF==1 || SF!=OF), {}", self.op2ir(&mnem, 0));
}
/*if CF==0 then IP = op1*/
Instr::Jnb => {
// println!("| jcc CF==0, {}", self.op2ir(&mnem, 0));
}
/*if CF==0 && ZF==0 then IP = op1*/
Instr::Jnbe => {
// println!("| jcc (CF==0 && ZF==0), {}", self.op2ir(&mnem, 0));
}
/*if SF==ofn IP = op1*/
Instr::Jnl => {
// println!("| jcc SF==OF, {}", self.op2ir(&mnem, 0));
}
/*if ZF==0 && SF==ofn IP = op1*/
Instr::Jnle => {
// println!("| jcc (ZF==0 && SF==OF), {}", self.op2ir(&mnem, 0));
}
/*if OF==0 then IP = op1*/
Instr::Jno => {
// println!("| jcc (OF==0), {}", self.op2ir(&mnem, 0));
}
/*if PF==0 then IP = op1*/
Instr::Jnp => {
// println!("| jcc (PF==0), {}", self.op2ir(&mnem, 0));
}
/*if SF==0 then IP = op1*/
Instr::Jns => {
// println!("| jcc (SF==0), {}", self.op2ir(&mnem, 0));
}
/*if ZF==0 then IP = op1*/
Instr::Jnz => {
// println!("| jcc ZF==0, {}", self.op2ir(&mnem, 0));
}
/*if OF==1 then IP = op1*/
Instr::Jo => {
// println!("| jcc OF==1, {}", self.op2ir(&mnem, 0));
}
/*if PF==1 then IP = op1*/
Instr::Jp => {
// println!("| jcc PF==1, {}", self.op2ir(&mnem, 0));
}
/*if SF==1 then IP = op1*/
Instr::Js => {
// println!("| jcc SF==1, {}", self.op2ir(&mnem, 0));
}
/*if ZF==1 then IP = op1*/
Instr::Jz => {
// println!("| jcc ZF==1, {}", self.op2ir(&mnem, 0));
}
/*op1 += 1*/
Instr::Inc => {
// println!("| add {}, 1", self.op2ir(&mnem, 0));
}
/*CF, OF, SF, ZF, AF, and PF flags are set according to result*/
Instr::Cmp => {
// println!(
"| set CF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set OF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set SF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set ZF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set AF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
// println!(
"| set PF, ({} - {})",
self.op2ir(&mnem, 0),
self.op2ir(&mnem, 1),
);
}
Instr::Leave => {
// println!("| mov R4, R5");
// println!("| pop R5");
}
Instr::Ret => {
// println!("| pop retaddr");
// println!("| R4 += {}", self.op2ir(&mnem, 0));
// println!("| jmp retaddr");
}
_ => {
// println!("| DEFAULT: {}", mnem.to_str());
}
}
// println!("|");
*/
}
pub fn op2ir(self, mnem: &Mnem, idx: usize) -> String {
let mut result = String::with_capacity(0x10);
result.push_str(match mnem.op[idx].val {
OperandE::Reg8Al => "R0L",
OperandE::Reg8Cl => "R1L",
OperandE::Reg8Dl => "R2L",
OperandE::Reg8Bl => "R3L",
OperandE::Reg8Ah => "R0H",
OperandE::Reg8Ch => "R1H",
OperandE::Reg8Dh => "R2H",
OperandE::Reg8Bh => "R3H",
OperandE::Reg16Ax => "R0X",
OperandE::Reg16Cx => "R1X",
OperandE::Reg16Dx => "R2X",
OperandE::Reg16Bx => "R3X",
OperandE::Reg16Sp => "R4X",
OperandE::Reg16Bp => "R5X",
OperandE::Reg16Si => "R6X",
OperandE::Reg16Di => "R7X",
OperandE::Reg32Eax => "R0",
OperandE::Reg32Ecx => "R1",
OperandE::Reg32Edx => "R2",
OperandE::Reg32Ebx => "R3",
OperandE::Reg32Esp => "R4",
OperandE::Reg32Ebp => "R5",
OperandE::Reg32Esi => "R6",
OperandE::Reg32Edi => "R7",
OperandE::MemReg16BxSi => "[R0X]",
OperandE::MemReg16BxDi => "[R1X]",
OperandE::MemReg16BpSi => "[R2X]",
OperandE::MemReg16BpDi => "[R3X]",
OperandE::MemReg16Si => "[R4X]",
OperandE::MemReg16Di => "[R5X]",
OperandE::MemReg16Bp => "[R6X]",
OperandE::MemReg16Bx => "[R7X]",
OperandE::MemReg32Eax => "[R0]",
OperandE::MemReg32Ecx => "[R1]",
OperandE::MemReg32Edx => "[R2]",
OperandE::MemReg32Ebx => "[R3]",
OperandE::MemReg32Esp => "[R4]",
OperandE::MemReg32Ebp => "[R5]",
OperandE::MemReg32Esi => "[R6]",
OperandE::MemReg32Edi => "[R7]",
OperandE::Jmp => "Jmp",
OperandE::Jcc_b => "Jcc_b",
OperandE::Jcc_be => "Jcc_be",
OperandE::Jcc_l => "Jcc_l",
OperandE::Jcc_le => "Jcc_le",
OperandE::Jcc_nb => "Jcc_nb",
OperandE::Jcc_nbe => "Jcc_nbe",
OperandE::Jcc_nl => "Jcc_nl",
OperandE::Jcc_nle => "Jcc_nle",
OperandE::Jcc_no => "Jcc_no",
OperandE::Jcc_np => "Jcc_np",
OperandE::Jcc_ns => "Jcc_ns",
OperandE::Jcc_nz => "Jcc_nz",
OperandE::Jcc_o => "Jcc_o",
OperandE::Jcc_p => "Jcc_p",
OperandE::Jcc_s => "Jcc_s",
OperandE::Jcc_z => "Jcc_z",
OperandE::Tmp => "Tmp",
_ => "",
});
result.push_str(&match mnem.op[idx].val {
OperandE::MemOffReg16BxSi => format!("[R0X_X86+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16BxDi => format!("[R1X_X86+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16BpSi => format!("[R2X_X86+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16BpDi => format!("[R3X_X86+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16Si => format!("[R4X+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16Di => format!("[R5X+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16Bp => format!("[R6X+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg16Bx => format!("[R7X+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Eax => format!("[R0+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Ecx => format!("[R1+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Edx => format!("[R2+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Ebx => format!("[R3+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Esp => format!("[R4+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Ebp => format!("[R5+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Esi => format!("[R6+0x{:X}]", mnem.op[idx].num),
OperandE::MemOffReg32Edi => format!("[R7+0x{:X}]", mnem.op[idx].num),
OperandE::ShortJmp => format!("{}", "ShortJmp"),
OperandE::PushByteNum | OperandE::ByteNum => format!("0x{:X}", mnem.op[idx].num),
OperandE::PushByteNum16 | OperandE::WordNum => format!("0x{:X}", mnem.op[idx].num),
OperandE::DwordNum => format!("0x{:X}", mnem.op[idx].num),
OperandE::WordOffset => format!("0x{:X}", mnem.op[idx].num),
OperandE::DwordOffset => format!("0x{:X}", mnem.op[idx].num),
OperandE::CallJmpDwordNum => format!("{}", "CallJmpDwordNum"),
OperandE::SIB => format!("{}", "Sib"),
_ => format!(""),
});
result
}
}
|
pub mod card;
pub mod deck;
pub mod player;
pub mod util;
|
use numpy::{IntoPyArray, PyArray2, PyArray4};
use pyo3::prelude::*;
use pyo3::types::{PyDict, PyType};
use pyo3::wrap_pyfunction;
use eco_sim::{
entity_type::Count,
rl_env_helper::{
ObsvWriter, ENTITY_REP_SIZE, MAX_REP_PER_CELL, MENTAL_REP_SIZE, PHYS_REP_SIZE,
},
Action, Cell, Coord, MentalState, SimState, World, WorldEntity, MAP_HEIGHT, MAP_WIDTH,
};
use eco_sim_gui::{start, TimeControl};
use ndarray::{Array4, ArrayBase};
use std::sync::{Arc, RwLock};
use std::thread::sleep;
use std::time::Duration;
type EnvObservation = PyArray4<f32>;
type EnvAction = usize;
type Reward = f32;
const MIN_SLEEP: Duration = Duration::from_millis(10);
const MAX_SLEEP: Duration = Duration::from_millis(100);
#[pyclass]
struct Environment {
sim: Arc<RwLock<SimState>>,
agents: Vec<(WorldEntity, Coord)>,
time_control: Option<Arc<RwLock<TimeControl>>>,
}
/*
#[pyfunction]
pub fn start_with_gui<'py>(py: Python<'py>, seed: u64, path: &str){
let sim = SimState::new_with_seed(1.0, seed);
let sim = Arc::new(RwLock::new(sim));
let sim_= Some(sim.clone());
py.allow_threads(move || {
std::thread::spawn(move ||start_py(sim, path));
eco_sim_gui::start(sim_);
});
}
fn start_py(sim: Arc<RwLock<SimState>>, path: &str) {
println!("no_gil");
let gil = Python::acquire_gil();
println!("gil");
let py = gil.python();
let env = Environment { sim, agents: Vec::new() };
let mut dict = PyDict::new(py).set_item("env", env);
let res = PyModule::import(py, path);
res.map(|drl_mod| drl_mod.call0("test", ));
}
*/
#[pymethods]
impl Environment {
#[new]
fn new(obj: &PyRawObject, seed: u64) {
let sim = SimState::new_with_seed(1.0, seed);
let sim = Arc::new(RwLock::new(sim));
obj.init(Environment {
sim,
agents: Vec::new(),
time_control: None,
});
}
fn start_gui<'py>(&mut self, py: Python<'py>) {
let tc = Arc::new(RwLock::new(TimeControl::Gone));
let sim = Some((self.sim.clone(), tc.clone()));
self.time_control = Some(tc);
py.allow_threads(move || std::thread::spawn(move || eco_sim_gui::start(sim)));
}
fn reset(&mut self, seed: u64) {
let mut sim = self.sim.write().unwrap();
*sim = SimState::new_with_seed(1.0, seed);
self.agents.clear()
}
fn register_agents(&mut self, number: Option<usize>) -> Vec<u8> {
let Self {
ref mut agents,
ref mut sim,
..
} = self;
let sim = sim.write().unwrap();
let mut old = Vec::new();
agents.retain(|(a, _)| {
let ret = sim
.world
.get_physical_state(a)
.map_or(false, |p| !p.is_dead())
&& sim.agent_system.mental_states.get(a).is_some();
if ret {
old.push(*a);
}
ret
});
let n = number.unwrap_or(1);
let mut c = 0;
for ms in (&sim.agent_system.mental_states).into_iter() {
if old.contains(&ms.id) {
continue;
}
match sim.world.get_physical_state(&ms.id) {
Some(phys) if !phys.is_dead() => {
agents.push((ms.id, ms.sight_radius));
c += 1;
if c >= n {
break;
}
}
_ => (),
}
}
agents
.iter()
.map(|(we, _c)| we.e_type().idx() as u8)
.collect()
}
fn state<'py>(
&self,
py: Python<'py>,
) -> PyResult<(
Vec<&'py EnvObservation>,
Vec<Reward>,
Vec<EnvAction>,
&'py PyArray2<f32>,
&'py PyArray2<f32>,
Vec<Vec<bool>>,
Vec<(usize, Option<usize>)>,
bool,
)> {
let sim = self.sim.read().unwrap();
let world = &sim.world;
let obsv_writer = ObsvWriter::new(world, &self.agents);
let mut positions = Vec::with_capacity(self.agents.len());
let mut observations = Vec::with_capacity(self.agents.len());
let mut rewards = Vec::with_capacity(self.agents.len());
let mut suggested = Vec::with_capacity(self.agents.len());
let mut remappings = Vec::new();
let mut shifted = 0;
for (i, (agent, _c)) in self.agents.iter().enumerate() {
let pyarr = PyArray4::zeros(
py,
(MAP_HEIGHT, MAP_WIDTH, MAX_REP_PER_CELL, ENTITY_REP_SIZE),
false,
);
observations.push(pyarr);
let (reward, act, killed) = match (
&sim.get_mental_state(agent),
world.get_physical_state(agent),
) {
(Some(ms), Some(phys)) if !phys.is_dead() => {
let reward = ms.score;
let suggested = ms.current_action;
(reward, suggested, false)
}
_ => (-1000.0, Action::Idle, true),
};
positions.push(world.positions.get(agent));
suggested.push(obsv_writer.encode_action(*agent, act).unwrap_or(0));
rewards.push(reward);
if killed {
remappings.push((i, None));
shifted += 1;
} else if shifted > 0 {
remappings.push((i, Some(i - shifted)))
}
}
let visibility = self
.agents
.iter()
.enumerate()
.map(|(i, (_a, s))| {
let v: Vec<bool> = positions
.iter()
.map(|op| match (op, positions[i]) {
(Some(other_pos), Some(pos)) if pos.distance(other_pos) <= *s => true,
_ => false,
})
.collect();
v
})
.collect();
let mut phys = PyArray2::zeros(py, (self.agents.len(), PHYS_REP_SIZE), false);
let mut mental = PyArray2::zeros(py, (self.agents.len(), MENTAL_REP_SIZE), false);
// let mut obs = Array4::zeros((MAP_HEIGHT, MAP_WIDTH, MAX_REP_PER_CELL, ENTITY_REP_SIZE));
{
let mut ones: Vec<_> = observations
.iter_mut()
.map(|pyarr| pyarr.as_array_mut())
.collect();
obsv_writer.encode_views(&mut ones);
obsv_writer.encode_agents(
&mut phys.as_array_mut(),
&mut mental.as_array_mut(),
&sim.agent_system.mental_states,
);
}
Ok((
observations,
rewards,
suggested,
phys,
mental,
visibility,
remappings,
false,
))
}
fn step<'py>(
&mut self,
py: Python<'py>,
actions: Vec<EnvAction>,
) -> PyResult<(
Vec<&'py EnvObservation>,
Vec<Reward>,
Vec<EnvAction>,
&'py PyArray2<f32>,
&'py PyArray2<f32>,
Vec<Vec<bool>>,
Vec<(usize, Option<usize>)>,
bool,
)> {
while let Some(dur) = {
self.time_control.as_mut().and_then(|tc| {
let tc = &mut *tc.write().unwrap();
match *tc {
TimeControl::Go => {
*tc = TimeControl::Gone;
None
}
TimeControl::Gone => Some(MIN_SLEEP),
TimeControl::Wait(dur) => Some(dur.min(MAX_SLEEP).max(MIN_SLEEP)),
}
})
} {
sleep(dur)
}
let actions_to_take: Vec<_> = {
let sim = self.sim.read().unwrap();
let world = &sim.world;
self.agents.retain(|(a, _)| {
world.get_physical_state(a).map_or(false, |p| !p.is_dead())
&& sim.agent_system.mental_states.get(a).is_some()
});
let obsv_writer = ObsvWriter::new(world, &self.agents);
self.agents
.iter()
.zip(actions.iter())
.map(|((we, _c), a)| (*we, obsv_writer.decode_action(*we, *a)))
.collect()
};
// println!("valid: {}", actions_to_take.iter().filter(|(_, r)|r.is_ok()).count());
py.allow_threads(|| self.sim.write().unwrap().step(actions_to_take));
self.state(py)
}
#[staticmethod]
fn action_space_size() -> usize {
ObsvWriter::ACTION_SPACE_SIZE
}
#[staticmethod]
fn map_width() -> usize {
MAP_WIDTH
}
#[staticmethod]
fn map_height() -> usize {
MAP_HEIGHT
}
#[staticmethod]
fn max_reps_per_square() -> usize {
MAX_REP_PER_CELL
}
#[staticmethod]
fn rep_size() -> usize {
ENTITY_REP_SIZE
}
#[staticmethod]
fn mental_rep_size() -> usize {
MENTAL_REP_SIZE
}
#[staticmethod]
fn physical_rep_size() -> usize {
PHYS_REP_SIZE
}
}
#[pymodule]
fn eco_sim(_py: Python, m: &PyModule) -> PyResult<()> {
m.add_class::<Environment>()?;
// m.add_wrapped(wrap_pyfunction!(start_with_gui))?;
Ok(())
}
|
use core::mem;
pub struct Bits([u8]);
impl Bits {
#[inline]
pub fn iter(&self) -> Iter { Iter { bits: self, pos: 0 } }
}
impl<'a> From<&'a [u8]> for &'a Bits {
#[inline]
fn from(bs: &'a [u8]) -> Self { unsafe { mem::transmute(bs) } }
}
impl<'a> From<&'a mut [u8]> for &'a mut Bits {
#[inline]
fn from(bs: &'a mut [u8]) -> Self { unsafe { mem::transmute(bs) } }
}
pub struct Iter<'a> {
bits: &'a Bits,
pos: usize,
}
impl<'a> Iterator for Iter<'a> {
type Item = bool;
#[inline]
fn next(&mut self) -> Option<bool> {
let (m, n) = (self.pos & 7, self.pos >> 3);
self.pos += 1;
self.bits.0.get(n).map(|x| 0 != x & (1 << m))
}
}
|
pub mod product;
pub mod cart;
pub mod order;
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use super::*;
use super::cart::item;
#[test]
fn create_order() {
let mut iphone_name = String::from("iphone v");
let mut iphone = product::Product::new(1, &mut iphone_name, 8000.0);
let mut samsung_name = String::from("samsung galaxy 1");
let mut samsung = product::Product::new(2, &mut samsung_name, 8000.0);
let mut item1 = item::Item::new(1, 2, &mut iphone);
let mut item2 = item::Item::new(2, 1, &mut samsung);
let mut items: HashMap<u32, &mut item::Item> = HashMap::new();
items.insert(item1.id, &mut item1);
items.insert(item2.id, &mut item2);
let mut cart1 = cart::Cart::new(1, &mut items);
let mut billing = order::Billing{
name: String::from("Wuriyanto"),
address: String::from("Banjarnegara"),
shipping_cost: 5000.0,
};
let order1 = order::Order::new(1, &mut cart1, &mut billing);
assert_eq!(order1.get_total(), 29000.0);
}
} |
extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::*;
#[proc_macro_attribute]
pub fn timed(_attrs: TokenStream, item: TokenStream) -> TokenStream {
if let Ok(mut fun) = parse::<ItemFn>(item.clone()) {
let new_stmts = rewrite_stmts(fun.sig.ident.to_string(), &mut fun.block.stmts);
fun.block.stmts = new_stmts;
return quote!(#fun).into();
}
if let Ok(mut fun) = parse::<TraitItemMethod>(item.clone()) {
if let Some(block) = fun.default.as_mut() {
let new_stmts = rewrite_stmts(fun.sig.ident.to_string(), &mut block.stmts);
block.stmts = new_stmts;
return quote!(#fun).into();
}
}
if let Ok(mut fun) = parse::<ImplItemMethod>(item) {
let new_stmts = rewrite_stmts(fun.sig.ident.to_string(), &mut fun.block.stmts);
fun.block.stmts = new_stmts;
return quote!(#fun).into();
}
panic!("`funtime::timed` only works on functions")
}
fn rewrite_stmts(name: String, stmts: &mut Vec<Stmt>) -> Vec<Stmt> {
fn truncate_stmt(stmt: &Stmt, len: usize) -> String {
let short =
format!("{}", quote::ToTokens::to_token_stream(stmt)).chars().collect::<Vec<_>>();
let short = if short.len() > len {
let mut short = short[..(len - 3)].into_iter().collect::<String>();
short.push_str("...");
short
} else {
short.into_iter().collect::<String>()
};
short
}
let setup: Block = parse_quote! {{
struct FuntimeTimer {
start: std::time::Instant,
name: &'static str,
buffer: String,
prev_mark: Option<std::time::Duration>,
}
impl Drop for FuntimeTimer {
fn drop(&mut self) {
use std::fmt::Write;
writeln!(&mut self.buffer, "funtime end: `{}` took {:?}", self.name, self.start.elapsed()).unwrap();
print!("{}", &self.buffer);
}
}
impl FuntimeTimer {
fn new(name: &'static str) -> Self {
use std::fmt::Write;
let mut buffer = String::new();
writeln!(&mut buffer, "funtime start: `{}`", name).unwrap();
FuntimeTimer {
start: std::time::Instant::now(),
name,
buffer,
prev_mark: None,
}
}
fn mark_elapsed(&mut self, short: &str) {
use std::fmt::Write;
let mut elapsed = self.start.elapsed();
if let Some(prev) = self.prev_mark.replace(elapsed) {
elapsed = elapsed - prev;
}
writeln!(&mut self.buffer, " took {:?}: `{}`", elapsed, short).unwrap();
}
}
let mut funtime_timer = FuntimeTimer::new(#name);
}};
let mut new_stmts = setup.stmts;
let last = stmts.pop();
for stmt in stmts.drain(..) {
let short = truncate_stmt(&stmt, 40);
let next_stmt = parse_quote!(funtime_timer.mark_elapsed(#short););
new_stmts.push(stmt);
new_stmts.push(next_stmt);
}
if let Some(stmt) = last {
let short = truncate_stmt(&stmt, 40);
let new_stmt = parse_quote! {
let funtime_return_val = {
#stmt
};
};
let next_stmt = parse_quote!(funtime_timer.mark_elapsed(#short););
let return_stmt = parse_quote!(return funtime_return_val;);
new_stmts.push(new_stmt);
new_stmts.push(next_stmt);
new_stmts.push(return_stmt);
}
new_stmts
}
|
// Copyright (c) The Starcoin Core Contributors
// SPDX-License-Identifier: Apache-2.0
use anyhow::Result;
use schemadb::schema::{Schema, SeekKeyCodec};
use schemadb::{ReadOptions, SchemaBatch};
pub trait SchemaDB {
fn get<S: Schema>(&self, schema_key: &S::Key) -> Result<Option<S::Value>>
where
S::Key: Clone;
fn put<S: Schema>(&self, key: &S::Key, value: &S::Value) -> Result<()>;
/// Delete all keys in range [begin, end).
/// `SK` has to be an explict type parameter since
/// https://github.com/rust-lang/rust/issues/44721
fn range_delete<S, SK>(&self, begin: &SK, end: &SK) -> Result<()>
where
S: Schema,
SK: SeekKeyCodec<S>;
fn iter<'a, S: Schema + 'static>(
&'a self,
opts: ReadOptions,
) -> Result<Box<dyn SchemaIterator<S> + 'a>>;
fn write_schemas(&self, batch: SchemaBatch) -> Result<()>;
}
pub trait SchemaIterator<S: Schema>: Iterator<Item = Result<(S::Key, S::Value)>> {
/// Seeks to the first key.
fn seek_to_first(&mut self) -> bool;
/// Seeks to the last key.
fn seek_to_last(&mut self) -> bool;
/// Seeks to the first key whose binary representation is equal to or greater than that of the
/// `seek_key`.
fn seek(&mut self, seek_key: &S::Key) -> Result<bool>;
/// Seeks to the last key whose binary representation is less than or equal to that of the
/// `seek_key`.
///
/// See example in [`RocksDB doc`](https://github.com/facebook/rocksdb/wiki/SeekForPrev).
fn seek_for_prev(&mut self, seek_key: &S::Key) -> Result<bool>;
}
|
use std::cmp::Ordering;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use num_str_cmp::numeric_str_cmp;
fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("cmp two digits", |b| {
b.iter(|| {
assert_eq!(
numeric_str_cmp(black_box("20"), black_box("10")),
Ordering::Greater
)
})
});
c.bench_function("cmp two digits parse", |b| {
b.iter(|| {
let a = black_box("20").parse::<f64>().unwrap();
let b = black_box("10").parse().unwrap();
let ord = if a > b {
Ordering::Greater
} else if a < b {
Ordering::Less
} else {
Ordering::Equal
};
assert_eq!(ord, Ordering::Greater);
})
});
c.bench_function("cmp 100 digits", |b| {
let s1 = black_box("20".repeat(50));
let s2 = black_box("50".repeat(50));
b.iter(|| assert_eq!(numeric_str_cmp(&s1, &s2), Ordering::Less));
});
c.bench_function("cmp 100 digits parse", |b| {
let s1 = black_box("20".repeat(50));
let s2 = black_box("50".repeat(50));
b.iter(|| {
let a = s1.parse::<f64>().unwrap();
let b = s2.parse().unwrap();
let ord = if a > b {
Ordering::Greater
} else if a < b {
Ordering::Less
} else {
Ordering::Equal
};
assert_eq!(ord, Ordering::Less);
})
});
c.bench_function("cmp 100,000 digits", |b| {
let s1 = black_box("20".repeat(50000));
let s2 = black_box("50".repeat(50000));
b.iter(|| assert_eq!(numeric_str_cmp(&s1, &s2), Ordering::Less));
});
// parsing a 100,000 digit number is much faster because they are greater than f64::MAX and parse to f64::INFINITY.
// comparisons are not accurate.
c.bench_function("cmp 100,000 digits parse", |b| {
let s1 = black_box("20".repeat(50000));
let s2 = black_box("50".repeat(50000));
b.iter(|| {
let a = s1.parse::<f64>().unwrap();
let b = s2.parse().unwrap();
assert!(a == f64::INFINITY);
assert!(b == f64::INFINITY);
let ord = if a > b {
Ordering::Greater
} else if a < b {
Ordering::Less
} else {
Ordering::Equal
};
assert_eq!(ord, Ordering::Equal)
})
});
c.bench_function("cmp 100 digits after decimal pt", |b| {
let s1 = black_box({
let mut string = "0.".to_string();
string.push_str(&"20".repeat(50));
string
});
let s2 = black_box({
let mut string = "0.".to_string();
string.push_str(&"50".repeat(50));
string
});
b.iter(|| assert_eq!(numeric_str_cmp(&s1, &s2), Ordering::Less));
});
c.bench_function("cmp 100 digits after decimal pt parse", |b| {
let s1 = black_box({
let mut string = "0.".to_string();
string.push_str(&"20".repeat(50));
string
});
let s2 = black_box({
let mut string = "0.".to_string();
string.push_str(&"50".repeat(50));
string
});
b.iter(|| {
let a = s1.parse::<f64>().unwrap();
let b = s2.parse().unwrap();
let ord = if a > b {
Ordering::Greater
} else if a < b {
Ordering::Less
} else {
Ordering::Equal
};
assert_eq!(ord, Ordering::Less);
})
});
c.bench_function("cmp 100 digits before and after decimal pt", |b| {
let s1 = black_box({
let mut string = "0.".to_string();
string.push_str(&"20".repeat(50));
string
});
let s2 = black_box({
let mut string = "0.".to_string();
string.push_str(&"50".repeat(50));
string
});
b.iter(|| assert_eq!(numeric_str_cmp(&s1, &s2), Ordering::Less));
});
c.bench_function("cmp 100 digits before and after decimal pt parse", |b| {
let s1 = black_box({
let mut string = "20".repeat(50);
string.push_str(&"20".repeat(50));
string
});
let s2 = black_box({
let mut string = "50".repeat(50);
string.push_str(&"50".repeat(50));
string
});
b.iter(|| {
let a = s1.parse::<f64>().unwrap();
let b = s2.parse().unwrap();
let ord = if a > b {
Ordering::Greater
} else if a < b {
Ordering::Less
} else {
Ordering::Equal
};
assert_eq!(ord, Ordering::Less);
})
});
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);
|
use particle::collide::collide::Collider;
use particle::decay::decay::Decayer;
use particle::decay::emit::Emitter;
use sack::{SackType, SackBacker, SackStorable, Sack};
// ----------------------------------------------------------
/// A test concrete implementation
use sack::TokenLike;
use std::collections::BTreeMap;
impl<C, D, T> SackBacker for BTreeBackedSack<C, D, T>
where C: SackStorable,
D: SackStorable,
T: Clone
{
}
// #[derive(Clone,Debug)]
// pub struct BTreeBackedSack<C, D, T> {
// t: T,
// b: BTreeMap<C, D>,
// }
// impl<'a, C: 'a, T: 'a> SackLike<'a, C, (), C> for BTreeBackedSack<C, (), T>
// where C: SackBacker,
// T: TokenLike
// {
// }
pub type BTreeBackedSack<C, D, T> = Sack<C, D, BTreeMap<C, D>, T>;
// #[derive(Clone)]
// pub struct Sack<C, D, B, T>
// where B: SackBacker
// {
// b: B,
// t: T,
// _phantom: PhantomData<(C, D)>,
// }
impl<'a,C1:'a, C2:'a, C3:'a, D1:'a, D2:'a, D3:'a, B1:'a, B2:'a, B3:'a, T1:'a, T2:'a, T3:'a>
Decayer<'a, C1, C2, C3, D1, D2, D3, B1, B2, B3, T1, T2, T3> for (SackType<C1, D1, B1>, SackType<C2, D2, B2>,SackType<C3, D3, B3>)
where C1: SackStorable,
C2: SackStorable,
C3: SackStorable,
D1: SackStorable,
D2: SackStorable,
D3: SackStorable,
B1: SackBacker,
B2: SackBacker,
B3: SackBacker,
T1: TokenLike,
T2: TokenLike,
T3: TokenLike
{
fn decay(&mut self) -> (&'a SackType<C2, D2, B2>, &'a SackType<C3, D3, B3>) {
unimplemented!()
}
}
impl<'a, C1: 'a, C2: 'a, D1: 'a, D2: 'a, B1: 'a, B2: 'a, T1: 'a, T2: 'a> Emitter<'a, C1, C2, D1, D2, B1, B2, T1, T2> for Decayer<'a, C1, C1, C2, D1, D1, D2, B1, B1, B2, T1, T1, T2>
where T1: Default,
C1: SackStorable,
C2: SackStorable,
D1: SackStorable,
D2: SackStorable,
B1: SackBacker,
B2: SackBacker,
T1: TokenLike,
T2: TokenLike
{
fn emit(_s1: &'a SackType<C1, D1, B1>) -> (&'a SackType<C1, D1, B1>, &'a SackType<C2, D2, B2>) {
unimplemented!()
}
}
impl<'a, C1, C2, C3, C4, D1, D2, D3, D4, B1, B2, B3, B4, T1, T2, T3, T4> Collider<'a, C1, C2, C3, C4, D1, D2, D3, D4, B1, B2, B3, B4, T1, T2, T3, T4>
for (C1, C2, C3, C4, D1, D2, D3, D4, B1, B2, B3, B4, T1, T2, T3, T4)
where B1: SackBacker,
B2: SackBacker,
B3: SackBacker,
B4: SackBacker
{
fn collide(_s1: &'a SackType<C1, D1, B1>, _s2: &'a SackType<C2, D2, B2>) -> (&'a SackType<C3, D3, B3>, &'a SackType<C4, D4, B4>) {
unimplemented!()
}
}
// impl<'a, C: 'a, T: 'a> SetStore<'a, BTreeBackedSack<C, (), T>, C> for BTreeBackedSack<C, (), T>
// where T: TokenLike + Default,
// C: SackBacker + SackStorable + Default + Ord+Copy
// {
// fn insert(&'a mut self, value: C) -> &'a Self {
// // let (mut b,t) = (self.b,self.t);
// self.b.insert(value, ());
// self
// }
// }
// impl<C, D, T> Default for BTreeBackedSack<C, D, T>
// where T: Default,
// C: Default + Ord
// {
// fn default() -> BTreeBackedSack<C, D, T> {
// BTreeBackedSack {
// t: T::default(),
// b: SackTypes::new(),
// }
// }
// }
|
use std::{
collections::HashMap,
hash::{BuildHasher, Hash},
};
use vec_map::VecMap;
use crate::Entity;
pub trait Get<E: Entity> {
fn get(&self, k: &E::Key) -> Option<&E>;
}
impl<E: Entity, T> Get<E> for &T
where
T: Get<E>,
{
fn get(&self, k: &E::Key) -> Option<&E> {
(*self).get(k)
}
}
impl<E: Entity, T> Get<E> for &mut T
where
T: Get<E>,
{
fn get(&self, k: &E::Key) -> Option<&E> {
(**self).get(k)
}
}
#[cfg(feature = "cache")]
impl<E: Entity, S> Get<E> for cache::Cache<E::Key, E, S>
where
E::Key: Eq + Hash,
S: BuildHasher,
{
fn get(&self, k: &E::Key) -> Option<&E> {
cache::Cache::get(self, k)
}
}
impl<E: Entity, S> Get<E> for HashMap<E::Key, E, S>
where
E::Key: Eq + Hash,
S: BuildHasher,
{
fn get(&self, k: &E::Key) -> Option<&E> {
HashMap::get(self, k)
}
}
impl<E: Entity> Get<E> for VecMap<E::Key, E>
where
E::Key: Clone + Into<usize>,
{
fn get(&self, k: &E::Key) -> Option<&E> {
VecMap::get(self, k)
}
}
|
//! A wrapper around libmalloc APIs.
use crate::bindings::{
mach_task_self_, malloc_default_zone, malloc_statistics_t, malloc_zone_t, vm_address_t,
};
use std::{io, str};
/// A Wrapper around `malloc_statistics_t`, originally defined at `libmalloc.h`.
pub type MallocStatistics = malloc_statistics_t;
/// A Wrapper around `malloc_zone_t`, originally defined at `libmalloc.h`.
pub struct MallocZone(*mut malloc_zone_t);
impl MallocZone {
/// Get the name of this zone.
pub fn name(&self) -> Result<&str, str::Utf8Error> {
unsafe { std::ffi::CStr::from_ptr((*self.0).zone_name) }.to_str()
}
/// Get the statistics of this zone.
pub fn statistics(&mut self) -> Option<MallocStatistics> {
unsafe {
let mut stats = std::mem::MaybeUninit::<malloc_statistics_t>::zeroed();
if let Some(f) = (*((*self.0).introspect)).statistics {
f(self.0, stats.as_mut_ptr());
Some(stats.assume_init())
} else {
None
}
}
}
}
/// Get all malloc zones of current process.
///
/// # Safety
/// CAUTION： `MallocZone`s(*malloc_zone_t) returned by `malloc_get_all_zones`
/// may be destoryed by other threads.
pub unsafe fn malloc_get_all_zones() -> io::Result<Vec<MallocZone>> {
let mut count: u32 = 0;
let mut zones: *mut vm_address_t = std::ptr::null_mut();
let ret = crate::bindings::malloc_get_all_zones(mach_task_self_, None, &mut zones, &mut count);
if ret != 0 {
Err(io::Error::from_raw_os_error(ret))
} else {
let zones =
std::slice::from_raw_parts_mut(zones as *mut *mut malloc_zone_t, count as usize)
.iter()
.map(|&p| MallocZone(p))
.collect::<Vec<_>>();
Ok(zones)
}
}
/// Get the default malloc zone of current process.
pub fn malloc_get_default_zone() -> MallocZone {
MallocZone(unsafe { malloc_default_zone() })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_malloc_get_all_zones() {
let zones = unsafe { malloc_get_all_zones().unwrap() };
assert!(!zones.is_empty());
let zone_names = zones.iter().map(|z| z.name().unwrap()).collect::<Vec<_>>();
assert!(zone_names.contains(&"DefaultMallocZone"));
}
#[test]
fn test_malloc_get_default_zone() {
let zone = malloc_get_default_zone();
assert_eq!(zone.name().unwrap(), "DefaultMallocZone");
}
#[test]
fn test_malloc_zone_statistics() {
let zones = unsafe { malloc_get_all_zones() }.unwrap();
for mut zone in zones {
let stat = zone.statistics().unwrap();
assert!(stat.blocks_in_use > 0);
assert!(stat.size_in_use > 0);
assert!(stat.max_size_in_use > 0);
assert!(stat.size_allocated > 0);
}
}
}
|
/// An error that could occur when using the API.
#[allow(missing_docs)]
#[derive(Debug, Error)]
pub enum Error {
#[error("hyper error: {0}")]
Hyper(#[from] hyper::Error),
#[error("invalid uri: {0}")]
InvalidUri(#[from] http::uri::InvalidUri),
#[error("serde_json error: {0}")]
Json(#[from] serde_json::Error),
#[error("reqwest error: {0}")]
Reqwest(#[from] reqwest::Error),
#[error("url parse error: {0}")]
UrlParse(#[from] url::ParseError),
}
/// Result type that defaults to the API error.
pub type Result<T, E = Error> = std::result::Result<T, E>;
|
use std::io;
//use std::io::prelude::*;
use std::cmp;
//use std::slice::range;
//use std::num::integer::gcd;
fn hex_sum(val: i32) -> i32 {
let hex_base: i32 = 16;
let mut count: i32 = 0;
let mut i = val;
while i > 0 {
count = count + (i % hex_base);
i = i / hex_base;
}
return count;
}
fn gcd(first: i32, second: i32) -> i32 {
let lesser = cmp::min(first, second);
//const int highest_possible_gcd = greater / 2;
let gcd_range = std::ops::Range::<i32>{ start: 2, end: lesser + 1 };
for i in gcd_range.rev() {
let divides_first = (first % i) == 0;
let divides_second = (second % i) == 0;
if divides_first && divides_second {
return i;
}
}
return 1;
}
fn solve_range(lower: i32, upper: i32) {
let mut non_1_gcd = 0;
for j in lower..(upper+1) {
let f_j = hex_sum(j);
let hex_gcd = gcd(j, f_j);
if hex_gcd != 1 {
non_1_gcd = non_1_gcd + 1;
}
}
println!("{}", non_1_gcd);
}
fn main() {
let mut buffer = String::new();
io::stdin().read_line(&mut buffer).expect("could not read line"); // Reading input from STDIN
let num_ranges = buffer.trim().parse::<i32>().unwrap();
for _ in 0..num_ranges {
let mut buffer = String::new();
io::stdin().read_line(&mut buffer).expect("could not read line");
let trimmed_buffer = buffer.trim();
let vec: Vec<&str> = trimmed_buffer.split(" ").collect();
let lower = vec[0].parse::<i32>().unwrap();
let upper = vec[1].parse::<i32>().unwrap();
solve_range(lower, upper);
}
} |
pub mod dead;
pub mod in_game;
pub mod screen;
pub mod start;
pub use dead::DeadScreen;
|
extern crate wiringpi;
use std::ffi::CString;
fn main() {
wiringpi::setup();
let bits = 4;
let cols = 16;
let rows = 2;
// Initialized the LCD
let lcd = wiringpi::lcd::lcd_init(rows, cols, bits, 11, 10, 4, 5, 6, 7, 0, 0, 0, 0);
// Move the cursore
wiringpi::lcd::lcd_position(lcd, 1, 1);
// Write something
wiringpi::lcd::lcd_puts(lcd, CString::new("Hello World!").unwrap());
loop {
}
}
|
// Copyright (c) Facebook, Inc. and its affiliates.
//
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
use crate::ExecutionTrace;
use air::{
Air, AirContext, Assertion, EvaluationFrame, FieldExtension, HashFunction, ProofOptions,
TraceInfo, TransitionConstraintDegree,
};
use math::{fields::f128::BaseElement, FieldElement, StarkField};
use utils::collections::Vec;
// FIBONACCI TRACE BUILDER
// ================================================================================================
pub fn build_fib_trace(length: usize) -> ExecutionTrace<BaseElement> {
assert!(length.is_power_of_two(), "length must be a power of 2");
let mut reg1 = vec![BaseElement::ONE];
let mut reg2 = vec![BaseElement::ONE];
for i in 0..(length / 2 - 1) {
reg1.push(reg1[i] + reg2[i]);
reg2.push(reg1[i] + BaseElement::from(2u8) * reg2[i]);
}
ExecutionTrace::init(vec![reg1, reg2])
}
// MOCK AIR
// ================================================================================================
pub struct MockAir {
context: AirContext<BaseElement>,
assertions: Vec<Assertion<BaseElement>>,
periodic_columns: Vec<Vec<BaseElement>>,
}
impl MockAir {
pub fn with_trace_length(trace_length: usize) -> Self {
Self::new(
TraceInfo::new(4, trace_length),
(),
ProofOptions::new(
32,
8,
0,
HashFunction::Blake3_256,
FieldExtension::None,
4,
256,
),
)
}
pub fn with_periodic_columns(
column_values: Vec<Vec<BaseElement>>,
trace_length: usize,
) -> Self {
let mut result = Self::new(
TraceInfo::new(4, trace_length),
(),
ProofOptions::new(
32,
8,
0,
HashFunction::Blake3_256,
FieldExtension::None,
4,
256,
),
);
result.periodic_columns = column_values;
result
}
pub fn with_assertions(assertions: Vec<Assertion<BaseElement>>, trace_length: usize) -> Self {
let mut result = Self::new(
TraceInfo::new(4, trace_length),
(),
ProofOptions::new(
32,
8,
0,
HashFunction::Blake3_256,
FieldExtension::None,
4,
256,
),
);
result.assertions = assertions;
result
}
}
impl Air for MockAir {
type BaseElement = BaseElement;
type PublicInputs = ();
fn new(trace_info: TraceInfo, _pub_inputs: (), _options: ProofOptions) -> Self {
let context = build_context(trace_info, 8);
MockAir {
context,
assertions: Vec::new(),
periodic_columns: Vec::new(),
}
}
fn context(&self) -> &AirContext<Self::BaseElement> {
&self.context
}
fn evaluate_transition<E: FieldElement + From<Self::BaseElement>>(
&self,
_frame: &EvaluationFrame<E>,
_periodic_values: &[E],
_result: &mut [E],
) {
}
fn get_assertions(&self) -> Vec<Assertion<Self::BaseElement>> {
self.assertions.clone()
}
fn get_periodic_column_values(&self) -> Vec<Vec<Self::BaseElement>> {
self.periodic_columns.clone()
}
}
// HELPER FUNCTIONS
// ================================================================================================
fn build_context<B: StarkField>(trace_info: TraceInfo, blowup_factor: usize) -> AirContext<B> {
let options = ProofOptions::new(
32,
blowup_factor,
0,
HashFunction::Blake3_256,
FieldExtension::None,
4,
256,
);
let t_degrees = vec![TransitionConstraintDegree::new(2)];
AirContext::new(trace_info, t_degrees, options)
}
|
use std::convert::TryFrom;
use futures::{Future, FutureExt};
use super::{BuilderState, Command, KeyOperation, Kv, Output};
use crate::{
kv::{IncompatibleTypeError, Numeric, Value},
Error,
};
/// Executes [`Command::Set`] when awaited. Also offers methods to customize the
/// options for the operation.
#[must_use = "futures do nothing unless you `.await` or poll them"]
pub struct Builder<'a, Kv, V> {
state: BuilderState<'a, Options<'a, Kv>, Result<V, Error>>,
}
struct Options<'a, Kv> {
kv: &'a Kv,
namespace: Option<String>,
key: String,
increment: bool,
amount: Numeric,
saturating: bool,
}
impl<'a, K, V> Builder<'a, K, V>
where
K: Kv,
{
pub(crate) fn new(
kv: &'a K,
namespace: Option<String>,
increment: bool,
key: String,
amount: Numeric,
) -> Self {
Self {
state: BuilderState::Pending(Some(Options {
key,
kv,
namespace,
increment,
amount,
saturating: true,
})),
}
}
fn options(&mut self) -> &mut Options<'a, K> {
if let BuilderState::Pending(Some(options)) = &mut self.state {
options
} else {
panic!("Attempted to use after retrieving the result")
}
}
/// Allows overflowing the value.
pub fn allow_overflow(mut self) -> Self {
self.options().saturating = false;
self
}
}
impl<'a, K, V> Future for Builder<'a, K, V>
where
K: Kv,
V: TryFrom<Numeric, Error = IncompatibleTypeError>,
{
type Output = Result<V, Error>;
fn poll(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Self::Output> {
match &mut self.state {
BuilderState::Executing(future) => future.as_mut().poll(cx),
BuilderState::Pending(builder) => {
let Options {
kv,
namespace,
key,
increment,
amount,
saturating,
} = builder.take().expect("expected builder to have options");
let future = async move {
let result = kv
.execute_key_operation(KeyOperation {
namespace,
key,
command: if increment {
Command::Increment { amount, saturating }
} else {
Command::Decrement { amount, saturating }
},
})
.await?;
if let Output::Value(Some(Value::Numeric(value))) = result {
Ok(V::try_from(value).expect("server should send back identical type"))
} else {
unreachable!("Unexpected result from key value operation")
}
}
.boxed();
self.state = BuilderState::Executing(future);
self.poll(cx)
}
}
}
}
|
// Copyright (c) 2017 oic developers
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.
//! Rust bindings over the Oracle Database Programming Interface for Drivers and Applications.
#![deny(missing_docs)]
#![feature(untagged_unions)]
#![recursion_limit="128"]
#![cfg_attr(feature = "cargo-clippy", allow(unseparated_literal_suffix))]
#[macro_use]
extern crate bitflags;
#[macro_use]
extern crate error_chain;
#[cfg(test)]
#[macro_use]
extern crate lazy_static;
#[macro_use]
extern crate slog;
#[macro_use]
mod macros;
extern crate chrono;
#[cfg(test)]
extern crate rand;
// Public API
pub mod common;
pub mod connection;
pub mod context;
pub mod data;
pub mod dequeue;
pub mod enqueue;
#[allow(missing_docs)]
pub mod error;
pub mod lob;
pub mod message;
pub mod object;
pub mod objecttype;
pub mod pool;
pub mod query;
pub mod rowid;
pub mod statement;
pub mod subscription;
pub mod variable;
mod odpi;
mod util;
pub use odpi::{constants, flags};
pub use odpi::structs::ODPIDataValueUnion as DataUnion;
#[cfg(test)]
mod test {
use context;
use error;
use std::ffi::CString;
use std::fs::File;
use std::io::{BufRead, BufReader};
#[cfg(test)]
pub enum ContextResult {
Ok(context::Context),
Err(error::Error),
}
#[cfg(test)]
unsafe impl Sync for ContextResult {}
#[cfg(test)]
lazy_static! {
pub static ref ENC: CString = CString::new("UTF-8").expect("badness");
pub static ref CREDS: Vec<String> = {
let file = File::open(".creds/oic-test")
.expect("bad creds");
let mut buf_reader = BufReader::new(file);
let mut creds = String::new();
let _ = buf_reader.read_line(&mut creds).expect("bad creds");
creds.split(":").map(|x| x.trim_right().to_string()).collect()
};
pub static ref CTXT: ContextResult = {
match context::Context::create() {
Ok(ctxt) => {
ContextResult::Ok(ctxt)
},
Err(e) => ContextResult::Err(e),
}
};
}
#[cfg(test)]
pub fn error_info(e: error::Error) {
use std::io::{self, Write};
writeln!(io::stderr(), "{}", e).expect("badness");
let ctxt = match *CTXT {
ContextResult::Ok(ref ctxt) => ctxt,
ContextResult::Err(ref _e) => return assert!(false),
};
let ctxt_error = ctxt.get_error();
writeln!(io::stderr(), "{}", ctxt_error).expect("badness");
assert!(false);
}
}
|
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#![allow(non_camel_case_types)]
mod clone;
pub use clone::clone3_syscall;
pub use clone::clone_syscall;
pub use clone::vfork_return_from_child;
pub use clone::vfork_syscall;
extern "C" {
pub fn calling_from_plugin() -> bool;
pub fn enter_plugin();
pub fn exit_plugin();
pub fn is_vdso_ready() -> bool;
}
pub type vdso_clock_gettime_fn =
extern "C" fn(clockid: libc::clockid_t, tp: *mut libc::timespec) -> i32;
pub type vdso_getcpu_fn = extern "C" fn(cpu: *mut u32, node: *mut u32, _unused: usize) -> i32;
pub type vdso_gettimeofday_fn =
extern "C" fn(tv: *mut libc::timeval, tz: *mut libc::timezone) -> i32;
pub type vdso_time_fn = extern "C" fn(tloc: *mut libc::time_t) -> i32;
pub extern "C" fn vdso_clock_gettime_stub(
_clockid: libc::clockid_t,
_tp: *mut libc::timespec,
) -> i32 {
// HACK: These are never called, but referencing these functions ensures
// they get linked into our binary. These are actually used by the loader.
unsafe { calling_from_plugin() };
unsafe { enter_plugin() };
unsafe { exit_plugin() };
unsafe { is_vdso_ready() };
-libc::EFAULT
}
pub extern "C" fn vdso_getcpu_stub(_cpu: *mut u32, _node: *mut u32, _unused: usize) -> i32 {
-libc::EFAULT
}
pub extern "C" fn vdso_gettimeofday_stub(_tv: *mut libc::timeval, _tz: *mut libc::timezone) -> i32 {
-libc::EFAULT
}
pub extern "C" fn vdso_time_stub(_tloc: *mut libc::time_t) -> i32 {
-libc::EFAULT
}
pub type void_void_fn = unsafe extern "C" fn() -> *mut libc::c_void;
#[repr(C)]
pub struct fn_icept {
pub lib_name: *const libc::c_char,
pub fn_name: *const libc::c_char,
pub icept_callback: extern "C" fn(void_void_fn) -> void_void_fn,
}
pub type icept_reg_fn = extern "C" fn(*const fn_icept);
unsafe impl Send for fn_icept {}
unsafe impl Sync for fn_icept {}
#[repr(C)]
pub struct syscall_stackframe {
pub rbp_stackalign: *mut libc::c_void,
pub r15: *mut libc::c_void,
pub r14: *mut libc::c_void,
pub r13: *mut libc::c_void,
pub r12: *mut libc::c_void,
pub r11: *mut libc::c_void,
pub r10: *mut libc::c_void,
pub r9: *mut libc::c_void,
pub r8: *mut libc::c_void,
pub rdi: *mut libc::c_void,
pub rsi: *mut libc::c_void,
pub rdx: *mut libc::c_void,
pub rcx: *mut libc::c_void,
pub rbx: *mut libc::c_void,
pub rbp_prologue: *mut libc::c_void,
// trampoline
pub fake_ret: *mut libc::c_void,
/// Syscall return address. This is where execution should continue after a
/// syscall has been handled.
pub ret: *mut libc::c_void,
}
pub type handle_syscall_fn = extern "C" fn(
syscall: isize,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
arg5: usize,
arg6: usize,
wrapper_sp: *mut syscall_stackframe,
) -> usize;
pub type handle_vdso_fn =
extern "C" fn(syscall: isize, actual_fn: void_void_fn) -> Option<void_void_fn>;
pub type handle_rdtsc_fn = extern "C" fn() -> u64;
pub type post_load_fn = extern "C" fn(bool);
/// A struct of arguments for the clone3 syscall.
#[derive(Debug)]
#[repr(C)]
pub struct clone_args {
// Flags bit mask
pub flags: u64,
// Where to store PID file descriptor (int *)
pub pidfd: u64,
// Where to store child TID, in child's memory (pid_t *)
pub child_tid: u64,
// Where to store child TID, in parent's memory (pid_t *)
pub parent_tid: u64,
// Signal to deliver to parent on child termination
pub exit_signal: u64,
// Pointer to lowest byte of stack
pub stack: u64,
// Size of stack
pub stack_size: u64,
// Location of new TLS
pub tls: u64,
// Pointer to a pid_t array (since Linux 5.5)
pub set_tid: u64,
// Number of elements in set_tid (since Linux 5.5)
pub set_tid_size: u64,
// File descriptor for target cgroup of child (since Linux 5.7)
pub cgroup: u64,
}
|
mod number;
use self::number::number_literal;
mod string;
pub use self::string::string_literal;
mod boolean;
use self::boolean::bool_literal;
mod array;
use self::array::*;
mod float;
use self::float::float_literal;
#[allow(unused_imports)]
use nom::*;
use ast::Ast;
/// put all literal types here
named!(pub literal<Ast>,
alt_complete!(
array_literal |
array_range |
float_literal |
number_literal |
string_literal |
bool_literal
)
);
#[cfg(test)]
mod test {
use super::*;
use datatype::Datatype;
#[test]
fn verify_literal_with_escapes_in_strings() {
let input_string = "
\"\nHello\nWorld\n\"
";
let (_, ast) = match literal(input_string.as_bytes()) {
IResult::Done(rest, v) => (rest, v),
IResult::Error(e) => panic!("Error in parsing: {}", e),
IResult::Incomplete(i) => panic!("Incomplete parse: {:?}", i),
};
assert_eq!(
Ast::Literal(Datatype::String("\nHello\nWorld\n".to_string())),
ast
)
}
#[test]
fn literal_captures_float_before_number() {
let input_string = "40.5";
let (_, ast) = match literal(input_string.as_bytes()) {
IResult::Done(rest, v) => (rest, v),
IResult::Error(e) => panic!("Error in parsing: {}", e),
IResult::Incomplete(i) => panic!("Incomplete parse: {:?}", i),
};
assert_eq!(
Ast::Literal(Datatype::Float(40.5)),
ast
)
}
#[test]
fn literal_can_capture_number() {
let input_string = "40";
let (_, ast) = match literal(input_string.as_bytes()) {
IResult::Done(rest, v) => (rest, v),
IResult::Error(e) => panic!("Error in parsing: {}", e),
IResult::Incomplete(i) => panic!("Incomplete parse: {:?}", i),
};
assert_eq!(
Ast::Literal(Datatype::Number(40)),
ast
)
}
// This behavior should cause the consuming parser to fail.
#[test]
fn space_in_float_causes_number_parse_instead() {
let input_string = "40. 5";
let (_, ast) = match literal(input_string.as_bytes()) {
IResult::Done(rest, v) => (rest, v),
IResult::Error(e) => panic!("Error in parsing: {}", e),
IResult::Incomplete(i) => panic!("Incomplete parse: {:?}", i),
};
assert_eq!(
Ast::Literal(Datatype::Number(40)),
ast
)
}
}
|
#![allow(dead_code)]
extern crate sha2;
extern crate hmac;
extern crate pbkdf2;
use hmac::Hmac;
use sha2::Sha256;
use pbkdf2::pbkdf2;
use std::ops::{Index, IndexMut, BitXorAssign};
#[inline(always)]
#[allow(non_snake_case)]
fn R(i: u32, r: u32) -> u32 {
i.rotate_left(r)
}
fn integerify(input: &[u8], n: u64) -> u64 {
assert!(input.len() >= 64);
let mut output = [0u8; 8];
output[..].copy_from_slice(&input[input.len() - 64.. input.len() - 56]);
unsafe {
u64::from_le(
::std::mem::transmute(output)
) & (n-1)
}
}
fn xor_to_slice(lhs: &[u8], rhs: &[u8], target: &mut [u8]) {
assert_eq!(lhs.len(), rhs.len());
assert_eq!(lhs.len(), target.len());
for ((l, r), t) in lhs.iter().cloned().zip(rhs.iter().cloned()).zip(target.iter_mut()) {
*t = l ^ r;
}
}
fn xor_slice(lhs: &mut [u8], rhs: &[u8]) {
assert_eq!(lhs.len(), rhs.len());
for (l, r) in lhs.iter_mut().zip(rhs.iter().cloned()) {
*l ^= r;
}
}
fn salsa_20_8_core(input: SalsaBlock) -> SalsaBlock {
let mut x = input.clone();
for _ in 0..4 {
x[4] ^= R( x[0].wrapping_add(x[12]), 7);
x[8] ^= R( x[4].wrapping_add(x[0] ), 9);
x[12] ^= R( x[8].wrapping_add(x[4] ), 13);
x[0] ^= R(x[12].wrapping_add(x[8] ), 18);
x[9] ^= R( x[5].wrapping_add(x[1] ), 7);
x[13] ^= R( x[9].wrapping_add(x[5] ), 9);
x[1] ^= R(x[13].wrapping_add(x[9] ), 13);
x[5] ^= R (x[1].wrapping_add(x[13]), 18);
x[14] ^= R(x[10].wrapping_add(x[6] ), 7);
x[2] ^= R(x[14].wrapping_add(x[10]), 9);
x[6] ^= R (x[2].wrapping_add(x[14]), 13);
x[10] ^= R (x[6].wrapping_add(x[2] ), 18);
x[3] ^= R(x[15].wrapping_add(x[11]), 7);
x[7] ^= R( x[3].wrapping_add(x[15]), 9);
x[11] ^= R( x[7].wrapping_add(x[3] ), 13);
x[15] ^= R(x[11].wrapping_add(x[7] ), 18);
x[1] ^= R( x[0].wrapping_add(x[3] ), 7);
x[2] ^= R( x[1].wrapping_add(x[0] ), 9);
x[3] ^= R( x[2].wrapping_add(x[1] ), 13);
x[0] ^= R( x[3].wrapping_add(x[2] ), 18);
x[6] ^= R( x[5].wrapping_add(x[4] ), 7);
x[7] ^= R( x[6].wrapping_add(x[5] ), 9);
x[4] ^= R( x[7].wrapping_add(x[6] ), 13);
x[5] ^= R( x[4].wrapping_add(x[7] ), 18);
x[11] ^= R(x[10].wrapping_add(x[9] ), 7);
x[8] ^= R(x[11].wrapping_add(x[10]), 9);
x[9] ^= R( x[8].wrapping_add(x[11]), 13);
x[10] ^= R( x[9].wrapping_add(x[8] ), 18);
x[12] ^= R(x[15].wrapping_add(x[14]), 7);
x[13] ^= R(x[12].wrapping_add(x[15]), 9);
x[14] ^= R(x[13].wrapping_add(x[12]), 13);
x[15] ^= R(x[14].wrapping_add(x[13]), 18);
}
for (x, i) in x.iter_mut().zip(input.iter().cloned()) {
*x = x.wrapping_add(i);
}
x
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct SalsaBlock([u32; 16]);
impl SalsaBlock {
pub fn as_bytes(&self) -> &[u8; 64] {
unsafe { &*(&self.0 as *const [u32; 16] as *const [u8; 64]) }
}
pub fn as_bytes_mut(&mut self) -> &mut [u8; 64] {
unsafe {&mut *(&mut self.0 as *mut [u32; 16] as *mut [u8; 64])}
}
fn xor_byte_slice(&mut self, sl: &[u8]) {
assert_eq!(sl.len(), 64);
for (l, r) in self.as_bytes_mut().iter_mut().zip(sl.iter().cloned()) {
*l ^= r;
}
}
pub fn salsa(self) -> Self {
salsa_20_8_core(self)
}
pub fn iter(&self) -> ::std::slice::Iter<u32> {
self.0.iter()
}
pub fn iter_mut(&mut self) -> ::std::slice::IterMut<u32> {
self.0.iter_mut()
}
pub fn from_bytes(src: [u8; 64]) -> Self {
SalsaBlock(
unsafe{::std::mem::transmute(src)}
)
}
pub fn from_words(src: [u32; 16]) -> Self {
SalsaBlock(src)
}
}
impl Index<usize> for SalsaBlock {
type Output = u32;
#[inline]
fn index(&self, index: usize) -> &Self::Output {
&self.0[index]
}
}
impl IndexMut<usize> for SalsaBlock {
#[inline]
fn index_mut(&mut self, index: usize) -> &mut u32 {
&mut self.0[index]
}
}
impl BitXorAssign for SalsaBlock {
fn bitxor_assign(&mut self, rhs: Self) {
for t in 0..16 {
self[t] ^= rhs[t]
}
}
}
struct ScryptBlockMixer<'a> {
state: SalsaBlock,
source: &'a [u8],
}
impl<'a> ScryptBlockMixer<'a> {
fn from_slice<'c>(src: &'c [u8]) -> ScryptBlockMixer<'c> {
assert!(src.len() > 0, "Input length must be non-zero");
assert_eq!(src.len() % 64, 0, "Input length must be a multiple of 64");
let mut state = [0u8; 64];
state.copy_from_slice(src.chunks(64).last().unwrap());
let state = SalsaBlock::from_bytes(state);
ScryptBlockMixer{state, source: src}
}
}
impl<'a> Iterator for ScryptBlockMixer<'a> {
type Item = SalsaBlock;
fn next(&mut self) -> Option<Self::Item> {
if self.source.is_empty() {return None}
let (next, source) = self.source.split_at(64);
self.source = source;
self.state.xor_byte_slice(next);
self.state = self.state.clone().salsa();
Some(self.state.clone())
}
}
fn scrypt_block_mix(input: &[u8]) -> Vec<u8> {
let mut output = vec![0; input.len()];
let s = ScryptBlockMixer::from_slice(input);
for (o, b) in output.chunks_mut(64).zip(s) {
o.copy_from_slice(b.as_bytes());
}
output
}
fn scrypt_romix(input: &[u8], p: usize) -> Vec<u8> {
assert!(p > 0);
assert!(p.is_power_of_two());
assert!(input.len() > 0);
assert!(input.len() % 128 == 0);
let mut x = input.to_owned();
let mut v: Vec<u8> = vec![0; input.len() * p];
let mut t: Vec<u8> = vec![0; x.len()];
let n = p as u64;
for c in v.chunks_mut(x.len()) {
c.copy_from_slice(&x);
x = scrypt_block_mix(&x);
}
for _ in 0..p {
let j = integerify(&x, n);
let low = (j * x.len() as u64) as usize;
let high = ((j+1) * x.len() as u64) as usize;
xor_to_slice(&mut x, &v[low..high], &mut t);
x = scrypt_block_mix(&t);
}
x
}
pub fn scrypt<P, S>(pass: P, salt: S, n: usize, r: usize, p: usize, output_len: usize, ) -> Vec<u8>
where P: AsRef<[u8]>, S: AsRef<[u8]> {
let mut b = vec![0u8; 128 * p * r];
pbkdf2::<Hmac<Sha256>>(pass.as_ref(), salt.as_ref(), 1, &mut b);
for chunk in b.chunks_mut(128 * r) {
let c_owned = chunk.to_owned();
chunk.copy_from_slice(&scrypt_romix(&c_owned, n));
}
let mut output = vec![0; output_len];
pbkdf2::<Hmac<Sha256>>(pass.as_ref(), &b, 1, &mut output);
output
}
#[cfg(test)]
mod tests {
static SALSA_20_INPUT_TEST_VECTOR: [u8; 64] = [
0x7e, 0x87, 0x9a, 0x21, 0x4f, 0x3e, 0xc9, 0x86,
0x7c, 0xa9, 0x40, 0xe6, 0x41, 0x71, 0x8f, 0x26,
0xba, 0xee, 0x55, 0x5b, 0x8c, 0x61, 0xc1, 0xb5,
0x0d, 0xf8, 0x46, 0x11, 0x6d, 0xcd, 0x3b, 0x1d,
0xee, 0x24, 0xf3, 0x19, 0xdf, 0x9b, 0x3d, 0x85,
0x14, 0x12, 0x1e, 0x4b, 0x5a, 0xc5, 0xaa, 0x32,
0x76, 0x02, 0x1d, 0x29, 0x09, 0xc7, 0x48, 0x29,
0xed, 0xeb, 0xc6, 0x8d, 0xb8, 0xb8, 0xc2, 0x5e,
];
static SALSA_20_OUTPUT_TEST_VECTOR: [u8; 64] = [
0xa4, 0x1f, 0x85, 0x9c, 0x66, 0x08, 0xcc, 0x99,
0x3b, 0x81, 0xca, 0xcb, 0x02, 0x0c, 0xef, 0x05,
0x04, 0x4b, 0x21, 0x81, 0xa2, 0xfd, 0x33, 0x7d,
0xfd, 0x7b, 0x1c, 0x63, 0x96, 0x68, 0x2f, 0x29,
0xb4, 0x39, 0x31, 0x68, 0xe3, 0xc9, 0xe6, 0xbc,
0xfe, 0x6b, 0xc5, 0xb7, 0xa0, 0x6d, 0x96, 0xba,
0xe4, 0x24, 0xcc, 0x10, 0x2c, 0x91, 0x74, 0x5c,
0x24, 0xad, 0x67, 0x3d, 0xc7, 0x61, 0x8f, 0x81,
];
#[test]
fn salsa_20_8_core_test_vector() {
use super::*;
let s_20_input = SalsaBlock::from_bytes(SALSA_20_INPUT_TEST_VECTOR);
let s_20_output = SalsaBlock::from_bytes(SALSA_20_OUTPUT_TEST_VECTOR);
assert_eq!(salsa_20_8_core(s_20_input), s_20_output);
}
static BLOCK_MIX_INPUT_TEST_VECTOR: [u8; 128] = [
0xf7, 0xce, 0x0b, 0x65, 0x3d, 0x2d, 0x72, 0xa4,
0x10, 0x8c, 0xf5, 0xab, 0xe9, 0x12, 0xff, 0xdd,
0x77, 0x76, 0x16, 0xdb, 0xbb, 0x27, 0xa7, 0x0e,
0x82, 0x04, 0xf3, 0xae, 0x2d, 0x0f, 0x6f, 0xad,
0x89, 0xf6, 0x8f, 0x48, 0x11, 0xd1, 0xe8, 0x7b,
0xcc, 0x3b, 0xd7, 0x40, 0x0a, 0x9f, 0xfd, 0x29,
0x09, 0x4f, 0x01, 0x84, 0x63, 0x95, 0x74, 0xf3,
0x9a, 0xe5, 0xa1, 0x31, 0x52, 0x17, 0xbc, 0xd7,
0x89, 0x49, 0x91, 0x44, 0x72, 0x13, 0xbb, 0x22,
0x6c, 0x25, 0xb5, 0x4d, 0xa8, 0x63, 0x70, 0xfb,
0xcd, 0x98, 0x43, 0x80, 0x37, 0x46, 0x66, 0xbb,
0x8f, 0xfc, 0xb5, 0xbf, 0x40, 0xc2, 0x54, 0xb0,
0x67, 0xd2, 0x7c, 0x51, 0xce, 0x4a, 0xd5, 0xfe,
0xd8, 0x29, 0xc9, 0x0b, 0x50, 0x5a, 0x57, 0x1b,
0x7f, 0x4d, 0x1c, 0xad, 0x6a, 0x52, 0x3c, 0xda,
0x77, 0x0e, 0x67, 0xbc, 0xea, 0xaf, 0x7e, 0x89,
];
static BLOCK_MIX_OUTPUT_TEST_VECTOR: [u8; 128] = [
0xa4, 0x1f, 0x85, 0x9c, 0x66, 0x08, 0xcc, 0x99,
0x3b, 0x81, 0xca, 0xcb, 0x02, 0x0c, 0xef, 0x05,
0x04, 0x4b, 0x21, 0x81, 0xa2, 0xfd, 0x33, 0x7d,
0xfd, 0x7b, 0x1c, 0x63, 0x96, 0x68, 0x2f, 0x29,
0xb4, 0x39, 0x31, 0x68, 0xe3, 0xc9, 0xe6, 0xbc,
0xfe, 0x6b, 0xc5, 0xb7, 0xa0, 0x6d, 0x96, 0xba,
0xe4, 0x24, 0xcc, 0x10, 0x2c, 0x91, 0x74, 0x5c,
0x24, 0xad, 0x67, 0x3d, 0xc7, 0x61, 0x8f, 0x81,
0x20, 0xed, 0xc9, 0x75, 0x32, 0x38, 0x81, 0xa8,
0x05, 0x40, 0xf6, 0x4c, 0x16, 0x2d, 0xcd, 0x3c,
0x21, 0x07, 0x7c, 0xfe, 0x5f, 0x8d, 0x5f, 0xe2,
0xb1, 0xa4, 0x16, 0x8f, 0x95, 0x36, 0x78, 0xb7,
0x7d, 0x3b, 0x3d, 0x80, 0x3b, 0x60, 0xe4, 0xab,
0x92, 0x09, 0x96, 0xe5, 0x9b, 0x4d, 0x53, 0xb6,
0x5d, 0x2a, 0x22, 0x58, 0x77, 0xd5, 0xed, 0xf5,
0x84, 0x2c, 0xb9, 0xf1, 0x4e, 0xef, 0xe4, 0x25,
];
#[test]
fn block_mix_test_vector() {
use super::*;
let b = BLOCK_MIX_INPUT_TEST_VECTOR[..].to_owned();
let z = BLOCK_MIX_OUTPUT_TEST_VECTOR[..].to_owned();
assert_eq!(scrypt_block_mix(&b), z);
}
static SCRYPT_ROMIX_INPUT_TEST_VECTOR: [u8; 128] = [
0xf7, 0xce, 0x0b, 0x65, 0x3d, 0x2d, 0x72, 0xa4,
0x10, 0x8c, 0xf5, 0xab, 0xe9, 0x12, 0xff, 0xdd,
0x77, 0x76, 0x16, 0xdb, 0xbb, 0x27, 0xa7, 0x0e,
0x82, 0x04, 0xf3, 0xae, 0x2d, 0x0f, 0x6f, 0xad,
0x89, 0xf6, 0x8f, 0x48, 0x11, 0xd1, 0xe8, 0x7b,
0xcc, 0x3b, 0xd7, 0x40, 0x0a, 0x9f, 0xfd, 0x29,
0x09, 0x4f, 0x01, 0x84, 0x63, 0x95, 0x74, 0xf3,
0x9a, 0xe5, 0xa1, 0x31, 0x52, 0x17, 0xbc, 0xd7,
0x89, 0x49, 0x91, 0x44, 0x72, 0x13, 0xbb, 0x22,
0x6c, 0x25, 0xb5, 0x4d, 0xa8, 0x63, 0x70, 0xfb,
0xcd, 0x98, 0x43, 0x80, 0x37, 0x46, 0x66, 0xbb,
0x8f, 0xfc, 0xb5, 0xbf, 0x40, 0xc2, 0x54, 0xb0,
0x67, 0xd2, 0x7c, 0x51, 0xce, 0x4a, 0xd5, 0xfe,
0xd8, 0x29, 0xc9, 0x0b, 0x50, 0x5a, 0x57, 0x1b,
0x7f, 0x4d, 0x1c, 0xad, 0x6a, 0x52, 0x3c, 0xda,
0x77, 0x0e, 0x67, 0xbc, 0xea, 0xaf, 0x7e, 0x89,
];
static SCRIPT_ROMIX_OUTPUT_TEST_VECTOR: [u8; 128] = [
0x79, 0xcc, 0xc1, 0x93, 0x62, 0x9d, 0xeb, 0xca,
0x04, 0x7f, 0x0b, 0x70, 0x60, 0x4b, 0xf6, 0xb6,
0x2c, 0xe3, 0xdd, 0x4a, 0x96, 0x26, 0xe3, 0x55,
0xfa, 0xfc, 0x61, 0x98, 0xe6, 0xea, 0x2b, 0x46,
0xd5, 0x84, 0x13, 0x67, 0x3b, 0x99, 0xb0, 0x29,
0xd6, 0x65, 0xc3, 0x57, 0x60, 0x1f, 0xb4, 0x26,
0xa0, 0xb2, 0xf4, 0xbb, 0xa2, 0x00, 0xee, 0x9f,
0x0a, 0x43, 0xd1, 0x9b, 0x57, 0x1a, 0x9c, 0x71,
0xef, 0x11, 0x42, 0xe6, 0x5d, 0x5a, 0x26, 0x6f,
0xdd, 0xca, 0x83, 0x2c, 0xe5, 0x9f, 0xaa, 0x7c,
0xac, 0x0b, 0x9c, 0xf1, 0xbe, 0x2b, 0xff, 0xca,
0x30, 0x0d, 0x01, 0xee, 0x38, 0x76, 0x19, 0xc4,
0xae, 0x12, 0xfd, 0x44, 0x38, 0xf2, 0x03, 0xa0,
0xe4, 0xe1, 0xc4, 0x7e, 0xc3, 0x14, 0x86, 0x1f,
0x4e, 0x90, 0x87, 0xcb, 0x33, 0x39, 0x6a, 0x68,
0x73, 0xe8, 0xf9, 0xd2, 0x53, 0x9a, 0x4b, 0x8e,
];
#[test]
fn scrypt_romix_test_vector() {
use super::*;
let input = SCRYPT_ROMIX_INPUT_TEST_VECTOR[..].to_owned();
let output = SCRIPT_ROMIX_OUTPUT_TEST_VECTOR[..].to_owned();
assert_eq!(scrypt_romix(&input, 16), output);
}
static SCRYPT_TEST_VECTOR_0: [u8; 64] = [
0x77, 0xd6, 0x57, 0x62, 0x38, 0x65, 0x7b, 0x20,
0x3b, 0x19, 0xca, 0x42, 0xc1, 0x8a, 0x04, 0x97,
0xf1, 0x6b, 0x48, 0x44, 0xe3, 0x07, 0x4a, 0xe8,
0xdf, 0xdf, 0xfa, 0x3f, 0xed, 0xe2, 0x14, 0x42,
0xfc, 0xd0, 0x06, 0x9d, 0xed, 0x09, 0x48, 0xf8,
0x32, 0x6a, 0x75, 0x3a, 0x0f, 0xc8, 0x1f, 0x17,
0xe8, 0xd3, 0xe0, 0xfb, 0x2e, 0x0d, 0x36, 0x28,
0xcf, 0x35, 0xe2, 0x0c, 0x38, 0xd1, 0x89, 0x06,
];
static SCRYPT_TEST_VECTOR_1: [u8; 64] = [
0xfd, 0xba, 0xbe, 0x1c, 0x9d, 0x34, 0x72, 0x00,
0x78, 0x56, 0xe7, 0x19, 0x0d, 0x01, 0xe9, 0xfe,
0x7c, 0x6a, 0xd7, 0xcb, 0xc8, 0x23, 0x78, 0x30,
0xe7, 0x73, 0x76, 0x63, 0x4b, 0x37, 0x31, 0x62,
0x2e, 0xaf, 0x30, 0xd9, 0x2e, 0x22, 0xa3, 0x88,
0x6f, 0xf1, 0x09, 0x27, 0x9d, 0x98, 0x30, 0xda,
0xc7, 0x27, 0xaf, 0xb9, 0x4a, 0x83, 0xee, 0x6d,
0x83, 0x60, 0xcb, 0xdf, 0xa2, 0xcc, 0x06, 0x40,
];
static SCRYPT_TEST_VECTOR_2: [u8; 64] = [
0x70, 0x23, 0xbd, 0xcb, 0x3a, 0xfd, 0x73, 0x48,
0x46, 0x1c, 0x06, 0xcd, 0x81, 0xfd, 0x38, 0xeb,
0xfd, 0xa8, 0xfb, 0xba, 0x90, 0x4f, 0x8e, 0x3e,
0xa9, 0xb5, 0x43, 0xf6, 0x54, 0x5d, 0xa1, 0xf2,
0xd5, 0x43, 0x29, 0x55, 0x61, 0x3f, 0x0f, 0xcf,
0x62, 0xd4, 0x97, 0x05, 0x24, 0x2a, 0x9a, 0xf9,
0xe6, 0x1e, 0x85, 0xdc, 0x0d, 0x65, 0x1e, 0x40,
0xdf, 0xcf, 0x01, 0x7b, 0x45, 0x57, 0x58, 0x87,
];
static SCRYPT_TEST_VECTOR_3: [u8; 64] = [
0x21, 0x01, 0xcb, 0x9b, 0x6a, 0x51, 0x1a, 0xae,
0xad, 0xdb, 0xbe, 0x09, 0xcf, 0x70, 0xf8, 0x81,
0xec, 0x56, 0x8d, 0x57, 0x4a, 0x2f, 0xfd, 0x4d,
0xab, 0xe5, 0xee, 0x98, 0x20, 0xad, 0xaa, 0x47,
0x8e, 0x56, 0xfd, 0x8f, 0x4b, 0xa5, 0xd0, 0x9f,
0xfa, 0x1c, 0x6d, 0x92, 0x7c, 0x40, 0xf4, 0xc3,
0x37, 0x30, 0x40, 0x49, 0xe8, 0xa9, 0x52, 0xfb,
0xcb, 0xf4, 0x5c, 0x6f, 0xa7, 0x7a, 0x41, 0xa4,
];
#[test]
fn scrypt_test_vector_0() {
use super::*;
assert_eq!(scrypt("", "", 16, 1, 1, 64), SCRYPT_TEST_VECTOR_0[..].to_owned());
}
#[test]
fn scrypt_test_vector_1() {
use super::*;
assert_eq!(scrypt("password", "NaCl", 1024, 8, 16, 64), SCRYPT_TEST_VECTOR_1[..].to_owned());
}
#[test]
fn scrypt_test_vector_2() {
use super::*;
assert_eq!(scrypt("pleaseletmein", "SodiumChloride", 16384, 8, 1, 64), SCRYPT_TEST_VECTOR_2[..].to_owned());
}
#[test]
fn scrypt_test_vector_3() {
use super::*;
assert_eq!(scrypt("pleaseletmein", "SodiumChloride", 1048576, 8, 1, 64), SCRYPT_TEST_VECTOR_3[..].to_owned());
}
}
|
#![allow(clippy::module_name_repetitions)]
/// [`InsertError`] types.
pub enum InsertError<K, V>
where
K: Clone + Ord + Send + Sync,
V: Clone + Send + Sync,
{
/// Duplicated: the same key is found.
Duplicated((K, V)),
/// Full: the tree, node, or leaf could not accommodate the entry.
Full((K, V)),
/// Retry: the target node, or leaf is being modified.
Retry((K, V)),
}
/// [`RemoveError`] types.
///
/// The boolean value tagged to the error code indicates that the target entry has been removed.
pub enum RemoveError {
/// Empty: the node is empty.
Empty(bool),
/// Retry: the target node, or leaf is being modified.
Retry(bool),
}
/// [`SearchError`] types.
pub enum SearchError {
/// Empty: the tree, node, or leaf is empty.
Empty,
/// Retry: the target node, or leaf is being modified.
Retry,
}
|
#![no_std]
mod from_primitive;
pub use from_primitive::FromPrimitive;
|
//! Colours
/// Helper macro to build static colour definitions
macro_rules! rgb16 {
($r:expr, $g:expr, $b:expr) => {
(($r & 0x1F) as u16) | ((($g & 0x1F) as u16) << 5) | ((($b & 0x1F) as u16) << 10)
};
}
/// 16-bit colour (5 bits per channel)
#[derive(Clone, Debug, PartialEq)]
pub struct Colour(u16);
impl Colour {
/// Maximum value for a colour
pub const MAX: u8 = 0x1F;
/// Create a new colour from 16-bit representation
pub fn new(v: u16) -> Colour {
Colour(v)
}
/// Create a new colour from individual channels
pub fn rgb(red: u8, green: u8, blue: u8) -> Colour {
Colour(rgb16!(red, green, blue))
}
/// Get this colour's 16-bit representation
pub fn u16(&self) -> u16 {
self.0
}
}
/// Helper colour: Red
pub const R: Colour = Colour(rgb16!(Colour::MAX, 0, 0));
/// Helper colour: Orange
pub const O: Colour = Colour(rgb16!(Colour::MAX, Colour::MAX / 2, 0));
/// Helper colour: Yellow
pub const Y: Colour = Colour(rgb16!(Colour::MAX, Colour::MAX, 0));
/// Helper colour: Green
pub const G: Colour = Colour(rgb16!(0, Colour::MAX, 0));
/// Helper colour: Blue
pub const B: Colour = Colour(rgb16!(0, 0, Colour::MAX));
/// Helper colour: Violet
pub const V: Colour = Colour(rgb16!(Colour::MAX / 2, 0, Colour::MAX));
/// Helper colour: White
pub const W: Colour = Colour(rgb16!(Colour::MAX, Colour::MAX, Colour::MAX));
/// Helper colour: Black
pub const BL: Colour = Colour(rgb16!(0, 0, 0));
|
use criterion::{criterion_group, criterion_main, Criterion};
use abin_benchmark::{
benchmark_test_set, run_benchmark, BenchStr, BytesBenchStr, SStrBenchStr, StdLibArcStrOnly,
StdLibOptimized, StdLibStringOnly, StrBenchStr,
};
fn perform<TBenchStr: BenchStr>() {
run_benchmark::<TBenchStr>(2, benchmark_test_set());
}
fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("Implementation: abin (SStr)", |b| {
b.iter(|| perform::<SStrBenchStr>())
});
c.bench_function("Implementation: abin (Str)", |b| {
b.iter(|| perform::<StrBenchStr>())
});
c.bench_function("Implementation: StdLibOptimized", |b| {
b.iter(|| perform::<StdLibOptimized>())
});
c.bench_function("Implementation: BytesBenchStr", |b| {
b.iter(|| perform::<BytesBenchStr>())
});
c.bench_function("Implementation: StdLibStringOnly", |b| {
b.iter(|| perform::<StdLibStringOnly>())
});
c.bench_function("Implementation: StdLibArcStrOnly", |b| {
b.iter(|| perform::<StdLibArcStrOnly>())
});
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);
|
#[allow(dead_code)]
fn read_line() -> String {
let mut line = String::new();
std::io::stdin().read_line(&mut line).unwrap();
line.trim_end().to_owned()
}
struct Piece {
x: i64,
y: i64,
}
struct Op {
code: usize,
p: i64,
}
impl Op {
fn new(param: Vec<isize>) -> Op {
Op {
code: param[0] as usize,
p: if param.len() == 2 { param[1] as i64 } else { 0 },
}
}
}
type Matrix3 = Vec<Vec<i64>>;
fn matmul(m1: &Matrix3, m2: &Matrix3) -> Matrix3 {
vec![
vec![
m1[0][0] * m2[0][0] + m1[0][1] * m2[1][0] + m1[0][2] * m2[2][0],
m1[0][0] * m2[0][1] + m1[0][1] * m2[1][1] + m1[0][2] * m2[2][1],
m1[0][0] * m2[0][2] + m1[0][1] * m2[1][2] + m1[0][2] * m2[2][2],
],
vec![
m1[1][0] * m2[0][0] + m1[1][1] * m2[1][0] + m1[1][2] * m2[2][0],
m1[1][0] * m2[0][1] + m1[1][1] * m2[1][1] + m1[1][2] * m2[2][1],
m1[1][0] * m2[0][2] + m1[1][1] * m2[1][2] + m1[1][2] * m2[2][2],
],
vec![
m1[2][0] * m2[0][0] + m1[2][1] * m2[1][0] + m1[2][2] * m2[2][0],
m1[2][0] * m2[0][1] + m1[2][1] * m2[1][1] + m1[2][2] * m2[2][1],
m1[2][0] * m2[0][2] + m1[2][1] * m2[1][2] + m1[2][2] * m2[2][2],
],
]
}
fn unit_matrix3() -> Matrix3 {
vec![vec![1, 0, 0], vec![0, 1, 0], vec![0, 0, 1]]
}
fn main() {
let n = read_line().parse().unwrap();
let mut pieces: Vec<Piece> = Vec::new();
for _ in 0..n {
let stdin = read_line();
let mut iter = stdin.split_whitespace();
let x = iter.next().unwrap().parse().unwrap();
let y = iter.next().unwrap().parse().unwrap();
pieces.push(Piece { x: x, y: y });
}
let m = read_line().parse().unwrap();
let mut ops: Vec<Op> = Vec::new();
for _ in 0..m {
let op = read_line()
.split_whitespace()
.map(|v| v.parse().unwrap())
.collect();
ops.push(Op::new(op));
}
let solver = Solver::new(pieces, ops);
let q = read_line().parse().unwrap();
for _ in 0..q {
let stdin = read_line();
let mut iter = stdin.split_whitespace();
let a = iter.next().unwrap().parse().unwrap();
let b = iter.next().unwrap().parse().unwrap();
let (x, y) = solver.query(a, b);
println!("{} {}", x, y);
}
}
struct Solver {
pieces: Vec<Piece>,
matrixes: Vec<Matrix3>,
}
impl Solver {
fn new(pieces: Vec<Piece>, ops: Vec<Op>) -> Solver {
let mut muls: Vec<Matrix3> = vec![unit_matrix3()];
for op in ops {
let m1 = match op.code {
1 => vec![vec![0, 1, 0], vec![-1, 0, 0], vec![0, 0, 1]],
2 => vec![vec![0, -1, 0], vec![1, 0, 0], vec![0, 0, 1]],
3 => vec![vec![-1, 0, 2 * op.p], vec![0, 1, 0], vec![0, 0, 1]],
_ => vec![vec![1, 0, 0], vec![0, -1, 2 * op.p], vec![0, 0, 1]],
};
let m2 = muls.last().unwrap();
let mul = matmul(&m1, m2);
muls.push(mul);
}
Solver {
pieces: pieces,
matrixes: muls,
}
}
fn query(&self, a: usize, b: usize) -> (i64, i64) {
let p = &self.pieces[b - 1];
let m = &self.matrixes[a];
(
m[0][0] * p.x + m[0][1] * p.y + m[0][2],
m[1][0] * p.x + m[1][1] * p.y + m[1][2],
)
}
}
|
use std::fmt::{self, Write};
use std::iter::IntoIterator;
use std::vec::IntoIter;
pub struct BindCount(usize);
impl BindCount {
pub fn new() -> Self {
Self(1)
}
fn next(&mut self) -> usize {
let count = self.0;
self.0 += 1;
count
}
pub fn count(&self) -> usize {
self.0
}
pub fn write_sql<W: Write>(&mut self, f: &mut W) -> fmt::Result {
write!(f, "${}", self.next())
}
}
pub trait CollectBinds {
fn collect_binds(&self, binds: &mut BindsInternal);
}
#[derive(Debug)]
pub struct BindsInternal {
vec: Vec<Bind>,
}
impl BindsInternal {
pub fn with_capacity(capacity: usize) -> Self {
Self {
vec: Vec::with_capacity(capacity),
}
}
pub fn push(&mut self, bind: Bind) {
self.vec.push(bind);
}
}
#[derive(Debug)]
pub struct Binds {
iter: IntoIter<Bind>,
}
impl Iterator for Binds {
type Item = Bind;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
impl From<BindsInternal> for Binds {
fn from(internal: BindsInternal) -> Self {
Binds {
iter: internal.vec.into_iter(),
}
}
}
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
pub enum Bind {
String(String),
I32(i32),
U64(u64),
}
|
// Added as part the code review and testing
// by ChainSafe Systems Aug 2021
use super::*;
use mock::*;
use pallet_balances::PositiveImbalance;
use pallet_staking::EraPayout;
use crate::inflation::{InflationFixedParams, IdealInterestPoint};
use frame_support::{assert_noop, assert_ok};
use sp_runtime::{
Perbill,
traits::BadOrigin,
};
// set_inflation_params
#[test]
fn set_inflation_params_called_by_non_admin_fails() {
ExtBuilder::default()
.build_and_execute(|| {
assert_noop!(
XXEconomics::set_inflation_params(Origin::signed(1), Default::default()),
BadOrigin
);
})
}
#[test]
fn set_inflation_params_called_by_admin() {
ExtBuilder::default()
.build_and_execute(|| {
let test_params = InflationFixedParams {
min_inflation: Perbill::from_float(0.1),
..Default::default()
};
assert_ok!(
XXEconomics::set_inflation_params(Origin::signed(AdminAccount::get()), test_params.clone())
);
assert_eq!(
XXEconomics::inflation_params(),
test_params
);
assert_eq!(
xx_economics_events(),
vec![RawEvent::InflationParamsChanged]
);
});
}
// set_interest_points
#[test]
fn set_interest_points_called_by_non_admin_fails() {
ExtBuilder::default()
.build_and_execute(|| {
assert_noop!(
XXEconomics::set_interest_points(Origin::signed(1), Default::default()),
BadOrigin
);
})
}
#[test]
fn set_interest_points_called_by_admin() {
ExtBuilder::default()
.build_and_execute(|| {
let test_points = vec![
IdealInterestPoint::<BlockNumber> {
block: 99,
..Default::default()
}
];
assert_ok!(
XXEconomics::set_interest_points(Origin::signed(AdminAccount::get()), test_points.clone())
);
assert_eq!(
XXEconomics::interest_points(),
test_points
);
assert_eq!(
xx_economics_events(),
vec![RawEvent::InterestPointsChanged]
);
});
}
// set_liquidity_rewards_stake
#[test]
fn set_liquidity_rewards_stake_called_by_non_admin_fails() {
ExtBuilder::default()
.build_and_execute(|| {
assert_noop!(
XXEconomics::set_liquidity_rewards_stake(Origin::signed(1), Default::default()),
BadOrigin
);
})
}
#[test]
fn set_liquidity_rewards_stake_called_by_admin() {
ExtBuilder::default()
.build_and_execute(|| {
let test_stake = 555;
assert_ok!(
XXEconomics::set_liquidity_rewards_stake(Origin::signed(AdminAccount::get()), test_stake.clone())
);
assert_eq!(
XXEconomics::ideal_stake_rewards(),
test_stake
);
assert_eq!(
xx_economics_events(),
vec![RawEvent::IdealLiquidityStakeChanged]
);
});
}
// set_liquidity_rewards_balance
#[test]
fn set_liquidity_rewards_balance_called_by_non_admin_fails() {
ExtBuilder::default()
.build_and_execute(|| {
assert_noop!(
XXEconomics::set_liquidity_rewards_balance(Origin::signed(1), Default::default()),
BadOrigin
);
})
}
#[test]
fn set_liquidity_rewards_balance_called_by_admin() {
ExtBuilder::default()
.build_and_execute(|| {
let test_balance = 123;
assert_ok!(
XXEconomics::set_liquidity_rewards_balance(Origin::signed(AdminAccount::get()), test_balance.clone())
);
assert_eq!(
XXEconomics::liquidity_rewards(),
test_balance
);
assert_eq!(
xx_economics_events(),
vec![RawEvent::LiquidityRewardsBalanceChanged]
);
});
}
// rewards
#[test]
fn takes_rewards_from_pool_when_possible() {
let initial_rewards_balance = 10000;
let issuance = 1000;
ExtBuilder::default()
.with_rewards_balance(initial_rewards_balance)
.build_and_execute(|| {
let initial_issuance = Balances::total_issuance();
// 1000 coins were issued as validator rewards
let imbalance = PositiveImbalance::<Test>::new(issuance);
XXEconomics::on_nonzero_unbalanced(imbalance);
// these should all be deducted form rewards balance
assert_eq!(XXEconomics::rewards_balance(), initial_rewards_balance - issuance);
// no further issuance
assert_eq!(Balances::total_issuance(), initial_issuance);
assert_eq!(
xx_economics_events(),
vec![
RawEvent::RewardFromPool(issuance)
]
)
});
}
#[test]
fn will_issue_when_pool_depleted() {
let initial_rewards_balance = 0;
let issuance = 1000;
ExtBuilder::default()
.with_rewards_balance(initial_rewards_balance)
.build_and_execute(|| {
let initial_issuance = Balances::total_issuance();
// 1000 coins were issued as validator rewards
let imbalance = PositiveImbalance::<Test>::new(issuance);
XXEconomics::on_nonzero_unbalanced(imbalance);
// some taken from rewards balance
assert_eq!(XXEconomics::rewards_balance(), 0);
// remainder issued
assert_eq!(Balances::total_issuance(), initial_issuance + issuance);
assert_eq!(
xx_economics_events(),
vec![
RawEvent::RewardMinted(issuance)
]
)
});
}
#[test]
fn will_split_pool_and_issuance_when_required() {
let initial_rewards_balance = 300;
let issuance = 1000;
ExtBuilder::default()
.with_rewards_balance(initial_rewards_balance)
.build_and_execute(|| {
let initial_issuance = Balances::total_issuance();
// 1000 coins were issued as validator rewards
let imbalance = PositiveImbalance::<Test>::new(issuance);
XXEconomics::on_nonzero_unbalanced(imbalance);
// some taken from rewards balance
assert_eq!(XXEconomics::rewards_balance(), 0);
// remainder issued
assert_eq!(Balances::total_issuance(), initial_issuance + (issuance - initial_rewards_balance));
assert_eq!(
xx_economics_events(),
vec![
RawEvent::RewardFromPool(initial_rewards_balance),
RawEvent::RewardMinted(issuance - initial_rewards_balance)
]
)
});
}
#[test]
fn noop_on_zero_imbalance() {
let initial_rewards_balance = 100;
let issuance = 0;
ExtBuilder::default()
.with_rewards_balance(initial_rewards_balance)
.build_and_execute(|| {
let initial_issuance = Balances::total_issuance();
// 1000 coins were issued as validator rewards
let imbalance = PositiveImbalance::<Test>::new(issuance);
XXEconomics::on_nonzero_unbalanced(imbalance);
// no change
assert_eq!(XXEconomics::rewards_balance(), initial_rewards_balance);
assert_eq!(Balances::total_issuance(), initial_issuance + issuance);
// no events
assert_eq!(
xx_economics_events(),
vec![]
)
});
}
// reward remainders
#[test]
fn reward_remainders_will_split_pool_and_issuance_when_required() {
let initial_rewards_balance = 300;
let reward_remainder = 1000;
ExtBuilder::default()
.with_rewards_balance(initial_rewards_balance)
.build_and_execute(|| {
let initial_issuance = Balances::total_issuance();
// 1000 tokens have alreay been minted, and the issuance updated
let imbalance = Balances::issue(reward_remainder);
// Send imbalance to treasury account
rewards::RewardRemainderAdapter::<Test>::on_nonzero_unbalanced(imbalance);
// some taken from rewards balance, emptying it
assert_eq!(XXEconomics::rewards_balance(), 0);
// remainder issued
assert_eq!(Balances::total_issuance(), initial_issuance + (reward_remainder - initial_rewards_balance));
// all ends up in treasury
assert_eq!(Balances::total_balance(MOCK_TREASURY), reward_remainder);
assert_eq!(
xx_economics_events(),
vec![
RawEvent::RewardFromPool(initial_rewards_balance),
RawEvent::RewardMinted(reward_remainder - initial_rewards_balance)
]
);
});
}
// era payout
fn test_interest_curve() -> Vec<IdealInterestPoint<BlockNumber>> {
vec![
IdealInterestPoint { block: 0, interest: Perbill::from_rational(1u32, 2u32) },
IdealInterestPoint { block: 10, interest: Perbill::from_rational(1u32, 4u32) }
]
}
#[test]
fn get_era_payout_at_block_lower_than_first_point() {
ExtBuilder::default()
.with_interest_points(
vec![
IdealInterestPoint { block: 5, interest: Perbill::from_rational(1u32, 4u32) },
IdealInterestPoint { block: 10, interest: Perbill::from_rational(1u32, 2u32) },
]
)
.build_and_execute(|| {
assert_eq!(XXEconomics::era_payout(0, 0, 0), (0, 0));
});
}
#[test]
fn get_era_payout_at_block_smaller_than_half_session() {
ExtBuilder::default()
.with_interest_points(test_interest_curve())
.build_and_execute(|| {
assert_eq!(XXEconomics::era_payout(0, 0, 0), (0, 0));
});
}
#[test]
fn get_era_payout_in_first_segment() {
ExtBuilder::default()
.with_interest_points(test_interest_curve())
.build_and_execute(|| {
run_to_block(5);
assert_eq!(XXEconomics::era_payout(0, 0, 0), (0, 0));
});
}
#[test]
fn get_era_payout_after_final_point() {
ExtBuilder::default()
.with_interest_points(test_interest_curve())
.build_and_execute(|| {
run_to_block(11);
assert_eq!(XXEconomics::era_payout(0, 0, 0), (0, 0));
});
}
#[test]
fn get_era_payout_with_increasing_interest() {
ExtBuilder::default()
.with_interest_points(
vec![
IdealInterestPoint { block: 0, interest: Perbill::from_rational(1u32, 4u32) },
IdealInterestPoint { block: 10, interest: Perbill::from_rational(1u32, 2u32) },
]
)
.build_and_execute(|| {
run_to_block(5);
assert_eq!(XXEconomics::era_payout(5000, 10000, MILLISECONDS_PER_YEAR), (1875, 0));
});
}
fn test_unordered_interest_curve() -> Vec<IdealInterestPoint<BlockNumber>> {
vec![
IdealInterestPoint { block: 10, interest: Perbill::from_rational(1u32, 4u32) },
IdealInterestPoint { block: 0, interest: Perbill::from_rational(1u32, 2u32) }
]
}
fn test_interest_curve_two() -> Vec<IdealInterestPoint<BlockNumber>> {
vec![
IdealInterestPoint { block: 0, interest: Perbill::from_rational(1u32, 2u32) },
IdealInterestPoint { block: 5, interest: Perbill::from_rational(1u32, 3u32) },
IdealInterestPoint { block: 10, interest: Perbill::from_rational(1u32, 4u32) }
]
}
fn test_unordered_interest_curve_two() -> Vec<IdealInterestPoint<BlockNumber>> {
vec![
IdealInterestPoint { block: 10, interest: Perbill::from_rational(1u32, 4u32) },
IdealInterestPoint { block: 0, interest: Perbill::from_rational(1u32, 2u32) },
IdealInterestPoint { block: 5, interest: Perbill::from_rational(1u32, 3u32) }
]
}
#[test]
fn confirm_unordered_points_get_sorted_at_genesis() {
ExtBuilder::default()
.with_interest_points(test_unordered_interest_curve())
.build_and_execute(|| {
assert_eq!(XXEconomics::interest_points(), test_interest_curve());
});
}
#[test]
fn confirm_unordered_points_get_sorted_when_set_by_admin() {
ExtBuilder::default()
.with_interest_points(test_interest_curve())
.build_and_execute(|| {
assert_ok!(
XXEconomics::set_interest_points(
Origin::signed(AdminAccount::get()),
test_unordered_interest_curve_two()
)
);
assert_eq!(XXEconomics::interest_points(), test_interest_curve_two());
assert_eq!(
xx_economics_events(),
vec![RawEvent::InterestPointsChanged]
);
});
}
|
#![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)]
RecoverableDatabases_Get(#[from] recoverable_databases::get::Error),
#[error(transparent)]
RecoverableDatabases_ListByServer(#[from] recoverable_databases::list_by_server::Error),
#[error(transparent)]
RestorableDroppedDatabases_Get(#[from] restorable_dropped_databases::get::Error),
#[error(transparent)]
RestorableDroppedDatabases_ListByServer(#[from] restorable_dropped_databases::list_by_server::Error),
#[error(transparent)]
ServerConnectionPolicies_Get(#[from] server_connection_policies::get::Error),
#[error(transparent)]
ServerConnectionPolicies_CreateOrUpdate(#[from] server_connection_policies::create_or_update::Error),
#[error(transparent)]
DatabaseThreatDetectionPolicies_Get(#[from] database_threat_detection_policies::get::Error),
#[error(transparent)]
DatabaseThreatDetectionPolicies_CreateOrUpdate(#[from] database_threat_detection_policies::create_or_update::Error),
#[error(transparent)]
DataMaskingPolicies_Get(#[from] data_masking_policies::get::Error),
#[error(transparent)]
DataMaskingPolicies_CreateOrUpdate(#[from] data_masking_policies::create_or_update::Error),
#[error(transparent)]
DataMaskingRules_CreateOrUpdate(#[from] data_masking_rules::create_or_update::Error),
#[error(transparent)]
DataMaskingRules_ListByDatabase(#[from] data_masking_rules::list_by_database::Error),
#[error(transparent)]
FirewallRules_Get(#[from] firewall_rules::get::Error),
#[error(transparent)]
FirewallRules_CreateOrUpdate(#[from] firewall_rules::create_or_update::Error),
#[error(transparent)]
FirewallRules_Delete(#[from] firewall_rules::delete::Error),
#[error(transparent)]
FirewallRules_ListByServer(#[from] firewall_rules::list_by_server::Error),
#[error(transparent)]
GeoBackupPolicies_Get(#[from] geo_backup_policies::get::Error),
#[error(transparent)]
GeoBackupPolicies_CreateOrUpdate(#[from] geo_backup_policies::create_or_update::Error),
#[error(transparent)]
GeoBackupPolicies_ListByDatabase(#[from] geo_backup_policies::list_by_database::Error),
#[error(transparent)]
Databases_ListMetrics(#[from] databases::list_metrics::Error),
#[error(transparent)]
Databases_ListMetricDefinitions(#[from] databases::list_metric_definitions::Error),
#[error(transparent)]
ElasticPools_ListMetrics(#[from] elastic_pools::list_metrics::Error),
#[error(transparent)]
ElasticPools_ListMetricDefinitions(#[from] elastic_pools::list_metric_definitions::Error),
#[error(transparent)]
RecommendedElasticPools_Get(#[from] recommended_elastic_pools::get::Error),
#[error(transparent)]
RecommendedElasticPools_ListByServer(#[from] recommended_elastic_pools::list_by_server::Error),
#[error(transparent)]
RecommendedElasticPools_ListMetrics(#[from] recommended_elastic_pools::list_metrics::Error),
#[error(transparent)]
ReplicationLinks_Get(#[from] replication_links::get::Error),
#[error(transparent)]
ReplicationLinks_Delete(#[from] replication_links::delete::Error),
#[error(transparent)]
ReplicationLinks_Failover(#[from] replication_links::failover::Error),
#[error(transparent)]
ReplicationLinks_FailoverAllowDataLoss(#[from] replication_links::failover_allow_data_loss::Error),
#[error(transparent)]
ReplicationLinks_Unlink(#[from] replication_links::unlink::Error),
#[error(transparent)]
ReplicationLinks_ListByDatabase(#[from] replication_links::list_by_database::Error),
#[error(transparent)]
ServerCommunicationLinks_Get(#[from] server_communication_links::get::Error),
#[error(transparent)]
ServerCommunicationLinks_CreateOrUpdate(#[from] server_communication_links::create_or_update::Error),
#[error(transparent)]
ServerCommunicationLinks_Delete(#[from] server_communication_links::delete::Error),
#[error(transparent)]
ServerCommunicationLinks_ListByServer(#[from] server_communication_links::list_by_server::Error),
#[error(transparent)]
ServiceObjectives_Get(#[from] service_objectives::get::Error),
#[error(transparent)]
ServiceObjectives_ListByServer(#[from] service_objectives::list_by_server::Error),
#[error(transparent)]
ElasticPoolActivities_ListByElasticPool(#[from] elastic_pool_activities::list_by_elastic_pool::Error),
#[error(transparent)]
ElasticPoolDatabaseActivities_ListByElasticPool(#[from] elastic_pool_database_activities::list_by_elastic_pool::Error),
#[error(transparent)]
ServiceTierAdvisors_Get(#[from] service_tier_advisors::get::Error),
#[error(transparent)]
ServiceTierAdvisors_ListByDatabase(#[from] service_tier_advisors::list_by_database::Error),
#[error(transparent)]
TransparentDataEncryptions_Get(#[from] transparent_data_encryptions::get::Error),
#[error(transparent)]
TransparentDataEncryptions_CreateOrUpdate(#[from] transparent_data_encryptions::create_or_update::Error),
#[error(transparent)]
TransparentDataEncryptionActivities_ListByConfiguration(#[from] transparent_data_encryption_activities::list_by_configuration::Error),
#[error(transparent)]
ServerUsages_ListByServer(#[from] server_usages::list_by_server::Error),
#[error(transparent)]
DatabaseUsages_ListByDatabase(#[from] database_usages::list_by_database::Error),
#[error(transparent)]
DatabaseAutomaticTuning_Get(#[from] database_automatic_tuning::get::Error),
#[error(transparent)]
DatabaseAutomaticTuning_Update(#[from] database_automatic_tuning::update::Error),
#[error(transparent)]
EncryptionProtectors_Revalidate(#[from] encryption_protectors::revalidate::Error),
#[error(transparent)]
EncryptionProtectors_ListByServer(#[from] encryption_protectors::list_by_server::Error),
#[error(transparent)]
EncryptionProtectors_Get(#[from] encryption_protectors::get::Error),
#[error(transparent)]
EncryptionProtectors_CreateOrUpdate(#[from] encryption_protectors::create_or_update::Error),
#[error(transparent)]
FailoverGroups_Get(#[from] failover_groups::get::Error),
#[error(transparent)]
FailoverGroups_CreateOrUpdate(#[from] failover_groups::create_or_update::Error),
#[error(transparent)]
FailoverGroups_Update(#[from] failover_groups::update::Error),
#[error(transparent)]
FailoverGroups_Delete(#[from] failover_groups::delete::Error),
#[error(transparent)]
FailoverGroups_ListByServer(#[from] failover_groups::list_by_server::Error),
#[error(transparent)]
FailoverGroups_Failover(#[from] failover_groups::failover::Error),
#[error(transparent)]
FailoverGroups_ForceFailoverAllowDataLoss(#[from] failover_groups::force_failover_allow_data_loss::Error),
#[error(transparent)]
Operations_List(#[from] operations::list::Error),
#[error(transparent)]
ServerKeys_ListByServer(#[from] server_keys::list_by_server::Error),
#[error(transparent)]
ServerKeys_Get(#[from] server_keys::get::Error),
#[error(transparent)]
ServerKeys_CreateOrUpdate(#[from] server_keys::create_or_update::Error),
#[error(transparent)]
ServerKeys_Delete(#[from] server_keys::delete::Error),
#[error(transparent)]
SyncAgents_Get(#[from] sync_agents::get::Error),
#[error(transparent)]
SyncAgents_CreateOrUpdate(#[from] sync_agents::create_or_update::Error),
#[error(transparent)]
SyncAgents_Delete(#[from] sync_agents::delete::Error),
#[error(transparent)]
SyncAgents_ListByServer(#[from] sync_agents::list_by_server::Error),
#[error(transparent)]
SyncAgents_GenerateKey(#[from] sync_agents::generate_key::Error),
#[error(transparent)]
SyncAgents_ListLinkedDatabases(#[from] sync_agents::list_linked_databases::Error),
#[error(transparent)]
SubscriptionUsages_ListByLocation(#[from] subscription_usages::list_by_location::Error),
#[error(transparent)]
SubscriptionUsages_Get(#[from] subscription_usages::get::Error),
#[error(transparent)]
VirtualClusters_List(#[from] virtual_clusters::list::Error),
#[error(transparent)]
VirtualClusters_ListByResourceGroup(#[from] virtual_clusters::list_by_resource_group::Error),
#[error(transparent)]
VirtualClusters_Get(#[from] virtual_clusters::get::Error),
#[error(transparent)]
VirtualClusters_Update(#[from] virtual_clusters::update::Error),
#[error(transparent)]
VirtualClusters_Delete(#[from] virtual_clusters::delete::Error),
#[error(transparent)]
VirtualNetworkRules_Get(#[from] virtual_network_rules::get::Error),
#[error(transparent)]
VirtualNetworkRules_CreateOrUpdate(#[from] virtual_network_rules::create_or_update::Error),
#[error(transparent)]
VirtualNetworkRules_Delete(#[from] virtual_network_rules::delete::Error),
#[error(transparent)]
VirtualNetworkRules_ListByServer(#[from] virtual_network_rules::list_by_server::Error),
#[error(transparent)]
ExtendedDatabaseBlobAuditingPolicies_Get(#[from] extended_database_blob_auditing_policies::get::Error),
#[error(transparent)]
ExtendedDatabaseBlobAuditingPolicies_CreateOrUpdate(#[from] extended_database_blob_auditing_policies::create_or_update::Error),
#[error(transparent)]
ExtendedDatabaseBlobAuditingPolicies_ListByDatabase(#[from] extended_database_blob_auditing_policies::list_by_database::Error),
#[error(transparent)]
ExtendedServerBlobAuditingPolicies_Get(#[from] extended_server_blob_auditing_policies::get::Error),
#[error(transparent)]
ExtendedServerBlobAuditingPolicies_CreateOrUpdate(#[from] extended_server_blob_auditing_policies::create_or_update::Error),
#[error(transparent)]
ExtendedServerBlobAuditingPolicies_ListByServer(#[from] extended_server_blob_auditing_policies::list_by_server::Error),
#[error(transparent)]
ServerBlobAuditingPolicies_Get(#[from] server_blob_auditing_policies::get::Error),
#[error(transparent)]
ServerBlobAuditingPolicies_CreateOrUpdate(#[from] server_blob_auditing_policies::create_or_update::Error),
#[error(transparent)]
ServerBlobAuditingPolicies_ListByServer(#[from] server_blob_auditing_policies::list_by_server::Error),
#[error(transparent)]
DatabaseBlobAuditingPolicies_Get(#[from] database_blob_auditing_policies::get::Error),
#[error(transparent)]
DatabaseBlobAuditingPolicies_CreateOrUpdate(#[from] database_blob_auditing_policies::create_or_update::Error),
#[error(transparent)]
DatabaseBlobAuditingPolicies_ListByDatabase(#[from] database_blob_auditing_policies::list_by_database::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessmentRuleBaselines_Get(#[from] database_vulnerability_assessment_rule_baselines::get::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessmentRuleBaselines_CreateOrUpdate(
#[from] database_vulnerability_assessment_rule_baselines::create_or_update::Error,
),
#[error(transparent)]
DatabaseVulnerabilityAssessmentRuleBaselines_Delete(#[from] database_vulnerability_assessment_rule_baselines::delete::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessments_Get(#[from] database_vulnerability_assessments::get::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessments_CreateOrUpdate(#[from] database_vulnerability_assessments::create_or_update::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessments_Delete(#[from] database_vulnerability_assessments::delete::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessments_ListByDatabase(#[from] database_vulnerability_assessments::list_by_database::Error),
#[error(transparent)]
JobAgents_ListByServer(#[from] job_agents::list_by_server::Error),
#[error(transparent)]
JobAgents_Get(#[from] job_agents::get::Error),
#[error(transparent)]
JobAgents_CreateOrUpdate(#[from] job_agents::create_or_update::Error),
#[error(transparent)]
JobAgents_Update(#[from] job_agents::update::Error),
#[error(transparent)]
JobAgents_Delete(#[from] job_agents::delete::Error),
#[error(transparent)]
JobCredentials_ListByAgent(#[from] job_credentials::list_by_agent::Error),
#[error(transparent)]
JobCredentials_Get(#[from] job_credentials::get::Error),
#[error(transparent)]
JobCredentials_CreateOrUpdate(#[from] job_credentials::create_or_update::Error),
#[error(transparent)]
JobCredentials_Delete(#[from] job_credentials::delete::Error),
#[error(transparent)]
JobExecutions_ListByAgent(#[from] job_executions::list_by_agent::Error),
#[error(transparent)]
JobExecutions_Cancel(#[from] job_executions::cancel::Error),
#[error(transparent)]
JobExecutions_Create(#[from] job_executions::create::Error),
#[error(transparent)]
JobExecutions_ListByJob(#[from] job_executions::list_by_job::Error),
#[error(transparent)]
JobExecutions_Get(#[from] job_executions::get::Error),
#[error(transparent)]
JobExecutions_CreateOrUpdate(#[from] job_executions::create_or_update::Error),
#[error(transparent)]
Jobs_ListByAgent(#[from] jobs::list_by_agent::Error),
#[error(transparent)]
Jobs_Get(#[from] jobs::get::Error),
#[error(transparent)]
Jobs_CreateOrUpdate(#[from] jobs::create_or_update::Error),
#[error(transparent)]
Jobs_Delete(#[from] jobs::delete::Error),
#[error(transparent)]
JobStepExecutions_ListByJobExecution(#[from] job_step_executions::list_by_job_execution::Error),
#[error(transparent)]
JobStepExecutions_Get(#[from] job_step_executions::get::Error),
#[error(transparent)]
JobSteps_ListByVersion(#[from] job_steps::list_by_version::Error),
#[error(transparent)]
JobSteps_GetByVersion(#[from] job_steps::get_by_version::Error),
#[error(transparent)]
JobSteps_ListByJob(#[from] job_steps::list_by_job::Error),
#[error(transparent)]
JobSteps_Get(#[from] job_steps::get::Error),
#[error(transparent)]
JobSteps_CreateOrUpdate(#[from] job_steps::create_or_update::Error),
#[error(transparent)]
JobSteps_Delete(#[from] job_steps::delete::Error),
#[error(transparent)]
JobTargetExecutions_ListByJobExecution(#[from] job_target_executions::list_by_job_execution::Error),
#[error(transparent)]
JobTargetExecutions_ListByStep(#[from] job_target_executions::list_by_step::Error),
#[error(transparent)]
JobTargetExecutions_Get(#[from] job_target_executions::get::Error),
#[error(transparent)]
JobTargetGroups_ListByAgent(#[from] job_target_groups::list_by_agent::Error),
#[error(transparent)]
JobTargetGroups_Get(#[from] job_target_groups::get::Error),
#[error(transparent)]
JobTargetGroups_CreateOrUpdate(#[from] job_target_groups::create_or_update::Error),
#[error(transparent)]
JobTargetGroups_Delete(#[from] job_target_groups::delete::Error),
#[error(transparent)]
JobVersions_ListByJob(#[from] job_versions::list_by_job::Error),
#[error(transparent)]
JobVersions_Get(#[from] job_versions::get::Error),
#[error(transparent)]
ManagedBackupShortTermRetentionPolicies_Get(#[from] managed_backup_short_term_retention_policies::get::Error),
#[error(transparent)]
ManagedBackupShortTermRetentionPolicies_CreateOrUpdate(#[from] managed_backup_short_term_retention_policies::create_or_update::Error),
#[error(transparent)]
ManagedBackupShortTermRetentionPolicies_Update(#[from] managed_backup_short_term_retention_policies::update::Error),
#[error(transparent)]
ManagedBackupShortTermRetentionPolicies_ListByDatabase(#[from] managed_backup_short_term_retention_policies::list_by_database::Error),
#[error(transparent)]
ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies_Get(
#[from] managed_restorable_dropped_database_backup_short_term_retention_policies::get::Error,
),
#[error(transparent)]
ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies_CreateOrUpdate(
#[from] managed_restorable_dropped_database_backup_short_term_retention_policies::create_or_update::Error,
),
#[error(transparent)]
ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies_Update(
#[from] managed_restorable_dropped_database_backup_short_term_retention_policies::update::Error,
),
#[error(transparent)]
ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies_ListByRestorableDroppedDatabase(
#[from] managed_restorable_dropped_database_backup_short_term_retention_policies::list_by_restorable_dropped_database::Error,
),
#[error(transparent)]
ServerAutomaticTuning_Get(#[from] server_automatic_tuning::get::Error),
#[error(transparent)]
ServerAutomaticTuning_Update(#[from] server_automatic_tuning::update::Error),
#[error(transparent)]
ServerDnsAliases_Get(#[from] server_dns_aliases::get::Error),
#[error(transparent)]
ServerDnsAliases_CreateOrUpdate(#[from] server_dns_aliases::create_or_update::Error),
#[error(transparent)]
ServerDnsAliases_Delete(#[from] server_dns_aliases::delete::Error),
#[error(transparent)]
ServerDnsAliases_ListByServer(#[from] server_dns_aliases::list_by_server::Error),
#[error(transparent)]
ServerDnsAliases_Acquire(#[from] server_dns_aliases::acquire::Error),
#[error(transparent)]
ServerSecurityAlertPolicies_Get(#[from] server_security_alert_policies::get::Error),
#[error(transparent)]
ServerSecurityAlertPolicies_CreateOrUpdate(#[from] server_security_alert_policies::create_or_update::Error),
#[error(transparent)]
ServerSecurityAlertPolicies_ListByServer(#[from] server_security_alert_policies::list_by_server::Error),
#[error(transparent)]
RestorableDroppedManagedDatabases_ListByInstance(#[from] restorable_dropped_managed_databases::list_by_instance::Error),
#[error(transparent)]
RestorableDroppedManagedDatabases_Get(#[from] restorable_dropped_managed_databases::get::Error),
#[error(transparent)]
RestorePoints_ListByDatabase(#[from] restore_points::list_by_database::Error),
#[error(transparent)]
RestorePoints_Create(#[from] restore_points::create::Error),
#[error(transparent)]
RestorePoints_Get(#[from] restore_points::get::Error),
#[error(transparent)]
RestorePoints_Delete(#[from] restore_points::delete::Error),
#[error(transparent)]
ManagedDatabaseSecurityAlertPolicies_Get(#[from] managed_database_security_alert_policies::get::Error),
#[error(transparent)]
ManagedDatabaseSecurityAlertPolicies_CreateOrUpdate(#[from] managed_database_security_alert_policies::create_or_update::Error),
#[error(transparent)]
ManagedDatabaseSecurityAlertPolicies_ListByDatabase(#[from] managed_database_security_alert_policies::list_by_database::Error),
#[error(transparent)]
ManagedServerSecurityAlertPolicies_Get(#[from] managed_server_security_alert_policies::get::Error),
#[error(transparent)]
ManagedServerSecurityAlertPolicies_CreateOrUpdate(#[from] managed_server_security_alert_policies::create_or_update::Error),
#[error(transparent)]
ManagedServerSecurityAlertPolicies_ListByInstance(#[from] managed_server_security_alert_policies::list_by_instance::Error),
#[error(transparent)]
SensitivityLabels_ListCurrentByDatabase(#[from] sensitivity_labels::list_current_by_database::Error),
#[error(transparent)]
SensitivityLabels_ListRecommendedByDatabase(#[from] sensitivity_labels::list_recommended_by_database::Error),
#[error(transparent)]
SensitivityLabels_EnableRecommendation(#[from] sensitivity_labels::enable_recommendation::Error),
#[error(transparent)]
SensitivityLabels_DisableRecommendation(#[from] sensitivity_labels::disable_recommendation::Error),
#[error(transparent)]
SensitivityLabels_Get(#[from] sensitivity_labels::get::Error),
#[error(transparent)]
SensitivityLabels_CreateOrUpdate(#[from] sensitivity_labels::create_or_update::Error),
#[error(transparent)]
SensitivityLabels_Delete(#[from] sensitivity_labels::delete::Error),
#[error(transparent)]
ManagedInstanceAdministrators_ListByInstance(#[from] managed_instance_administrators::list_by_instance::Error),
#[error(transparent)]
ManagedInstanceAdministrators_Get(#[from] managed_instance_administrators::get::Error),
#[error(transparent)]
ManagedInstanceAdministrators_CreateOrUpdate(#[from] managed_instance_administrators::create_or_update::Error),
#[error(transparent)]
ManagedInstanceAdministrators_Delete(#[from] managed_instance_administrators::delete::Error),
#[error(transparent)]
DatabaseOperations_Cancel(#[from] database_operations::cancel::Error),
#[error(transparent)]
DatabaseOperations_ListByDatabase(#[from] database_operations::list_by_database::Error),
#[error(transparent)]
ElasticPoolOperations_Cancel(#[from] elastic_pool_operations::cancel::Error),
#[error(transparent)]
ElasticPoolOperations_ListByElasticPool(#[from] elastic_pool_operations::list_by_elastic_pool::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessmentScans_ListByDatabase(#[from] database_vulnerability_assessment_scans::list_by_database::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessmentScans_Get(#[from] database_vulnerability_assessment_scans::get::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessmentScans_InitiateScan(#[from] database_vulnerability_assessment_scans::initiate_scan::Error),
#[error(transparent)]
DatabaseVulnerabilityAssessmentScans_Export(#[from] database_vulnerability_assessment_scans::export::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentRuleBaselines_Get(#[from] managed_database_vulnerability_assessment_rule_baselines::get::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentRuleBaselines_CreateOrUpdate(
#[from] managed_database_vulnerability_assessment_rule_baselines::create_or_update::Error,
),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentRuleBaselines_Delete(
#[from] managed_database_vulnerability_assessment_rule_baselines::delete::Error,
),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentScans_ListByDatabase(
#[from] managed_database_vulnerability_assessment_scans::list_by_database::Error,
),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentScans_Get(#[from] managed_database_vulnerability_assessment_scans::get::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentScans_InitiateScan(#[from] managed_database_vulnerability_assessment_scans::initiate_scan::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessmentScans_Export(#[from] managed_database_vulnerability_assessment_scans::export::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessments_Get(#[from] managed_database_vulnerability_assessments::get::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessments_CreateOrUpdate(#[from] managed_database_vulnerability_assessments::create_or_update::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessments_Delete(#[from] managed_database_vulnerability_assessments::delete::Error),
#[error(transparent)]
ManagedDatabaseVulnerabilityAssessments_ListByDatabase(#[from] managed_database_vulnerability_assessments::list_by_database::Error),
#[error(transparent)]
InstanceFailoverGroups_Get(#[from] instance_failover_groups::get::Error),
#[error(transparent)]
InstanceFailoverGroups_CreateOrUpdate(#[from] instance_failover_groups::create_or_update::Error),
#[error(transparent)]
InstanceFailoverGroups_Delete(#[from] instance_failover_groups::delete::Error),
#[error(transparent)]
InstanceFailoverGroups_ListByLocation(#[from] instance_failover_groups::list_by_location::Error),
#[error(transparent)]
InstanceFailoverGroups_Failover(#[from] instance_failover_groups::failover::Error),
#[error(transparent)]
InstanceFailoverGroups_ForceFailoverAllowDataLoss(#[from] instance_failover_groups::force_failover_allow_data_loss::Error),
#[error(transparent)]
TdeCertificates_Create(#[from] tde_certificates::create::Error),
#[error(transparent)]
ManagedInstanceTdeCertificates_Create(#[from] managed_instance_tde_certificates::create::Error),
#[error(transparent)]
ManagedInstanceKeys_ListByInstance(#[from] managed_instance_keys::list_by_instance::Error),
#[error(transparent)]
ManagedInstanceKeys_Get(#[from] managed_instance_keys::get::Error),
#[error(transparent)]
ManagedInstanceKeys_CreateOrUpdate(#[from] managed_instance_keys::create_or_update::Error),
#[error(transparent)]
ManagedInstanceKeys_Delete(#[from] managed_instance_keys::delete::Error),
#[error(transparent)]
ManagedInstanceEncryptionProtectors_Revalidate(#[from] managed_instance_encryption_protectors::revalidate::Error),
#[error(transparent)]
ManagedInstanceEncryptionProtectors_ListByInstance(#[from] managed_instance_encryption_protectors::list_by_instance::Error),
#[error(transparent)]
ManagedInstanceEncryptionProtectors_Get(#[from] managed_instance_encryption_protectors::get::Error),
#[error(transparent)]
ManagedInstanceEncryptionProtectors_CreateOrUpdate(#[from] managed_instance_encryption_protectors::create_or_update::Error),
#[error(transparent)]
RecoverableManagedDatabases_ListByInstance(#[from] recoverable_managed_databases::list_by_instance::Error),
#[error(transparent)]
RecoverableManagedDatabases_Get(#[from] recoverable_managed_databases::get::Error),
#[error(transparent)]
BackupShortTermRetentionPolicies_Get(#[from] backup_short_term_retention_policies::get::Error),
#[error(transparent)]
BackupShortTermRetentionPolicies_CreateOrUpdate(#[from] backup_short_term_retention_policies::create_or_update::Error),
#[error(transparent)]
BackupShortTermRetentionPolicies_Update(#[from] backup_short_term_retention_policies::update::Error),
#[error(transparent)]
BackupShortTermRetentionPolicies_ListByDatabase(#[from] backup_short_term_retention_policies::list_by_database::Error),
#[error(transparent)]
ManagedInstanceVulnerabilityAssessments_Get(#[from] managed_instance_vulnerability_assessments::get::Error),
#[error(transparent)]
ManagedInstanceVulnerabilityAssessments_CreateOrUpdate(#[from] managed_instance_vulnerability_assessments::create_or_update::Error),
#[error(transparent)]
ManagedInstanceVulnerabilityAssessments_Delete(#[from] managed_instance_vulnerability_assessments::delete::Error),
#[error(transparent)]
ManagedInstanceVulnerabilityAssessments_ListByInstance(#[from] managed_instance_vulnerability_assessments::list_by_instance::Error),
#[error(transparent)]
ServerVulnerabilityAssessments_Get(#[from] server_vulnerability_assessments::get::Error),
#[error(transparent)]
ServerVulnerabilityAssessments_CreateOrUpdate(#[from] server_vulnerability_assessments::create_or_update::Error),
#[error(transparent)]
ServerVulnerabilityAssessments_Delete(#[from] server_vulnerability_assessments::delete::Error),
#[error(transparent)]
ServerVulnerabilityAssessments_ListByServer(#[from] server_vulnerability_assessments::list_by_server::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_Get(#[from] managed_database_sensitivity_labels::get::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_CreateOrUpdate(#[from] managed_database_sensitivity_labels::create_or_update::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_Delete(#[from] managed_database_sensitivity_labels::delete::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_DisableRecommendation(#[from] managed_database_sensitivity_labels::disable_recommendation::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_EnableRecommendation(#[from] managed_database_sensitivity_labels::enable_recommendation::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_ListCurrentByDatabase(#[from] managed_database_sensitivity_labels::list_current_by_database::Error),
#[error(transparent)]
ManagedDatabaseSensitivityLabels_ListRecommendedByDatabase(
#[from] managed_database_sensitivity_labels::list_recommended_by_database::Error,
),
#[error(transparent)]
InstancePools_Get(#[from] instance_pools::get::Error),
#[error(transparent)]
InstancePools_CreateOrUpdate(#[from] instance_pools::create_or_update::Error),
#[error(transparent)]
InstancePools_Update(#[from] instance_pools::update::Error),
#[error(transparent)]
InstancePools_Delete(#[from] instance_pools::delete::Error),
#[error(transparent)]
InstancePools_ListByResourceGroup(#[from] instance_pools::list_by_resource_group::Error),
#[error(transparent)]
InstancePools_List(#[from] instance_pools::list::Error),
#[error(transparent)]
Usages_ListByInstancePool(#[from] usages::list_by_instance_pool::Error),
#[error(transparent)]
PrivateLinkResources_ListByServer(#[from] private_link_resources::list_by_server::Error),
#[error(transparent)]
PrivateLinkResources_Get(#[from] private_link_resources::get::Error),
#[error(transparent)]
Servers_ListByResourceGroup(#[from] servers::list_by_resource_group::Error),
#[error(transparent)]
Servers_Get(#[from] servers::get::Error),
#[error(transparent)]
Servers_CreateOrUpdate(#[from] servers::create_or_update::Error),
#[error(transparent)]
Servers_Update(#[from] servers::update::Error),
#[error(transparent)]
Servers_Delete(#[from] servers::delete::Error),
#[error(transparent)]
Servers_List(#[from] servers::list::Error),
#[error(transparent)]
Servers_CheckNameAvailability(#[from] servers::check_name_availability::Error),
#[error(transparent)]
Capabilities_ListByLocation(#[from] capabilities::list_by_location::Error),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_Get(#[from] long_term_retention_managed_instance_backups::get::Error),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_Delete(#[from] long_term_retention_managed_instance_backups::delete::Error),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_ListByDatabase(#[from] long_term_retention_managed_instance_backups::list_by_database::Error),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_ListByInstance(#[from] long_term_retention_managed_instance_backups::list_by_instance::Error),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_ListByLocation(#[from] long_term_retention_managed_instance_backups::list_by_location::Error),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_GetByResourceGroup(
#[from] long_term_retention_managed_instance_backups::get_by_resource_group::Error,
),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_DeleteByResourceGroup(
#[from] long_term_retention_managed_instance_backups::delete_by_resource_group::Error,
),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_ListByResourceGroupDatabase(
#[from] long_term_retention_managed_instance_backups::list_by_resource_group_database::Error,
),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_ListByResourceGroupInstance(
#[from] long_term_retention_managed_instance_backups::list_by_resource_group_instance::Error,
),
#[error(transparent)]
LongTermRetentionManagedInstanceBackups_ListByResourceGroupLocation(
#[from] long_term_retention_managed_instance_backups::list_by_resource_group_location::Error,
),
#[error(transparent)]
ManagedInstanceLongTermRetentionPolicies_Get(#[from] managed_instance_long_term_retention_policies::get::Error),
#[error(transparent)]
ManagedInstanceLongTermRetentionPolicies_CreateOrUpdate(#[from] managed_instance_long_term_retention_policies::create_or_update::Error),
#[error(transparent)]
ManagedInstanceLongTermRetentionPolicies_ListByDatabase(#[from] managed_instance_long_term_retention_policies::list_by_database::Error),
#[error(transparent)]
WorkloadGroups_Get(#[from] workload_groups::get::Error),
#[error(transparent)]
WorkloadGroups_CreateOrUpdate(#[from] workload_groups::create_or_update::Error),
#[error(transparent)]
WorkloadGroups_Delete(#[from] workload_groups::delete::Error),
#[error(transparent)]
WorkloadGroups_ListByDatabase(#[from] workload_groups::list_by_database::Error),
#[error(transparent)]
WorkloadClassifiers_Get(#[from] workload_classifiers::get::Error),
#[error(transparent)]
WorkloadClassifiers_CreateOrUpdate(#[from] workload_classifiers::create_or_update::Error),
#[error(transparent)]
WorkloadClassifiers_Delete(#[from] workload_classifiers::delete::Error),
#[error(transparent)]
WorkloadClassifiers_ListByWorkloadGroup(#[from] workload_classifiers::list_by_workload_group::Error),
#[error(transparent)]
ManagedInstanceOperations_Cancel(#[from] managed_instance_operations::cancel::Error),
#[error(transparent)]
ManagedInstanceOperations_ListByManagedInstance(#[from] managed_instance_operations::list_by_managed_instance::Error),
#[error(transparent)]
ManagedInstanceOperations_Get(#[from] managed_instance_operations::get::Error),
#[error(transparent)]
ServerAzureAdAdministrators_Get(#[from] server_azure_ad_administrators::get::Error),
#[error(transparent)]
ServerAzureAdAdministrators_CreateOrUpdate(#[from] server_azure_ad_administrators::create_or_update::Error),
#[error(transparent)]
ServerAzureAdAdministrators_Delete(#[from] server_azure_ad_administrators::delete::Error),
#[error(transparent)]
ServerAzureAdAdministrators_ListByServer(#[from] server_azure_ad_administrators::list_by_server::Error),
#[error(transparent)]
SyncGroups_ListSyncDatabaseIds(#[from] sync_groups::list_sync_database_ids::Error),
#[error(transparent)]
SyncGroups_RefreshHubSchema(#[from] sync_groups::refresh_hub_schema::Error),
#[error(transparent)]
SyncGroups_ListHubSchemas(#[from] sync_groups::list_hub_schemas::Error),
#[error(transparent)]
SyncGroups_ListLogs(#[from] sync_groups::list_logs::Error),
#[error(transparent)]
SyncGroups_CancelSync(#[from] sync_groups::cancel_sync::Error),
#[error(transparent)]
SyncGroups_TriggerSync(#[from] sync_groups::trigger_sync::Error),
#[error(transparent)]
SyncGroups_Get(#[from] sync_groups::get::Error),
#[error(transparent)]
SyncGroups_CreateOrUpdate(#[from] sync_groups::create_or_update::Error),
#[error(transparent)]
SyncGroups_Update(#[from] sync_groups::update::Error),
#[error(transparent)]
SyncGroups_Delete(#[from] sync_groups::delete::Error),
#[error(transparent)]
SyncGroups_ListByDatabase(#[from] sync_groups::list_by_database::Error),
#[error(transparent)]
SyncMembers_Get(#[from] sync_members::get::Error),
#[error(transparent)]
SyncMembers_CreateOrUpdate(#[from] sync_members::create_or_update::Error),
#[error(transparent)]
SyncMembers_Update(#[from] sync_members::update::Error),
#[error(transparent)]
SyncMembers_Delete(#[from] sync_members::delete::Error),
#[error(transparent)]
SyncMembers_ListBySyncGroup(#[from] sync_members::list_by_sync_group::Error),
#[error(transparent)]
SyncMembers_ListMemberSchemas(#[from] sync_members::list_member_schemas::Error),
#[error(transparent)]
SyncMembers_RefreshMemberSchema(#[from] sync_members::refresh_member_schema::Error),
#[error(transparent)]
Databases_Export(#[from] databases::export::Error),
#[error(transparent)]
ImportExport_Import(#[from] import_export::import::Error),
#[error(transparent)]
Servers_ImportDatabase(#[from] servers::import_database::Error),
#[error(transparent)]
ManagedDatabases_ListByInstance(#[from] managed_databases::list_by_instance::Error),
#[error(transparent)]
ManagedDatabases_Get(#[from] managed_databases::get::Error),
#[error(transparent)]
ManagedDatabases_CreateOrUpdate(#[from] managed_databases::create_or_update::Error),
#[error(transparent)]
ManagedDatabases_Update(#[from] managed_databases::update::Error),
#[error(transparent)]
ManagedDatabases_Delete(#[from] managed_databases::delete::Error),
#[error(transparent)]
ManagedDatabases_CompleteRestore(#[from] managed_databases::complete_restore::Error),
#[error(transparent)]
ManagedDatabases_ListInaccessibleByInstance(#[from] managed_databases::list_inaccessible_by_instance::Error),
#[error(transparent)]
ManagedDatabaseRestoreDetails_Get(#[from] managed_database_restore_details::get::Error),
#[error(transparent)]
ServerAzureAdOnlyAuthentications_Get(#[from] server_azure_ad_only_authentications::get::Error),
#[error(transparent)]
ServerAzureAdOnlyAuthentications_CreateOrUpdate(#[from] server_azure_ad_only_authentications::create_or_update::Error),
#[error(transparent)]
ServerAzureAdOnlyAuthentications_Delete(#[from] server_azure_ad_only_authentications::delete::Error),
#[error(transparent)]
ServerAzureAdOnlyAuthentications_ListByServer(#[from] server_azure_ad_only_authentications::list_by_server::Error),
#[error(transparent)]
ManagedInstances_ListByInstancePool(#[from] managed_instances::list_by_instance_pool::Error),
#[error(transparent)]
ManagedInstances_ListByResourceGroup(#[from] managed_instances::list_by_resource_group::Error),
#[error(transparent)]
ManagedInstances_Get(#[from] managed_instances::get::Error),
#[error(transparent)]
ManagedInstances_CreateOrUpdate(#[from] managed_instances::create_or_update::Error),
#[error(transparent)]
ManagedInstances_Update(#[from] managed_instances::update::Error),
#[error(transparent)]
ManagedInstances_Delete(#[from] managed_instances::delete::Error),
#[error(transparent)]
ManagedInstances_ListByManagedInstance(#[from] managed_instances::list_by_managed_instance::Error),
#[error(transparent)]
ManagedInstances_Failover(#[from] managed_instances::failover::Error),
#[error(transparent)]
ManagedInstances_List(#[from] managed_instances::list::Error),
#[error(transparent)]
ManagedInstanceAzureAdOnlyAuthentications_Get(#[from] managed_instance_azure_ad_only_authentications::get::Error),
#[error(transparent)]
ManagedInstanceAzureAdOnlyAuthentications_CreateOrUpdate(
#[from] managed_instance_azure_ad_only_authentications::create_or_update::Error,
),
#[error(transparent)]
ManagedInstanceAzureAdOnlyAuthentications_Delete(#[from] managed_instance_azure_ad_only_authentications::delete::Error),
#[error(transparent)]
ManagedInstanceAzureAdOnlyAuthentications_ListByInstance(
#[from] managed_instance_azure_ad_only_authentications::list_by_instance::Error,
),
#[error(transparent)]
ServerTrustGroups_Get(#[from] server_trust_groups::get::Error),
#[error(transparent)]
ServerTrustGroups_CreateOrUpdate(#[from] server_trust_groups::create_or_update::Error),
#[error(transparent)]
ServerTrustGroups_Delete(#[from] server_trust_groups::delete::Error),
#[error(transparent)]
ServerTrustGroups_ListByLocation(#[from] server_trust_groups::list_by_location::Error),
#[error(transparent)]
ServerTrustGroups_ListByInstance(#[from] server_trust_groups::list_by_instance::Error),
#[error(transparent)]
ElasticPools_ListByServer(#[from] elastic_pools::list_by_server::Error),
#[error(transparent)]
ElasticPools_Get(#[from] elastic_pools::get::Error),
#[error(transparent)]
ElasticPools_CreateOrUpdate(#[from] elastic_pools::create_or_update::Error),
#[error(transparent)]
ElasticPools_Update(#[from] elastic_pools::update::Error),
#[error(transparent)]
ElasticPools_Delete(#[from] elastic_pools::delete::Error),
#[error(transparent)]
ElasticPools_Failover(#[from] elastic_pools::failover::Error),
#[error(transparent)]
ServerDevOpsAuditSettings_Get(#[from] server_dev_ops_audit_settings::get::Error),
#[error(transparent)]
ServerDevOpsAuditSettings_CreateOrUpdate(#[from] server_dev_ops_audit_settings::create_or_update::Error),
#[error(transparent)]
ServerDevOpsAuditSettings_ListByServer(#[from] server_dev_ops_audit_settings::list_by_server::Error),
#[error(transparent)]
Databases_ListByServer(#[from] databases::list_by_server::Error),
#[error(transparent)]
Databases_Get(#[from] databases::get::Error),
#[error(transparent)]
Databases_CreateOrUpdate(#[from] databases::create_or_update::Error),
#[error(transparent)]
Databases_Update(#[from] databases::update::Error),
#[error(transparent)]
Databases_Delete(#[from] databases::delete::Error),
#[error(transparent)]
Databases_ListByElasticPool(#[from] databases::list_by_elastic_pool::Error),
#[error(transparent)]
Databases_Pause(#[from] databases::pause::Error),
#[error(transparent)]
Databases_Resume(#[from] databases::resume::Error),
#[error(transparent)]
Databases_Failover(#[from] databases::failover::Error),
#[error(transparent)]
Databases_ListInaccessibleByServer(#[from] databases::list_inaccessible_by_server::Error),
#[error(transparent)]
Databases_UpgradeDataWarehouse(#[from] databases::upgrade_data_warehouse::Error),
#[error(transparent)]
Databases_Rename(#[from] databases::rename::Error),
#[error(transparent)]
LongTermRetentionBackups_Copy(#[from] long_term_retention_backups::copy::Error),
#[error(transparent)]
LongTermRetentionBackups_Update(#[from] long_term_retention_backups::update::Error),
#[error(transparent)]
LongTermRetentionBackups_Get(#[from] long_term_retention_backups::get::Error),
#[error(transparent)]
LongTermRetentionBackups_Delete(#[from] long_term_retention_backups::delete::Error),
#[error(transparent)]
LongTermRetentionBackups_ListByDatabase(#[from] long_term_retention_backups::list_by_database::Error),
#[error(transparent)]
LongTermRetentionBackups_ListByLocation(#[from] long_term_retention_backups::list_by_location::Error),
#[error(transparent)]
LongTermRetentionBackups_ListByServer(#[from] long_term_retention_backups::list_by_server::Error),
#[error(transparent)]
LongTermRetentionBackups_CopyByResourceGroup(#[from] long_term_retention_backups::copy_by_resource_group::Error),
#[error(transparent)]
LongTermRetentionBackups_UpdateByResourceGroup(#[from] long_term_retention_backups::update_by_resource_group::Error),
#[error(transparent)]
LongTermRetentionBackups_GetByResourceGroup(#[from] long_term_retention_backups::get_by_resource_group::Error),
#[error(transparent)]
LongTermRetentionBackups_DeleteByResourceGroup(#[from] long_term_retention_backups::delete_by_resource_group::Error),
#[error(transparent)]
LongTermRetentionBackups_ListByResourceGroupDatabase(#[from] long_term_retention_backups::list_by_resource_group_database::Error),
#[error(transparent)]
LongTermRetentionBackups_ListByResourceGroupLocation(#[from] long_term_retention_backups::list_by_resource_group_location::Error),
#[error(transparent)]
LongTermRetentionBackups_ListByResourceGroupServer(#[from] long_term_retention_backups::list_by_resource_group_server::Error),
#[error(transparent)]
LongTermRetentionPolicies_Get(#[from] long_term_retention_policies::get::Error),
#[error(transparent)]
LongTermRetentionPolicies_CreateOrUpdate(#[from] long_term_retention_policies::create_or_update::Error),
#[error(transparent)]
LongTermRetentionPolicies_ListByDatabase(#[from] long_term_retention_policies::list_by_database::Error),
#[error(transparent)]
PrivateEndpointConnections_Get(#[from] private_endpoint_connections::get::Error),
#[error(transparent)]
PrivateEndpointConnections_CreateOrUpdate(#[from] private_endpoint_connections::create_or_update::Error),
#[error(transparent)]
PrivateEndpointConnections_Delete(#[from] private_endpoint_connections::delete::Error),
#[error(transparent)]
PrivateEndpointConnections_ListByServer(#[from] private_endpoint_connections::list_by_server::Error),
}
pub mod recoverable_databases {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
) -> std::result::Result<models::RecoverableDatabase, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/recoverableDatabases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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::RecoverableDatabase =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::RecoverableDatabaseListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/recoverableDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RecoverableDatabaseListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 restorable_dropped_databases {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
restorable_droppeded_database_id: &str,
) -> std::result::Result<models::RestorableDroppedDatabase, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/restorableDroppedDatabases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
restorable_droppeded_database_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::RestorableDroppedDatabase =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::RestorableDroppedDatabaseListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/restorableDroppedDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestorableDroppedDatabaseListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 server_connection_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
connection_policy_name: &str,
) -> std::result::Result<models::ServerConnectionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/connectionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
connection_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::ServerConnectionPolicy =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
connection_policy_name: &str,
parameters: &models::ServerConnectionPolicy,
) -> 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.Sql/servers/{}/connectionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
connection_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(parameters).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::ServerConnectionPolicy = 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::ServerConnectionPolicy = 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();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerConnectionPolicy),
Created201(models::ServerConnectionPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 database_threat_detection_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
security_alert_policy_name: &str,
) -> std::result::Result<models::DatabaseSecurityAlertPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
security_alert_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::DatabaseSecurityAlertPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
server_name: &str,
database_name: &str,
security_alert_policy_name: &str,
parameters: &models::DatabaseSecurityAlertPolicy,
) -> 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.Sql/servers/{}/databases/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
security_alert_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(parameters).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::DatabaseSecurityAlertPolicy = 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::DatabaseSecurityAlertPolicy = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DatabaseSecurityAlertPolicy),
Created201(models::DatabaseSecurityAlertPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 data_masking_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
data_masking_policy_name: &str,
) -> std::result::Result<models::DataMaskingPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/dataMaskingPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
data_masking_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::DataMaskingPolicy =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
database_name: &str,
data_masking_policy_name: &str,
parameters: &models::DataMaskingPolicy,
) -> std::result::Result<models::DataMaskingPolicy, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/dataMaskingPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
data_masking_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(parameters).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::DataMaskingPolicy = 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();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 data_masking_rules {
use super::{models, API_VERSION};
pub async fn create_or_update(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
data_masking_policy_name: &str,
data_masking_rule_name: &str,
parameters: &models::DataMaskingRule,
) -> 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.Sql/servers/{}/databases/{}/dataMaskingPolicies/{}/rules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
data_masking_policy_name,
data_masking_rule_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(parameters).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::DataMaskingRule = 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::DataMaskingRule = 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();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DataMaskingRule),
Created201(models::DataMaskingRule),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_database(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
data_masking_policy_name: &str,
) -> std::result::Result<models::DataMaskingRuleListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/dataMaskingPolicies/{}/rules",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
data_masking_policy_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DataMaskingRuleListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_database::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 firewall_rules {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
firewall_rule_name: &str,
) -> std::result::Result<models::FirewallRule, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/firewallRules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
firewall_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::FirewallRule =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
firewall_rule_name: &str,
parameters: &models::FirewallRule,
) -> 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.Sql/servers/{}/firewallRules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
firewall_rule_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(parameters).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::FirewallRule = 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::FirewallRule = 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();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::FirewallRule),
Created201(models::FirewallRule),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
firewall_rule_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/firewallRules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
firewall_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::OK => Ok(delete::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::FirewallRuleListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/firewallRules",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FirewallRuleListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 geo_backup_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
geo_backup_policy_name: &str,
) -> std::result::Result<models::GeoBackupPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/geoBackupPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
geo_backup_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::GeoBackupPolicy =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
database_name: &str,
geo_backup_policy_name: &str,
parameters: &models::GeoBackupPolicy,
) -> 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.Sql/servers/{}/databases/{}/geoBackupPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
geo_backup_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(parameters).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::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::GeoBackupPolicy = 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))
}
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::GeoBackupPolicy = 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))
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Created201(models::GeoBackupPolicy),
Ok200(models::GeoBackupPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_database(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
) -> std::result::Result<models::GeoBackupPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/geoBackupPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::GeoBackupPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_database::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 databases {
use super::{models, API_VERSION};
pub async fn list_metrics(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
filter: &str,
) -> std::result::Result<models::MetricListResult, list_metrics::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/metrics",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_metrics::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_metrics::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("$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_metrics::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metrics::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MetricListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_metrics::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metrics::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metrics {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_metric_definitions(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
) -> std::result::Result<models::MetricDefinitionListResult, list_metric_definitions::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/metricDefinitions",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_metric_definitions::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_metric_definitions::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_metric_definitions::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metric_definitions::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MetricDefinitionListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_metric_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metric_definitions::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metric_definitions {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 export(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::ExportDatabaseDefinition,
subscription_id: &str,
) -> std::result::Result<export::Response, export::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/export",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(export::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(export::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(parameters).map_err(export::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(export::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(export::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ImportExportOperationResult =
serde_json::from_slice(rsp_body).map_err(|source| export::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(export::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(export::Response::Accepted202),
status_code => Err(export::Error::DefaultResponse { status_code }),
}
}
pub mod export {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ImportExportOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::Database, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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::Database =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::Database,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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(parameters).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::Database = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::Database = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Database),
Accepted202,
Created201(models::Database),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::DatabaseUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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(parameters).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::Database =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Database),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_elastic_pool(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseListResult, list_by_elastic_pool::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/databases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_elastic_pool::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_elastic_pool::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_elastic_pool::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_elastic_pool::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_elastic_pool::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_elastic_pool::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_elastic_pool {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 pause(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<pause::Response, pause::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/pause",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(pause::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(pause::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(pause::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(pause::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Database =
serde_json::from_slice(rsp_body).map_err(|source| pause::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(pause::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(pause::Response::Accepted202),
status_code => Err(pause::Error::DefaultResponse { status_code }),
}
}
pub mod pause {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Database),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 resume(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<resume::Response, resume::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/resume",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(resume::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(resume::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(resume::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(resume::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Database =
serde_json::from_slice(rsp_body).map_err(|source| resume::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(resume::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(resume::Response::Accepted202),
status_code => Err(resume::Error::DefaultResponse { status_code }),
}
}
pub mod resume {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Database),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 failover(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
replica_type: Option<&str>,
subscription_id: &str,
) -> std::result::Result<failover::Response, failover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/failover",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(failover::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(failover::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(replica_type) = replica_type {
url.query_pairs_mut().append_pair("replicaType", replica_type);
}
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(failover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(failover::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(failover::Response::Accepted202),
status_code => Err(failover::Error::DefaultResponse { status_code }),
}
}
pub mod failover {
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 },
#[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_inaccessible_by_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseListResult, list_inaccessible_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/inaccessibleDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_inaccessible_by_server::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_inaccessible_by_server::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_inaccessible_by_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_inaccessible_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_inaccessible_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_inaccessible_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_inaccessible_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 upgrade_data_warehouse(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<upgrade_data_warehouse::Response, upgrade_data_warehouse::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/upgradeDataWarehouse",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(upgrade_data_warehouse::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(upgrade_data_warehouse::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(upgrade_data_warehouse::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(upgrade_data_warehouse::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(upgrade_data_warehouse::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(upgrade_data_warehouse::Response::Accepted202),
status_code => Err(upgrade_data_warehouse::Error::DefaultResponse { status_code }),
}
}
pub mod upgrade_data_warehouse {
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 },
#[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 rename(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::ResourceMoveDefinition,
subscription_id: &str,
) -> std::result::Result<(), rename::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/move",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(rename::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(rename::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(parameters).map_err(rename::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(rename::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(rename::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(rename::Error::DefaultResponse { status_code }),
}
}
pub mod rename {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 elastic_pools {
use super::{models, API_VERSION};
pub async fn list_metrics(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
filter: &str,
) -> std::result::Result<models::MetricListResult, list_metrics::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/metrics",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_metrics::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_metrics::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("$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_metrics::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metrics::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MetricListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_metrics::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metrics::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metrics {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_metric_definitions(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
) -> std::result::Result<models::MetricDefinitionListResult, list_metric_definitions::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/metricDefinitions",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_metric_definitions::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_metric_definitions::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_metric_definitions::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metric_definitions::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MetricDefinitionListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_metric_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metric_definitions::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metric_definitions {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
skip: Option<i64>,
subscription_id: &str,
) -> std::result::Result<models::ElasticPoolListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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(skip) = skip {
url.query_pairs_mut().append_pair("$skip", skip.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_by_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ElasticPoolListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ElasticPool, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_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::ElasticPool =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
parameters: &models::ElasticPool,
subscription_id: &str,
) -> 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.Sql/servers/{}/elasticPools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_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(parameters).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::ElasticPool = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ElasticPool = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ElasticPool),
Accepted202,
Created201(models::ElasticPool),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
parameters: &models::ElasticPoolUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_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(parameters).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::ElasticPool =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ElasticPool),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 failover(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<failover::Response, failover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/failover",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(failover::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(failover::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(failover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(failover::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(failover::Response::Accepted202),
status_code => Err(failover::Error::DefaultResponse { status_code }),
}
}
pub mod failover {
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 },
#[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 recommended_elastic_pools {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
recommended_elastic_pool_name: &str,
) -> std::result::Result<models::RecommendedElasticPool, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/recommendedElasticPools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
recommended_elastic_pool_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::RecommendedElasticPool =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::RecommendedElasticPoolListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/recommendedElasticPools",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RecommendedElasticPoolListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_metrics(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
recommended_elastic_pool_name: &str,
) -> std::result::Result<models::RecommendedElasticPoolListMetricsResult, list_metrics::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/recommendedElasticPools/{}/metrics",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
recommended_elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_metrics::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_metrics::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_metrics::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metrics::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RecommendedElasticPoolListMetricsResult =
serde_json::from_slice(rsp_body).map_err(|source| list_metrics::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metrics::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metrics {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 replication_links {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
link_id: &str,
) -> std::result::Result<models::ReplicationLink, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/replicationLinks/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
link_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::ReplicationLink =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
database_name: &str,
link_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/replicationLinks/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
link_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);
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();
Err(delete::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 failover(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
link_id: &str,
) -> std::result::Result<failover::Response, failover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/replicationLinks/{}/failover",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
link_id
);
let mut url = url::Url::parse(url_str).map_err(failover::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(failover::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(failover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(failover::Response::NoContent204),
http::StatusCode::ACCEPTED => Ok(failover::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
Err(failover::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod failover {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 failover_allow_data_loss(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
link_id: &str,
) -> std::result::Result<failover_allow_data_loss::Response, failover_allow_data_loss::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/replicationLinks/{}/forceFailoverAllowDataLoss" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , link_id) ;
let mut url = url::Url::parse(url_str).map_err(failover_allow_data_loss::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(failover_allow_data_loss::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(failover_allow_data_loss::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover_allow_data_loss::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(failover_allow_data_loss::Response::NoContent204),
http::StatusCode::ACCEPTED => Ok(failover_allow_data_loss::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
Err(failover_allow_data_loss::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod failover_allow_data_loss {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 unlink(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
link_id: &str,
parameters: &models::UnlinkParameters,
) -> std::result::Result<unlink::Response, unlink::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/replicationLinks/{}/unlink",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
link_id
);
let mut url = url::Url::parse(url_str).map_err(unlink::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(unlink::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(parameters).map_err(unlink::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(unlink::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(unlink::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(unlink::Response::NoContent204),
http::StatusCode::ACCEPTED => Ok(unlink::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
Err(unlink::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod unlink {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_database(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
) -> std::result::Result<models::ReplicationLinkListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/replicationLinks",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ReplicationLinkListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_database::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 server_communication_links {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
communication_link_name: &str,
) -> std::result::Result<models::ServerCommunicationLink, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/communicationLinks/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
communication_link_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::ServerCommunicationLink =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
communication_link_name: &str,
parameters: &models::ServerCommunicationLink,
) -> 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.Sql/servers/{}/communicationLinks/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
communication_link_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(parameters).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::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ServerCommunicationLink = 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))
}
http::StatusCode::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Created201(models::ServerCommunicationLink),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
communication_link_name: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/communicationLinks/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
communication_link_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(()),
status_code => {
let rsp_body = rsp.body();
Err(delete::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::ServerCommunicationLinkListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/communicationLinks",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerCommunicationLinkListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 service_objectives {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
service_objective_name: &str,
) -> std::result::Result<models::ServiceObjective, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/serviceObjectives/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
service_objective_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::ServiceObjective =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::ServiceObjectiveListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/serviceObjectives",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServiceObjectiveListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 elastic_pool_activities {
use super::{models, API_VERSION};
pub async fn list_by_elastic_pool(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
) -> std::result::Result<models::ElasticPoolActivityListResult, list_by_elastic_pool::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/elasticPoolActivity",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_elastic_pool::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_elastic_pool::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_elastic_pool::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_elastic_pool::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ElasticPoolActivityListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_elastic_pool::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_elastic_pool::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_elastic_pool {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 elastic_pool_database_activities {
use super::{models, API_VERSION};
pub async fn list_by_elastic_pool(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
) -> std::result::Result<models::ElasticPoolDatabaseActivityListResult, list_by_elastic_pool::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/elasticPoolDatabaseActivity",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_elastic_pool::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_elastic_pool::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_elastic_pool::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_elastic_pool::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ElasticPoolDatabaseActivityListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_elastic_pool::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_elastic_pool::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_elastic_pool {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 service_tier_advisors {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
service_tier_advisor_name: &str,
) -> std::result::Result<models::ServiceTierAdvisor, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/serviceTierAdvisors/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
service_tier_advisor_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::ServiceTierAdvisor =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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_database(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
) -> std::result::Result<models::ServiceTierAdvisorListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/serviceTierAdvisors",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServiceTierAdvisorListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_database::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 transparent_data_encryptions {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
transparent_data_encryption_name: &str,
) -> std::result::Result<models::TransparentDataEncryption, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/transparentDataEncryption/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
transparent_data_encryption_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::TransparentDataEncryption =
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();
Err(get::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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,
server_name: &str,
database_name: &str,
transparent_data_encryption_name: &str,
parameters: &models::TransparentDataEncryption,
) -> 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.Sql/servers/{}/databases/{}/transparentDataEncryption/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
transparent_data_encryption_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(parameters).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::TransparentDataEncryption = 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::TransparentDataEncryption = 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();
Err(create_or_update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::TransparentDataEncryption),
Created201(models::TransparentDataEncryption),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 transparent_data_encryption_activities {
use super::{models, API_VERSION};
pub async fn list_by_configuration(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
transparent_data_encryption_name: &str,
) -> std::result::Result<models::TransparentDataEncryptionActivityListResult, list_by_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/transparentDataEncryption/{}/operationResults" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , transparent_data_encryption_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_configuration::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_configuration::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_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TransparentDataEncryptionActivityListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_configuration {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 server_usages {
use super::{models, API_VERSION};
pub async fn list_by_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::ServerUsageListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/usages",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerUsageListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_server::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 database_usages {
use super::{models, API_VERSION};
pub async fn list_by_database(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
database_name: &str,
) -> std::result::Result<models::DatabaseUsageListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/usages",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseUsageListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_database::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Unexpected HTTP status code {}", status_code)]
UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
#[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 database_automatic_tuning {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseAutomaticTuning, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/automaticTuning/current",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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::DatabaseAutomaticTuning =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
resource_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::DatabaseAutomaticTuning,
subscription_id: &str,
) -> std::result::Result<models::DatabaseAutomaticTuning, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/automaticTuning/current",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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(parameters).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::DatabaseAutomaticTuning =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 encryption_protectors {
use super::{models, API_VERSION};
pub async fn revalidate(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
encryption_protector_name: &str,
subscription_id: &str,
) -> std::result::Result<revalidate::Response, revalidate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/encryptionProtector/{}/revalidate",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
encryption_protector_name
);
let mut url = url::Url::parse(url_str).map_err(revalidate::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(revalidate::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(revalidate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(revalidate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(revalidate::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(revalidate::Response::Accepted202),
status_code => Err(revalidate::Error::DefaultResponse { status_code }),
}
}
pub mod revalidate {
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::EncryptionProtectorListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/encryptionProtector",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::EncryptionProtectorListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
encryption_protector_name: &str,
subscription_id: &str,
) -> std::result::Result<models::EncryptionProtector, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/encryptionProtector/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
encryption_protector_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::EncryptionProtector =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
encryption_protector_name: &str,
parameters: &models::EncryptionProtector,
subscription_id: &str,
) -> 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.Sql/servers/{}/encryptionProtector/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
encryption_protector_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(parameters).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::EncryptionProtector = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::EncryptionProtector),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 failover_groups {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::FailoverGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/failoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
failover_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::FailoverGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
failover_group_name: &str,
parameters: &models::FailoverGroup,
subscription_id: &str,
) -> 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.Sql/servers/{}/failoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
failover_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(parameters).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::FailoverGroup = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::FailoverGroup = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::FailoverGroup),
Accepted202,
Created201(models::FailoverGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
failover_group_name: &str,
parameters: &models::FailoverGroupUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/failoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
failover_group_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(parameters).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::FailoverGroup =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::FailoverGroup),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/failoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
failover_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::FailoverGroupListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/failoverGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FailoverGroupListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 failover(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<failover::Response, failover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/failoverGroups/{}/failover",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
failover_group_name
);
let mut url = url::Url::parse(url_str).map_err(failover::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(failover::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(failover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FailoverGroup =
serde_json::from_slice(rsp_body).map_err(|source| failover::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(failover::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(failover::Response::Accepted202),
status_code => Err(failover::Error::DefaultResponse { status_code }),
}
}
pub mod failover {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::FailoverGroup),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 force_failover_allow_data_loss(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<force_failover_allow_data_loss::Response, force_failover_allow_data_loss::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/failoverGroups/{}/forceFailoverAllowDataLoss",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
failover_group_name
);
let mut url = url::Url::parse(url_str).map_err(force_failover_allow_data_loss::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(force_failover_allow_data_loss::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(force_failover_allow_data_loss::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(force_failover_allow_data_loss::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FailoverGroup = serde_json::from_slice(rsp_body)
.map_err(|source| force_failover_allow_data_loss::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(force_failover_allow_data_loss::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(force_failover_allow_data_loss::Response::Accepted202),
status_code => Err(force_failover_allow_data_loss::Error::DefaultResponse { status_code }),
}
}
pub mod force_failover_allow_data_loss {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::FailoverGroup),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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::OperationListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!("{}/providers/Microsoft.Sql/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::OperationListResult =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 server_keys {
use super::{models, API_VERSION};
pub async fn list_by_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerKeyListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/keys",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerKeyListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
key_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerKey, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/keys/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
key_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::ServerKey =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
key_name: &str,
parameters: &models::ServerKey,
subscription_id: &str,
) -> 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.Sql/servers/{}/keys/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
key_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(parameters).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::ServerKey = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ServerKey = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerKey),
Accepted202,
Created201(models::ServerKey),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
key_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/keys/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
key_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 sync_agents {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
sync_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncAgent, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/syncAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
sync_agent_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::SyncAgent =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
sync_agent_name: &str,
parameters: &models::SyncAgent,
subscription_id: &str,
) -> 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.Sql/servers/{}/syncAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
sync_agent_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(parameters).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::SyncAgent = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SyncAgent = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SyncAgent),
Accepted202,
Created201(models::SyncAgent),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
sync_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/syncAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
sync_agent_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncAgentListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/syncAgents",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncAgentListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 generate_key(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
sync_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncAgentKeyProperties, generate_key::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/syncAgents/{}/generateKey",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
sync_agent_name
);
let mut url = url::Url::parse(url_str).map_err(generate_key::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(generate_key::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(generate_key::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(generate_key::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncAgentKeyProperties =
serde_json::from_slice(rsp_body).map_err(|source| generate_key::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(generate_key::Error::DefaultResponse { status_code }),
}
}
pub mod generate_key {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_linked_databases(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
sync_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncAgentLinkedDatabaseListResult, list_linked_databases::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/syncAgents/{}/linkedDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
sync_agent_name
);
let mut url = url::Url::parse(url_str).map_err(list_linked_databases::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_linked_databases::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_linked_databases::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_linked_databases::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncAgentLinkedDatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_linked_databases::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_linked_databases::Error::DefaultResponse { status_code }),
}
}
pub mod list_linked_databases {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 subscription_usages {
use super::{models, API_VERSION};
pub async fn list_by_location(
operation_config: &crate::OperationConfig,
location_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SubscriptionUsageListResult, list_by_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/usages",
operation_config.base_path(),
subscription_id,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_location::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_location::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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SubscriptionUsageListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
location_name: &str,
usage_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SubscriptionUsage, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/usages/{}",
operation_config.base_path(),
subscription_id,
location_name,
usage_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::SubscriptionUsage =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 virtual_clusters {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::VirtualClusterListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/virtualClusters",
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::VirtualClusterListResult =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
resource_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VirtualClusterListResult, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/virtualClusters",
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::VirtualClusterListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
virtual_cluster_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VirtualCluster, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/virtualClusters/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
virtual_cluster_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::VirtualCluster =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
resource_group_name: &str,
virtual_cluster_name: &str,
parameters: &models::VirtualClusterUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/virtualClusters/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
virtual_cluster_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(parameters).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::VirtualCluster =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::VirtualCluster),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
virtual_cluster_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/virtualClusters/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
virtual_cluster_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 virtual_network_rules {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
virtual_network_rule_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VirtualNetworkRule, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/virtualNetworkRules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
virtual_network_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::VirtualNetworkRule =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
virtual_network_rule_name: &str,
parameters: &models::VirtualNetworkRule,
subscription_id: &str,
) -> 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.Sql/servers/{}/virtualNetworkRules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
virtual_network_rule_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(parameters).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::VirtualNetworkRule = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::VirtualNetworkRule = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::VirtualNetworkRule),
Accepted202,
Created201(models::VirtualNetworkRule),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
virtual_network_rule_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/virtualNetworkRules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
virtual_network_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::OK => Ok(delete::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(delete::Response::Accepted202),
http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VirtualNetworkRuleListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/virtualNetworkRules",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VirtualNetworkRuleListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 extended_database_blob_auditing_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
blob_auditing_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ExtendedDatabaseBlobAuditingPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/extendedAuditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
blob_auditing_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::ExtendedDatabaseBlobAuditingPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
blob_auditing_policy_name: &str,
parameters: &models::ExtendedDatabaseBlobAuditingPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/extendedAuditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
blob_auditing_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(parameters).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::ExtendedDatabaseBlobAuditingPolicy = 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::ExtendedDatabaseBlobAuditingPolicy = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ExtendedDatabaseBlobAuditingPolicy),
Created201(models::ExtendedDatabaseBlobAuditingPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ExtendedDatabaseBlobAuditingPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/extendedAuditingSettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ExtendedDatabaseBlobAuditingPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 extended_server_blob_auditing_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
blob_auditing_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ExtendedServerBlobAuditingPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/extendedAuditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
blob_auditing_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::ExtendedServerBlobAuditingPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
blob_auditing_policy_name: &str,
parameters: &models::ExtendedServerBlobAuditingPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/extendedAuditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
blob_auditing_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(parameters).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::ExtendedServerBlobAuditingPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ExtendedServerBlobAuditingPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ExtendedServerBlobAuditingPolicyListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/extendedAuditingSettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ExtendedServerBlobAuditingPolicyListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 server_blob_auditing_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
blob_auditing_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerBlobAuditingPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/auditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
blob_auditing_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::ServerBlobAuditingPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
blob_auditing_policy_name: &str,
parameters: &models::ServerBlobAuditingPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/auditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
blob_auditing_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(parameters).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::ServerBlobAuditingPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerBlobAuditingPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerBlobAuditingPolicyListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/auditingSettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerBlobAuditingPolicyListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 database_blob_auditing_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
blob_auditing_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseBlobAuditingPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/auditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
blob_auditing_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::DatabaseBlobAuditingPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
blob_auditing_policy_name: &str,
parameters: &models::DatabaseBlobAuditingPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/auditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
blob_auditing_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(parameters).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::DatabaseBlobAuditingPolicy = 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::DatabaseBlobAuditingPolicy = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DatabaseBlobAuditingPolicy),
Created201(models::DatabaseBlobAuditingPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseBlobAuditingPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/auditingSettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseBlobAuditingPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 database_vulnerability_assessment_rule_baselines {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
rule_id: &str,
baseline_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessmentRuleBaseline, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/rules/{}/baselines/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , vulnerability_assessment_name , rule_id , baseline_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::DatabaseVulnerabilityAssessmentRuleBaseline =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
rule_id: &str,
baseline_name: &str,
parameters: &models::DatabaseVulnerabilityAssessmentRuleBaseline,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessmentRuleBaseline, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/rules/{}/baselines/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , vulnerability_assessment_name , rule_id , baseline_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(parameters).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::DatabaseVulnerabilityAssessmentRuleBaseline = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
rule_id: &str,
baseline_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/rules/{}/baselines/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , vulnerability_assessment_name , rule_id , baseline_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 database_vulnerability_assessments {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessment, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
vulnerability_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::DatabaseVulnerabilityAssessment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
parameters: &models::DatabaseVulnerabilityAssessment,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
vulnerability_assessment_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(parameters).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::DatabaseVulnerabilityAssessment = 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::DatabaseVulnerabilityAssessment = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DatabaseVulnerabilityAssessment),
Created201(models::DatabaseVulnerabilityAssessment),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
vulnerability_assessment_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessmentListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseVulnerabilityAssessmentListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 job_agents {
use super::{models, API_VERSION};
pub async fn list_by_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobAgentListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobAgentListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobAgent, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_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::JobAgent =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
parameters: &models::JobAgent,
subscription_id: &str,
) -> 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.Sql/servers/{}/jobAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_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(parameters).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::JobAgent = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::JobAgent = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobAgent),
Accepted202,
Created201(models::JobAgent),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
parameters: &models::JobAgentUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_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(parameters).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::JobAgent =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobAgent),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_credentials {
use super::{models, API_VERSION};
pub async fn list_by_agent(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobCredentialListResult, list_by_agent::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/credentials",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_agent::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_agent::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_agent::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_agent::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobCredentialListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_agent::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_agent::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_agent {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
credential_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobCredential, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/credentials/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
credential_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::JobCredential =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
credential_name: &str,
parameters: &models::JobCredential,
subscription_id: &str,
) -> 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.Sql/servers/{}/jobAgents/{}/credentials/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
credential_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(parameters).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::JobCredential = 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::JobCredential = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobCredential),
Created201(models::JobCredential),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
credential_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/credentials/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
credential_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_executions {
use super::{models, API_VERSION};
pub async fn list_by_agent(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
create_time_min: Option<&str>,
create_time_max: Option<&str>,
end_time_min: Option<&str>,
end_time_max: Option<&str>,
is_active: Option<bool>,
skip: Option<i64>,
top: Option<i64>,
subscription_id: &str,
) -> std::result::Result<models::JobExecutionListResult, list_by_agent::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/executions",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_agent::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_agent::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(create_time_min) = create_time_min {
url.query_pairs_mut().append_pair("createTimeMin", create_time_min);
}
if let Some(create_time_max) = create_time_max {
url.query_pairs_mut().append_pair("createTimeMax", create_time_max);
}
if let Some(end_time_min) = end_time_min {
url.query_pairs_mut().append_pair("endTimeMin", end_time_min);
}
if let Some(end_time_max) = end_time_max {
url.query_pairs_mut().append_pair("endTimeMax", end_time_max);
}
if let Some(is_active) = is_active {
url.query_pairs_mut().append_pair("isActive", is_active.to_string().as_str());
}
if let Some(skip) = skip {
url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
}
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_by_agent::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_agent::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobExecutionListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_agent::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_agent::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_agent {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 cancel(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
subscription_id: &str,
) -> std::result::Result<(), cancel::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}/cancel",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_id
);
let mut url = url::Url::parse(url_str).map_err(cancel::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(cancel::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(cancel::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(cancel::Error::DefaultResponse { status_code }),
}
}
pub mod cancel {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
subscription_id: &str,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_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::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(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);
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(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::JobExecution =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(create::Response::Accepted202),
status_code => Err(create::Error::DefaultResponse { status_code }),
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobExecution),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
create_time_min: Option<&str>,
create_time_max: Option<&str>,
end_time_min: Option<&str>,
end_time_max: Option<&str>,
is_active: Option<bool>,
skip: Option<i64>,
top: Option<i64>,
subscription_id: &str,
) -> std::result::Result<models::JobExecutionListResult, list_by_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_job::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_job::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(create_time_min) = create_time_min {
url.query_pairs_mut().append_pair("createTimeMin", create_time_min);
}
if let Some(create_time_max) = create_time_max {
url.query_pairs_mut().append_pair("createTimeMax", create_time_max);
}
if let Some(end_time_min) = end_time_min {
url.query_pairs_mut().append_pair("endTimeMin", end_time_min);
}
if let Some(end_time_max) = end_time_max {
url.query_pairs_mut().append_pair("endTimeMax", end_time_max);
}
if let Some(is_active) = is_active {
url.query_pairs_mut().append_pair("isActive", is_active.to_string().as_str());
}
if let Some(skip) = skip {
url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
}
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_by_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobExecutionListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_job::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_job::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
subscription_id: &str,
) -> std::result::Result<models::JobExecution, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_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::JobExecution =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
subscription_id: &str,
) -> 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.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_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);
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(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::JobExecution = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::JobExecution = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobExecution),
Accepted202,
Created201(models::JobExecution),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 jobs {
use super::{models, API_VERSION};
pub async fn list_by_agent(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobListResult, list_by_agent::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_agent::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_agent::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_agent::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_agent::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_agent::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_agent::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_agent {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::Job, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_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::Job =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
parameters: &models::Job,
subscription_id: &str,
) -> 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.Sql/servers/{}/jobAgents/{}/jobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_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(parameters).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::Job = 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::Job = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Job),
Created201(models::Job),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_step_executions {
use super::{models, API_VERSION};
pub async fn list_by_job_execution(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
create_time_min: Option<&str>,
create_time_max: Option<&str>,
end_time_min: Option<&str>,
end_time_max: Option<&str>,
is_active: Option<bool>,
skip: Option<i64>,
top: Option<i64>,
subscription_id: &str,
) -> std::result::Result<models::JobExecutionListResult, list_by_job_execution::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}/steps",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_id
);
let mut url = url::Url::parse(url_str).map_err(list_by_job_execution::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_job_execution::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(create_time_min) = create_time_min {
url.query_pairs_mut().append_pair("createTimeMin", create_time_min);
}
if let Some(create_time_max) = create_time_max {
url.query_pairs_mut().append_pair("createTimeMax", create_time_max);
}
if let Some(end_time_min) = end_time_min {
url.query_pairs_mut().append_pair("endTimeMin", end_time_min);
}
if let Some(end_time_max) = end_time_max {
url.query_pairs_mut().append_pair("endTimeMax", end_time_max);
}
if let Some(is_active) = is_active {
url.query_pairs_mut().append_pair("isActive", is_active.to_string().as_str());
}
if let Some(skip) = skip {
url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
}
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_by_job_execution::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_job_execution::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobExecutionListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_job_execution::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_job_execution::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_job_execution {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
step_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobExecution, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}/steps/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_id,
step_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::JobExecution =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_steps {
use super::{models, API_VERSION};
pub async fn list_by_version(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_version: i32,
subscription_id: &str,
) -> std::result::Result<models::JobStepListResult, list_by_version::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/versions/{}/steps",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_version
);
let mut url = url::Url::parse(url_str).map_err(list_by_version::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_version::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_version::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_version::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobStepListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_version::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_version::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_version {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_by_version(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_version: i32,
step_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobStep, get_by_version::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/versions/{}/steps/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_version,
step_name
);
let mut url = url::Url::parse(url_str).map_err(get_by_version::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_by_version::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_by_version::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_by_version::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobStep =
serde_json::from_slice(rsp_body).map_err(|source| get_by_version::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get_by_version::Error::DefaultResponse { status_code }),
}
}
pub mod get_by_version {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobStepListResult, list_by_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/steps",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_job::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_job::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_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobStepListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_job::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_job::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
step_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobStep, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/steps/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
step_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::JobStep =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
step_name: &str,
parameters: &models::JobStep,
subscription_id: &str,
) -> 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.Sql/servers/{}/jobAgents/{}/jobs/{}/steps/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
step_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(parameters).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::JobStep = 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::JobStep = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobStep),
Created201(models::JobStep),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
step_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/steps/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
step_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_target_executions {
use super::{models, API_VERSION};
pub async fn list_by_job_execution(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
create_time_min: Option<&str>,
create_time_max: Option<&str>,
end_time_min: Option<&str>,
end_time_max: Option<&str>,
is_active: Option<bool>,
skip: Option<i64>,
top: Option<i64>,
subscription_id: &str,
) -> std::result::Result<models::JobExecutionListResult, list_by_job_execution::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}/targets",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_id
);
let mut url = url::Url::parse(url_str).map_err(list_by_job_execution::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_job_execution::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(create_time_min) = create_time_min {
url.query_pairs_mut().append_pair("createTimeMin", create_time_min);
}
if let Some(create_time_max) = create_time_max {
url.query_pairs_mut().append_pair("createTimeMax", create_time_max);
}
if let Some(end_time_min) = end_time_min {
url.query_pairs_mut().append_pair("endTimeMin", end_time_min);
}
if let Some(end_time_max) = end_time_max {
url.query_pairs_mut().append_pair("endTimeMax", end_time_max);
}
if let Some(is_active) = is_active {
url.query_pairs_mut().append_pair("isActive", is_active.to_string().as_str());
}
if let Some(skip) = skip {
url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
}
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_by_job_execution::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_job_execution::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobExecutionListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_job_execution::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_job_execution::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_job_execution {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_step(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
step_name: &str,
create_time_min: Option<&str>,
create_time_max: Option<&str>,
end_time_min: Option<&str>,
end_time_max: Option<&str>,
is_active: Option<bool>,
skip: Option<i64>,
top: Option<i64>,
subscription_id: &str,
) -> std::result::Result<models::JobExecutionListResult, list_by_step::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}/steps/{}/targets",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_execution_id,
step_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_step::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_step::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(create_time_min) = create_time_min {
url.query_pairs_mut().append_pair("createTimeMin", create_time_min);
}
if let Some(create_time_max) = create_time_max {
url.query_pairs_mut().append_pair("createTimeMax", create_time_max);
}
if let Some(end_time_min) = end_time_min {
url.query_pairs_mut().append_pair("endTimeMin", end_time_min);
}
if let Some(end_time_max) = end_time_max {
url.query_pairs_mut().append_pair("endTimeMax", end_time_max);
}
if let Some(is_active) = is_active {
url.query_pairs_mut().append_pair("isActive", is_active.to_string().as_str());
}
if let Some(skip) = skip {
url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
}
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_by_step::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_step::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobExecutionListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_step::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_step::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_step {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_execution_id: &str,
step_name: &str,
target_id: &str,
subscription_id: &str,
) -> std::result::Result<models::JobExecution, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/executions/{}/steps/{}/targets/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , job_agent_name , job_name , job_execution_id , step_name , target_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::JobExecution =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_target_groups {
use super::{models, API_VERSION};
pub async fn list_by_agent(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobTargetGroupListResult, list_by_agent::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/targetGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_agent::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_agent::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_agent::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_agent::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobTargetGroupListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_agent::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_agent::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_agent {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
target_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobTargetGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/targetGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
target_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::JobTargetGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
target_group_name: &str,
parameters: &models::JobTargetGroup,
subscription_id: &str,
) -> 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.Sql/servers/{}/jobAgents/{}/targetGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
target_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(parameters).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::JobTargetGroup = 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::JobTargetGroup = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::JobTargetGroup),
Created201(models::JobTargetGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
target_group_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/targetGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
target_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 job_versions {
use super::{models, API_VERSION};
pub async fn list_by_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::JobVersionListResult, list_by_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/versions",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_job::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_job::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_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::JobVersionListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_job::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_job::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
job_agent_name: &str,
job_name: &str,
job_version: i32,
subscription_id: &str,
) -> std::result::Result<models::JobVersion, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/jobAgents/{}/jobs/{}/versions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
job_agent_name,
job_name,
job_version
);
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::JobVersion =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 managed_backup_short_term_retention_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedBackupShortTermRetentionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/backupShortTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , 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::ManagedBackupShortTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
policy_name: &str,
parameters: &models::ManagedBackupShortTermRetentionPolicy,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/databases/{}/backupShortTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , 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(parameters).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::ManagedBackupShortTermRetentionPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedBackupShortTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
policy_name: &str,
parameters: &models::ManagedBackupShortTermRetentionPolicy,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/backupShortTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , policy_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(parameters).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::ManagedBackupShortTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedBackupShortTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedBackupShortTermRetentionPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/backupShortTermRetentionPolicies" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedBackupShortTermRetentionPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_restorable_dropped_database_backup_short_term_retention_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
restorable_dropped_database_id: &str,
policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedBackupShortTermRetentionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/restorableDroppedDatabases/{}/backupShortTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , restorable_dropped_database_id , 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::ManagedBackupShortTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
restorable_dropped_database_id: &str,
policy_name: &str,
parameters: &models::ManagedBackupShortTermRetentionPolicy,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/restorableDroppedDatabases/{}/backupShortTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , restorable_dropped_database_id , 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(parameters).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::ManagedBackupShortTermRetentionPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedBackupShortTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
managed_instance_name: &str,
restorable_dropped_database_id: &str,
policy_name: &str,
parameters: &models::ManagedBackupShortTermRetentionPolicy,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/restorableDroppedDatabases/{}/backupShortTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , restorable_dropped_database_id , policy_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(parameters).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::ManagedBackupShortTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedBackupShortTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_restorable_dropped_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
restorable_dropped_database_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedBackupShortTermRetentionPolicyListResult, list_by_restorable_dropped_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/restorableDroppedDatabases/{}/backupShortTermRetentionPolicies" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , restorable_dropped_database_id) ;
let mut url = url::Url::parse(url_str).map_err(list_by_restorable_dropped_database::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_restorable_dropped_database::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_restorable_dropped_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_restorable_dropped_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedBackupShortTermRetentionPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_restorable_dropped_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_restorable_dropped_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_restorable_dropped_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 server_automatic_tuning {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerAutomaticTuning, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/automaticTuning/current",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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::ServerAutomaticTuning =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
resource_group_name: &str,
server_name: &str,
parameters: &models::ServerAutomaticTuning,
subscription_id: &str,
) -> std::result::Result<models::ServerAutomaticTuning, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/automaticTuning/current",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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(parameters).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::ServerAutomaticTuning =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 server_dns_aliases {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
dns_alias_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerDnsAlias, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/dnsAliases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
dns_alias_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::ServerDnsAlias =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
dns_alias_name: &str,
subscription_id: &str,
) -> 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.Sql/servers/{}/dnsAliases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
dns_alias_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);
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(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::ServerDnsAlias = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ServerDnsAlias = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerDnsAlias),
Accepted202,
Created201(models::ServerDnsAlias),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
dns_alias_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/dnsAliases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
dns_alias_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerDnsAliasListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/dnsAliases",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerDnsAliasListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 acquire(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
dns_alias_name: &str,
parameters: &models::ServerDnsAliasAcquisition,
subscription_id: &str,
) -> std::result::Result<acquire::Response, acquire::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/dnsAliases/{}/acquire",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
dns_alias_name
);
let mut url = url::Url::parse(url_str).map_err(acquire::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(acquire::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(parameters).map_err(acquire::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(acquire::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(acquire::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(acquire::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(acquire::Response::Accepted202),
status_code => Err(acquire::Error::DefaultResponse { status_code }),
}
}
pub mod acquire {
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 },
#[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 server_security_alert_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
security_alert_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerSecurityAlertPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
security_alert_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::ServerSecurityAlertPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
security_alert_policy_name: &str,
parameters: &models::ServerSecurityAlertPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
security_alert_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(parameters).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::ServerSecurityAlertPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerSecurityAlertPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::LogicalServerSecurityAlertPolicyListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/securityAlertPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LogicalServerSecurityAlertPolicyListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 restorable_dropped_managed_databases {
use super::{models, API_VERSION};
pub async fn list_by_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::RestorableDroppedManagedDatabaseListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/restorableDroppedDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestorableDroppedManagedDatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
restorable_dropped_database_id: &str,
subscription_id: &str,
) -> std::result::Result<models::RestorableDroppedManagedDatabase, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/restorableDroppedDatabases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
restorable_dropped_database_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::RestorableDroppedManagedDatabase =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 restore_points {
use super::{models, API_VERSION};
pub async fn list_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::RestorePointListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/restorePoints",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestorePointListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::CreateDatabaseRestorePointDefinition,
subscription_id: &str,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/restorePoints",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_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::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(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(parameters).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::RestorePoint =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(create::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::RestorePoint =
serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create::Response::Created201(rsp_value))
}
status_code => Err(create::Error::DefaultResponse { status_code }),
}
}
pub mod create {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::RestorePoint),
Accepted202,
Created201(models::RestorePoint),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
restore_point_name: &str,
subscription_id: &str,
) -> std::result::Result<models::RestorePoint, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/restorePoints/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
restore_point_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::RestorePoint =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
restore_point_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/restorePoints/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
restore_point_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 managed_database_security_alert_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
security_alert_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedDatabaseSecurityAlertPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name,
security_alert_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::ManagedDatabaseSecurityAlertPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
security_alert_policy_name: &str,
parameters: &models::ManagedDatabaseSecurityAlertPolicy,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/databases/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name,
security_alert_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(parameters).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::ManagedDatabaseSecurityAlertPolicy = 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::ManagedDatabaseSecurityAlertPolicy = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedDatabaseSecurityAlertPolicy),
Created201(models::ManagedDatabaseSecurityAlertPolicy),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedDatabaseSecurityAlertPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/securityAlertPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedDatabaseSecurityAlertPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_server_security_alert_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
security_alert_policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedServerSecurityAlertPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
security_alert_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::ManagedServerSecurityAlertPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
security_alert_policy_name: &str,
parameters: &models::ManagedServerSecurityAlertPolicy,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/securityAlertPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
security_alert_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(parameters).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::ManagedServerSecurityAlertPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedServerSecurityAlertPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedServerSecurityAlertPolicyListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/securityAlertPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedServerSecurityAlertPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 sensitivity_labels {
use super::{models, API_VERSION};
pub async fn list_current_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::SensitivityLabelListResult, list_current_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/currentSensitivityLabels",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_current_by_database::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_current_by_database::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_current_by_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_current_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SensitivityLabelListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_current_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_current_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_current_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_recommended_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
include_disabled_recommendations: Option<bool>,
skip_token: Option<&str>,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::SensitivityLabelListResult, list_recommended_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/recommendedSensitivityLabels",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_recommended_by_database::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_recommended_by_database::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_disabled_recommendations) = include_disabled_recommendations {
url.query_pairs_mut().append_pair(
"includeDisabledRecommendations",
include_disabled_recommendations.to_string().as_str(),
);
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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_recommended_by_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_recommended_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SensitivityLabelListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_recommended_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_recommended_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_recommended_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 enable_recommendation(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<(), enable_recommendation::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}/enable" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
let mut url = url::Url::parse(url_str).map_err(enable_recommendation::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(enable_recommendation::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(enable_recommendation::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(enable_recommendation::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(enable_recommendation::Error::DefaultResponse { status_code }),
}
}
pub mod enable_recommendation {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 disable_recommendation(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<(), disable_recommendation::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}/disable" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
let mut url = url::Url::parse(url_str).map_err(disable_recommendation::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(disable_recommendation::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(disable_recommendation::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(disable_recommendation::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(disable_recommendation::Error::DefaultResponse { status_code }),
}
}
pub mod disable_recommendation {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<models::SensitivityLabel, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
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::SensitivityLabel =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
parameters: &models::SensitivityLabel,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
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(parameters).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::SensitivityLabel = 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::SensitivityLabel = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SensitivityLabel),
Created201(models::SensitivityLabel),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 managed_instance_administrators {
use super::{models, API_VERSION};
pub async fn list_by_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceAdministratorListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/administrators",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceAdministratorListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
administrator_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceAdministrator, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/administrators/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
administrator_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::ManagedInstanceAdministrator =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
administrator_name: &str,
parameters: &models::ManagedInstanceAdministrator,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/administrators/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
administrator_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(parameters).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::ManagedInstanceAdministrator = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceAdministrator = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstanceAdministrator),
Accepted202,
Created201(models::ManagedInstanceAdministrator),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
administrator_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/administrators/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
administrator_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),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
pub mod delete {
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 },
#[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 database_operations {
use super::{models, API_VERSION};
pub async fn cancel(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
operation_id: &str,
subscription_id: &str,
) -> std::result::Result<(), cancel::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/operations/{}/cancel",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
operation_id
);
let mut url = url::Url::parse(url_str).map_err(cancel::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(cancel::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(cancel::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(cancel::Error::DefaultResponse { status_code }),
}
}
pub mod cancel {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseOperationListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/operations",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseOperationListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 elastic_pool_operations {
use super::{models, API_VERSION};
pub async fn cancel(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
operation_id: &str,
subscription_id: &str,
) -> std::result::Result<(), cancel::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/operations/{}/cancel",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name,
operation_id
);
let mut url = url::Url::parse(url_str).map_err(cancel::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(cancel::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(cancel::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(cancel::Error::DefaultResponse { status_code }),
}
}
pub mod cancel {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_elastic_pool(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
elastic_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ElasticPoolOperationListResult, list_by_elastic_pool::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/elasticPools/{}/operations",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
elastic_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_elastic_pool::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_elastic_pool::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_elastic_pool::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_elastic_pool::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ElasticPoolOperationListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_elastic_pool::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_elastic_pool::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_elastic_pool {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 database_vulnerability_assessment_scans {
use super::{models, API_VERSION};
pub async fn list_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VulnerabilityAssessmentScanRecordListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/scans",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
vulnerability_assessment_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VulnerabilityAssessmentScanRecordListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
scan_id: &str,
subscription_id: &str,
) -> std::result::Result<models::VulnerabilityAssessmentScanRecord, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/scans/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
vulnerability_assessment_name,
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);
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::VulnerabilityAssessmentScanRecord =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_scan(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
scan_id: &str,
subscription_id: &str,
) -> std::result::Result<initiate_scan::Response, initiate_scan::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/scans/{}/initiateScan" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , vulnerability_assessment_name , scan_id) ;
let mut url = url::Url::parse(url_str).map_err(initiate_scan::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_scan::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(initiate_scan::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(initiate_scan::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(initiate_scan::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(initiate_scan::Response::Accepted202),
status_code => Err(initiate_scan::Error::DefaultResponse { status_code }),
}
}
pub mod initiate_scan {
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 },
#[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 export(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
scan_id: &str,
subscription_id: &str,
) -> std::result::Result<export::Response, export::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/vulnerabilityAssessments/{}/scans/{}/export" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , vulnerability_assessment_name , scan_id) ;
let mut url = url::Url::parse(url_str).map_err(export::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(export::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(export::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(export::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseVulnerabilityAssessmentScansExport =
serde_json::from_slice(rsp_body).map_err(|source| export::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(export::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseVulnerabilityAssessmentScansExport =
serde_json::from_slice(rsp_body).map_err(|source| export::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(export::Response::Created201(rsp_value))
}
status_code => Err(export::Error::DefaultResponse { status_code }),
}
}
pub mod export {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DatabaseVulnerabilityAssessmentScansExport),
Created201(models::DatabaseVulnerabilityAssessmentScansExport),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_database_vulnerability_assessment_rule_baselines {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
rule_id: &str,
baseline_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessmentRuleBaseline, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/rules/{}/baselines/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name , rule_id , baseline_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::DatabaseVulnerabilityAssessmentRuleBaseline =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
rule_id: &str,
baseline_name: &str,
parameters: &models::DatabaseVulnerabilityAssessmentRuleBaseline,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessmentRuleBaseline, create_or_update::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/rules/{}/baselines/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name , rule_id , baseline_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(parameters).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::DatabaseVulnerabilityAssessmentRuleBaseline = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
rule_id: &str,
baseline_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/rules/{}/baselines/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name , rule_id , baseline_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 managed_database_vulnerability_assessment_scans {
use super::{models, API_VERSION};
pub async fn list_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VulnerabilityAssessmentScanRecordListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/scans" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VulnerabilityAssessmentScanRecordListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
scan_id: &str,
subscription_id: &str,
) -> std::result::Result<models::VulnerabilityAssessmentScanRecord, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/scans/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name , 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);
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::VulnerabilityAssessmentScanRecord =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_scan(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
scan_id: &str,
subscription_id: &str,
) -> std::result::Result<initiate_scan::Response, initiate_scan::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/scans/{}/initiateScan" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name , scan_id) ;
let mut url = url::Url::parse(url_str).map_err(initiate_scan::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_scan::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(initiate_scan::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(initiate_scan::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(initiate_scan::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(initiate_scan::Response::Accepted202),
status_code => Err(initiate_scan::Error::DefaultResponse { status_code }),
}
}
pub mod initiate_scan {
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 },
#[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 export(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
scan_id: &str,
subscription_id: &str,
) -> std::result::Result<export::Response, export::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}/scans/{}/export" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , vulnerability_assessment_name , scan_id) ;
let mut url = url::Url::parse(url_str).map_err(export::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(export::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(export::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(export::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseVulnerabilityAssessmentScansExport =
serde_json::from_slice(rsp_body).map_err(|source| export::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(export::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseVulnerabilityAssessmentScansExport =
serde_json::from_slice(rsp_body).map_err(|source| export::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(export::Response::Created201(rsp_value))
}
status_code => Err(export::Error::DefaultResponse { status_code }),
}
}
pub mod export {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DatabaseVulnerabilityAssessmentScansExport),
Created201(models::DatabaseVulnerabilityAssessmentScansExport),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_database_vulnerability_assessments {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessment, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name,
vulnerability_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::DatabaseVulnerabilityAssessment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
parameters: &models::DatabaseVulnerabilityAssessment,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name,
vulnerability_assessment_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(parameters).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::DatabaseVulnerabilityAssessment = 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::DatabaseVulnerabilityAssessment = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::DatabaseVulnerabilityAssessment),
Created201(models::DatabaseVulnerabilityAssessment),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name,
vulnerability_assessment_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::DatabaseVulnerabilityAssessmentListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/vulnerabilityAssessments",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DatabaseVulnerabilityAssessmentListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 instance_failover_groups {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::InstanceFailoverGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/instanceFailoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
failover_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::InstanceFailoverGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
location_name: &str,
failover_group_name: &str,
parameters: &models::InstanceFailoverGroup,
subscription_id: &str,
) -> 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.Sql/locations/{}/instanceFailoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
failover_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(parameters).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::InstanceFailoverGroup = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::InstanceFailoverGroup = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::InstanceFailoverGroup),
Accepted202,
Created201(models::InstanceFailoverGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
location_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/instanceFailoverGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
failover_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_location(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
subscription_id: &str,
) -> std::result::Result<models::InstanceFailoverGroupListResult, list_by_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/instanceFailoverGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_location::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_location::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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::InstanceFailoverGroupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 failover(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<failover::Response, failover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/instanceFailoverGroups/{}/failover",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
failover_group_name
);
let mut url = url::Url::parse(url_str).map_err(failover::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(failover::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(failover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::InstanceFailoverGroup =
serde_json::from_slice(rsp_body).map_err(|source| failover::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(failover::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(failover::Response::Accepted202),
status_code => Err(failover::Error::DefaultResponse { status_code }),
}
}
pub mod failover {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::InstanceFailoverGroup),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 force_failover_allow_data_loss(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
failover_group_name: &str,
subscription_id: &str,
) -> std::result::Result<force_failover_allow_data_loss::Response, force_failover_allow_data_loss::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/instanceFailoverGroups/{}/forceFailoverAllowDataLoss" , operation_config . base_path () , subscription_id , resource_group_name , location_name , failover_group_name) ;
let mut url = url::Url::parse(url_str).map_err(force_failover_allow_data_loss::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(force_failover_allow_data_loss::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(force_failover_allow_data_loss::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(force_failover_allow_data_loss::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::InstanceFailoverGroup = serde_json::from_slice(rsp_body)
.map_err(|source| force_failover_allow_data_loss::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(force_failover_allow_data_loss::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(force_failover_allow_data_loss::Response::Accepted202),
status_code => Err(force_failover_allow_data_loss::Error::DefaultResponse { status_code }),
}
}
pub mod force_failover_allow_data_loss {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::InstanceFailoverGroup),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 tde_certificates {
use super::{models, API_VERSION};
pub async fn create(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
parameters: &models::TdeCertificate,
subscription_id: &str,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/tdeCertificates",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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::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(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(parameters).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 => Ok(create::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(create::Response::Accepted202),
status_code => Err(create::Error::DefaultResponse { status_code }),
}
}
pub mod create {
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 },
#[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 managed_instance_tde_certificates {
use super::{models, API_VERSION};
pub async fn create(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
parameters: &models::TdeCertificate,
subscription_id: &str,
) -> std::result::Result<create::Response, create::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/tdeCertificates",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_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::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(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(parameters).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 => Ok(create::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(create::Response::Accepted202),
status_code => Err(create::Error::DefaultResponse { status_code }),
}
}
pub mod create {
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 },
#[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 managed_instance_keys {
use super::{models, API_VERSION};
pub async fn list_by_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceKeyListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/keys",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceKeyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
key_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceKey, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/keys/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
key_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::ManagedInstanceKey =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
key_name: &str,
parameters: &models::ManagedInstanceKey,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/keys/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
key_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(parameters).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::ManagedInstanceKey = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceKey = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstanceKey),
Accepted202,
Created201(models::ManagedInstanceKey),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
key_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/keys/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
key_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 managed_instance_encryption_protectors {
use super::{models, API_VERSION};
pub async fn revalidate(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
encryption_protector_name: &str,
subscription_id: &str,
) -> std::result::Result<revalidate::Response, revalidate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/encryptionProtector/{}/revalidate",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
encryption_protector_name
);
let mut url = url::Url::parse(url_str).map_err(revalidate::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(revalidate::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(revalidate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(revalidate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(revalidate::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(revalidate::Response::Accepted202),
status_code => Err(revalidate::Error::DefaultResponse { status_code }),
}
}
pub mod revalidate {
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 },
#[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_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceEncryptionProtectorListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/encryptionProtector",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceEncryptionProtectorListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
encryption_protector_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceEncryptionProtector, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/encryptionProtector/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
encryption_protector_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::ManagedInstanceEncryptionProtector =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
encryption_protector_name: &str,
parameters: &models::ManagedInstanceEncryptionProtector,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/encryptionProtector/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
encryption_protector_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(parameters).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::ManagedInstanceEncryptionProtector = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstanceEncryptionProtector),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 recoverable_managed_databases {
use super::{models, API_VERSION};
pub async fn list_by_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::RecoverableManagedDatabaseListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/recoverableDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RecoverableManagedDatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
recoverable_database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::RecoverableManagedDatabase, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/recoverableDatabases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
recoverable_database_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::RecoverableManagedDatabase =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 backup_short_term_retention_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupShortTermRetentionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/backupShortTermRetentionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
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::BackupShortTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
policy_name: &str,
parameters: &models::BackupShortTermRetentionPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/backupShortTermRetentionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
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(parameters).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::BackupShortTermRetentionPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::BackupShortTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
database_name: &str,
policy_name: &str,
parameters: &models::BackupShortTermRetentionPolicy,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/backupShortTermRetentionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
policy_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(parameters).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::BackupShortTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::BackupShortTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupShortTermRetentionPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/backupShortTermRetentionPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupShortTermRetentionPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_instance_vulnerability_assessments {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceVulnerabilityAssessment, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
vulnerability_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::ManagedInstanceVulnerabilityAssessment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
vulnerability_assessment_name: &str,
parameters: &models::ManagedInstanceVulnerabilityAssessment,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
vulnerability_assessment_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(parameters).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::ManagedInstanceVulnerabilityAssessment = 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::ManagedInstanceVulnerabilityAssessment = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstanceVulnerabilityAssessment),
Created201(models::ManagedInstanceVulnerabilityAssessment),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
vulnerability_assessment_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceVulnerabilityAssessmentListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/vulnerabilityAssessments",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceVulnerabilityAssessmentListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 server_vulnerability_assessments {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerVulnerabilityAssessment, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
vulnerability_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::ServerVulnerabilityAssessment =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
vulnerability_assessment_name: &str,
parameters: &models::ServerVulnerabilityAssessment,
subscription_id: &str,
) -> 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.Sql/servers/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
vulnerability_assessment_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(parameters).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::ServerVulnerabilityAssessment = 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::ServerVulnerabilityAssessment = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerVulnerabilityAssessment),
Created201(models::ServerVulnerabilityAssessment),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
vulnerability_assessment_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/vulnerabilityAssessments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
vulnerability_assessment_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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerVulnerabilityAssessmentListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/vulnerabilityAssessments",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerVulnerabilityAssessmentListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_database_sensitivity_labels {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<models::SensitivityLabel, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
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::SensitivityLabel =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
parameters: &models::SensitivityLabel,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
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(parameters).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::SensitivityLabel = 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::SensitivityLabel = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SensitivityLabel),
Created201(models::SensitivityLabel),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<(), delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
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(()),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 disable_recommendation(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<(), disable_recommendation::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}/disable" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
let mut url = url::Url::parse(url_str).map_err(disable_recommendation::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(disable_recommendation::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(disable_recommendation::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(disable_recommendation::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(disable_recommendation::Error::DefaultResponse { status_code }),
}
}
pub mod disable_recommendation {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 enable_recommendation(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
schema_name: &str,
table_name: &str,
column_name: &str,
sensitivity_label_source: &str,
subscription_id: &str,
) -> std::result::Result<(), enable_recommendation::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/schemas/{}/tables/{}/columns/{}/sensitivityLabels/{}/enable" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , schema_name , table_name , column_name , sensitivity_label_source) ;
let mut url = url::Url::parse(url_str).map_err(enable_recommendation::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(enable_recommendation::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(enable_recommendation::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(enable_recommendation::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(enable_recommendation::Error::DefaultResponse { status_code }),
}
}
pub mod enable_recommendation {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_current_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::SensitivityLabelListResult, list_current_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/currentSensitivityLabels",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_current_by_database::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_current_by_database::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_current_by_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_current_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SensitivityLabelListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_current_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_current_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_current_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_recommended_by_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
include_disabled_recommendations: Option<bool>,
skip_token: Option<&str>,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::SensitivityLabelListResult, list_recommended_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/recommendedSensitivityLabels",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_recommended_by_database::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_recommended_by_database::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_disabled_recommendations) = include_disabled_recommendations {
url.query_pairs_mut().append_pair(
"includeDisabledRecommendations",
include_disabled_recommendations.to_string().as_str(),
);
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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_recommended_by_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_recommended_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SensitivityLabelListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_recommended_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_recommended_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_recommended_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 instance_pools {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
instance_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<models::InstancePool, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/instancePools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
instance_pool_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::InstancePool =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
instance_pool_name: &str,
parameters: &models::InstancePool,
subscription_id: &str,
) -> 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.Sql/instancePools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
instance_pool_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(parameters).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::InstancePool = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::InstancePool = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::InstancePool),
Accepted202,
Created201(models::InstancePool),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
instance_pool_name: &str,
parameters: &models::InstancePoolUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/instancePools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
instance_pool_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(parameters).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::InstancePool =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::InstancePool),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
instance_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/instancePools/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
instance_pool_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
resource_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::InstancePoolListResult, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/instancePools",
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::InstancePoolListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
) -> std::result::Result<models::InstancePoolListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/instancePools",
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::InstancePoolListResult =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 usages {
use super::{models, API_VERSION};
pub async fn list_by_instance_pool(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
instance_pool_name: &str,
expand_children: Option<bool>,
subscription_id: &str,
) -> std::result::Result<models::UsageListResult, list_by_instance_pool::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/instancePools/{}/usages",
operation_config.base_path(),
subscription_id,
resource_group_name,
instance_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance_pool::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_instance_pool::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_children) = expand_children {
url.query_pairs_mut()
.append_pair("expandChildren", expand_children.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_by_instance_pool::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance_pool::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::UsageListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance_pool::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance_pool::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance_pool {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 private_link_resources {
use super::{models, API_VERSION};
pub async fn list_by_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PrivateLinkResourceListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/privateLinkResources",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PrivateLinkResourceListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PrivateLinkResource, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/privateLinkResources/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
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::PrivateLinkResource =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 servers {
use super::{models, API_VERSION};
pub async fn list_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerListResult, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers",
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::ServerListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::Server, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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::Server =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
parameters: &models::Server,
subscription_id: &str,
) -> 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.Sql/servers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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(parameters).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::Server = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::Server = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Server),
Accepted202,
Created201(models::Server),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
parameters: &models::ServerUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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(parameters).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::Server =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Server),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
) -> std::result::Result<models::ServerListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/servers",
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::ServerListResult =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 check_name_availability(
operation_config: &crate::OperationConfig,
parameters: &models::CheckNameAvailabilityRequest,
subscription_id: &str,
) -> std::result::Result<models::CheckNameAvailabilityResponse, check_name_availability::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/checkNameAvailability",
operation_config.base_path(),
subscription_id
);
let mut url = url::Url::parse(url_str).map_err(check_name_availability::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(check_name_availability::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(parameters).map_err(check_name_availability::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(check_name_availability::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(check_name_availability::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CheckNameAvailabilityResponse = serde_json::from_slice(rsp_body)
.map_err(|source| check_name_availability::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(check_name_availability::Error::DefaultResponse { status_code }),
}
}
pub mod check_name_availability {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 import_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
parameters: &models::ImportNewDatabaseDefinition,
subscription_id: &str,
) -> std::result::Result<import_database::Response, import_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/import",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(import_database::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(import_database::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(parameters).map_err(import_database::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(import_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(import_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ImportExportOperationResult = serde_json::from_slice(rsp_body)
.map_err(|source| import_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(import_database::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(import_database::Response::Accepted202),
status_code => Err(import_database::Error::DefaultResponse { status_code }),
}
}
pub mod import_database {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ImportExportOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 capabilities {
use super::{models, API_VERSION};
pub async fn list_by_location(
operation_config: &crate::OperationConfig,
location_name: &str,
include: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LocationCapabilities, list_by_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/capabilities",
operation_config.base_path(),
subscription_id,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_location::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_location::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) = include {
url.query_pairs_mut().append_pair("include", include);
}
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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LocationCapabilities = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 long_term_retention_managed_instance_backups {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
location_name: &str,
managed_instance_name: &str,
database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackup, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionDatabases/{}/longTermRetentionManagedInstanceBackups/{}" , operation_config . base_path () , subscription_id , location_name , managed_instance_name , database_name , backup_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::ManagedInstanceLongTermRetentionBackup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
location_name: &str,
managed_instance_name: &str,
database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionDatabases/{}/longTermRetentionManagedInstanceBackups/{}" , operation_config . base_path () , subscription_id , location_name , managed_instance_name , database_name , backup_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),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
pub mod delete {
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 },
#[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_database(
operation_config: &crate::OperationConfig,
location_name: &str,
managed_instance_name: &str,
database_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackupListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionDatabases/{}/longTermRetentionManagedInstanceBackups" , operation_config . base_path () , subscription_id , location_name , managed_instance_name , database_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_instance(
operation_config: &crate::OperationConfig,
location_name: &str,
managed_instance_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackupListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionManagedInstanceBackups" , operation_config . base_path () , subscription_id , location_name , managed_instance_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_location(
operation_config: &crate::OperationConfig,
location_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackupListResult, list_by_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstanceBackups",
operation_config.base_path(),
subscription_id,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_location::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_location::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
managed_instance_name: &str,
database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackup, get_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionDatabases/{}/longTermRetentionManagedInstanceBackups/{}" , operation_config . base_path () , subscription_id , resource_group_name , location_name , managed_instance_name , database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(get_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(get_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(get_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackup = serde_json::from_slice(rsp_body)
.map_err(|source| get_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get_by_resource_group::Error::DefaultResponse { status_code }),
}
}
pub mod get_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 },
#[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_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
managed_instance_name: &str,
database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_by_resource_group::Response, delete_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionDatabases/{}/longTermRetentionManagedInstanceBackups/{}" , operation_config . base_path () , subscription_id , resource_group_name , location_name , managed_instance_name , database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(delete_by_resource_group::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_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(delete_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_by_resource_group::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(delete_by_resource_group::Response::Accepted202),
status_code => Err(delete_by_resource_group::Error::DefaultResponse { status_code }),
}
}
pub mod delete_by_resource_group {
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 },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
managed_instance_name: &str,
database_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackupListResult, list_by_resource_group_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionDatabases/{}/longTermRetentionManagedInstanceBackups" , operation_config . base_path () , subscription_id , resource_group_name , location_name , managed_instance_name , database_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_database::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_database::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_resource_group_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
managed_instance_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackupListResult, list_by_resource_group_instance::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstances/{}/longTermRetentionManagedInstanceBackups" , operation_config . base_path () , subscription_id , resource_group_name , location_name , managed_instance_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_instance::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_instance::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_resource_group_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_location(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionBackupListResult, list_by_resource_group_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionManagedInstanceBackups",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_location::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_location::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_resource_group_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_instance_long_term_retention_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/backupLongTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , 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::ManagedInstanceLongTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
policy_name: &str,
parameters: &models::ManagedInstanceLongTermRetentionPolicy,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/databases/{}/backupLongTermRetentionPolicies/{}" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name , 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(parameters).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::ManagedInstanceLongTermRetentionPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstanceLongTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceLongTermRetentionPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/backupLongTermRetentionPolicies" , operation_config . base_path () , subscription_id , resource_group_name , managed_instance_name , database_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceLongTermRetentionPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 workload_groups {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::WorkloadGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/workloadGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
workload_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::WorkloadGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
parameters: &models::WorkloadGroup,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/workloadGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
workload_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(parameters).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::WorkloadGroup = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::WorkloadGroup = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::WorkloadGroup),
Accepted202,
Created201(models::WorkloadGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/workloadGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
workload_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::WorkloadGroupListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/workloadGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WorkloadGroupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 workload_classifiers {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
workload_classifier_name: &str,
subscription_id: &str,
) -> std::result::Result<models::WorkloadClassifier, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/workloadGroups/{}/workloadClassifiers/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , workload_group_name , workload_classifier_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::WorkloadClassifier =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
workload_classifier_name: &str,
parameters: &models::WorkloadClassifier,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/workloadGroups/{}/workloadClassifiers/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , workload_group_name , workload_classifier_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(parameters).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::WorkloadClassifier = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::WorkloadClassifier = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::WorkloadClassifier),
Accepted202,
Created201(models::WorkloadClassifier),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
workload_classifier_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/workloadGroups/{}/workloadClassifiers/{}" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , workload_group_name , workload_classifier_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_workload_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
workload_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::WorkloadClassifierListResult, list_by_workload_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/workloadGroups/{}/workloadClassifiers",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
workload_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_workload_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_workload_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_workload_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_workload_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WorkloadClassifierListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_workload_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_workload_group::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_workload_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_instance_operations {
use super::{models, API_VERSION};
pub async fn cancel(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
operation_id: &str,
subscription_id: &str,
) -> std::result::Result<(), cancel::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/operations/{}/cancel",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
operation_id
);
let mut url = url::Url::parse(url_str).map_err(cancel::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(cancel::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(cancel::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(cancel::Error::DefaultResponse { status_code }),
}
}
pub mod cancel {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_managed_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceOperationListResult, list_by_managed_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/operations",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_managed_instance::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_managed_instance::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_managed_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_managed_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceOperationListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_managed_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_managed_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_managed_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
operation_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceOperation, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/operations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
operation_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::ManagedInstanceOperation =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 server_azure_ad_administrators {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
administrator_name: &str,
) -> std::result::Result<models::ServerAzureAdAdministrator, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/administrators/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
administrator_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::ServerAzureAdAdministrator =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
server_name: &str,
administrator_name: &str,
parameters: &models::ServerAzureAdAdministrator,
) -> 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.Sql/servers/{}/administrators/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
administrator_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(parameters).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::ServerAzureAdAdministrator = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ServerAzureAdAdministrator = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerAzureAdAdministrator),
Accepted202,
Created201(models::ServerAzureAdAdministrator),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
server_name: &str,
administrator_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/administrators/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
administrator_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
server_name: &str,
) -> std::result::Result<models::AdministratorListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/administrators",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AdministratorListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 sync_groups {
use super::{models, API_VERSION};
pub async fn list_sync_database_ids(
operation_config: &crate::OperationConfig,
location_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncDatabaseIdListResult, list_sync_database_ids::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/syncDatabaseIds",
operation_config.base_path(),
subscription_id,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_sync_database_ids::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_sync_database_ids::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_sync_database_ids::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_sync_database_ids::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncDatabaseIdListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_sync_database_ids::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_sync_database_ids::Error::DefaultResponse { status_code }),
}
}
pub mod list_sync_database_ids {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 refresh_hub_schema(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<refresh_hub_schema::Response, refresh_hub_schema::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/refreshHubSchema",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name
);
let mut url = url::Url::parse(url_str).map_err(refresh_hub_schema::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(refresh_hub_schema::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(refresh_hub_schema::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(refresh_hub_schema::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(refresh_hub_schema::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(refresh_hub_schema::Response::Accepted202),
status_code => Err(refresh_hub_schema::Error::DefaultResponse { status_code }),
}
}
pub mod refresh_hub_schema {
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 },
#[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_hub_schemas(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncFullSchemaPropertiesListResult, list_hub_schemas::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/hubSchemas",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_hub_schemas::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_hub_schemas::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_hub_schemas::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_hub_schemas::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncFullSchemaPropertiesListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_hub_schemas::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_hub_schemas::Error::DefaultResponse { status_code }),
}
}
pub mod list_hub_schemas {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_logs(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
start_time: &str,
end_time: &str,
type_: &str,
continuation_token: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::SyncGroupLogListResult, list_logs::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/logs",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_logs::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_logs::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("startTime", start_time);
url.query_pairs_mut().append_pair("endTime", end_time);
url.query_pairs_mut().append_pair("type", type_);
if let Some(continuation_token) = continuation_token {
url.query_pairs_mut().append_pair("continuationToken", continuation_token);
}
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_logs::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_logs::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncGroupLogListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_logs::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_logs::Error::DefaultResponse { status_code }),
}
}
pub mod list_logs {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 cancel_sync(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<(), cancel_sync::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/cancelSync",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name
);
let mut url = url::Url::parse(url_str).map_err(cancel_sync::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(cancel_sync::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(cancel_sync::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(cancel_sync::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(cancel_sync::Error::DefaultResponse { status_code }),
}
}
pub mod cancel_sync {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 trigger_sync(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<(), trigger_sync::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/triggerSync",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name
);
let mut url = url::Url::parse(url_str).map_err(trigger_sync::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(trigger_sync::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(trigger_sync::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(trigger_sync::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => Err(trigger_sync::Error::DefaultResponse { status_code }),
}
}
pub mod trigger_sync {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_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::SyncGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
parameters: &models::SyncGroup,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/syncGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_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(parameters).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::SyncGroup = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SyncGroup = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SyncGroup),
Accepted202,
Created201(models::SyncGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
parameters: &models::SyncGroup,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_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(parameters).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::SyncGroup =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SyncGroup),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncGroupListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncGroupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 sync_members {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
sync_member_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncMember, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name,
sync_member_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::SyncMember =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
sync_member_name: &str,
parameters: &models::SyncMember,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name,
sync_member_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(parameters).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::SyncMember = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SyncMember = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SyncMember),
Accepted202,
Created201(models::SyncMember),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
sync_member_name: &str,
parameters: &models::SyncMember,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name,
sync_member_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(parameters).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::SyncMember =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SyncMember),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
sync_member_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name,
sync_member_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_sync_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncMemberListResult, list_by_sync_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_sync_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_sync_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_sync_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_sync_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncMemberListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_sync_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_sync_group::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_sync_group {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_member_schemas(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
sync_member_name: &str,
subscription_id: &str,
) -> std::result::Result<models::SyncFullSchemaPropertiesListResult, list_member_schemas::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers/{}/schemas",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
sync_group_name,
sync_member_name
);
let mut url = url::Url::parse(url_str).map_err(list_member_schemas::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_member_schemas::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_member_schemas::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_member_schemas::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SyncFullSchemaPropertiesListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_member_schemas::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_member_schemas::Error::DefaultResponse { status_code }),
}
}
pub mod list_member_schemas {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 refresh_member_schema(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
sync_group_name: &str,
sync_member_name: &str,
subscription_id: &str,
) -> std::result::Result<refresh_member_schema::Response, refresh_member_schema::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/syncGroups/{}/syncMembers/{}/refreshSchema" , operation_config . base_path () , subscription_id , resource_group_name , server_name , database_name , sync_group_name , sync_member_name) ;
let mut url = url::Url::parse(url_str).map_err(refresh_member_schema::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(refresh_member_schema::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(refresh_member_schema::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(refresh_member_schema::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(refresh_member_schema::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(refresh_member_schema::Response::Accepted202),
status_code => Err(refresh_member_schema::Error::DefaultResponse { status_code }),
}
}
pub mod refresh_member_schema {
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 },
#[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 import_export {
use super::{models, API_VERSION};
pub async fn import(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
parameters: &models::ImportExistingDatabaseDefinition,
subscription_id: &str,
) -> std::result::Result<import::Response, import::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/import",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(import::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(import::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(parameters).map_err(import::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(import::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(import::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ImportExportOperationResult =
serde_json::from_slice(rsp_body).map_err(|source| import::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(import::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(import::Response::Accepted202),
status_code => Err(import::Error::DefaultResponse { status_code }),
}
}
pub mod import {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ImportExportOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_databases {
use super::{models, API_VERSION};
pub async fn list_by_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedDatabaseListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedDatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedDatabase, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_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::ManagedDatabase =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
parameters: &models::ManagedDatabase,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_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(parameters).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::ManagedDatabase = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedDatabase = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedDatabase),
Accepted202,
Created201(models::ManagedDatabase),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
parameters: &models::ManagedDatabaseUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_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(parameters).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::ManagedDatabase =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedDatabase),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 complete_restore(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
parameters: &models::CompleteDatabaseRestoreDefinition,
subscription_id: &str,
) -> std::result::Result<complete_restore::Response, complete_restore::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/completeRestore",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(complete_restore::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(complete_restore::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(parameters).map_err(complete_restore::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(complete_restore::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(complete_restore::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(complete_restore::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(complete_restore::Response::Accepted202),
status_code => Err(complete_restore::Error::DefaultResponse { status_code }),
}
}
pub mod complete_restore {
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 },
#[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_inaccessible_by_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedDatabaseListResult, list_inaccessible_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/inaccessibleManagedDatabases",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_inaccessible_by_instance::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_inaccessible_by_instance::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_inaccessible_by_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_inaccessible_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedDatabaseListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_inaccessible_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_inaccessible_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_inaccessible_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_database_restore_details {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
database_name: &str,
restore_details_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedDatabaseRestoreDetailsResult, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/databases/{}/restoreDetails/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
database_name,
restore_details_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::ManagedDatabaseRestoreDetailsResult =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 server_azure_ad_only_authentications {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
authentication_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerAzureAdOnlyAuthentication, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/azureADOnlyAuthentications/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
authentication_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::ServerAzureAdOnlyAuthentication =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
authentication_name: &str,
parameters: &models::ServerAzureAdOnlyAuthentication,
subscription_id: &str,
) -> 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.Sql/servers/{}/azureADOnlyAuthentications/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
authentication_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(parameters).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::ServerAzureAdOnlyAuthentication = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ServerAzureAdOnlyAuthentication = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerAzureAdOnlyAuthentication),
Accepted202,
Created201(models::ServerAzureAdOnlyAuthentication),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
authentication_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/azureADOnlyAuthentications/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
authentication_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::AzureAdOnlyAuthListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/azureADOnlyAuthentications",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::AzureAdOnlyAuthListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 managed_instances {
use super::{models, API_VERSION};
pub async fn list_by_instance_pool(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
instance_pool_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceListResult, list_by_instance_pool::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/instancePools/{}/managedInstances",
operation_config.base_path(),
subscription_id,
resource_group_name,
instance_pool_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance_pool::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_instance_pool::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_instance_pool::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance_pool::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance_pool::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance_pool::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance_pool {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceListResult, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances",
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::ManagedInstanceListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstance, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_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::ManagedInstance =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
parameters: &models::ManagedInstance,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_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(parameters).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::ManagedInstance = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstance = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstance),
Accepted202,
Created201(models::ManagedInstance),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
resource_group_name: &str,
managed_instance_name: &str,
parameters: &models::ManagedInstanceUpdate,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_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(parameters).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::ManagedInstance =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstance),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_managed_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
number_of_queries: Option<i32>,
databases: Option<&str>,
start_time: Option<&str>,
end_time: Option<&str>,
interval: Option<&str>,
aggregation_function: Option<&str>,
observation_metric: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::TopQueriesListResult, list_by_managed_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/topqueries",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_managed_instance::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_managed_instance::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(number_of_queries) = number_of_queries {
url.query_pairs_mut()
.append_pair("numberOfQueries", number_of_queries.to_string().as_str());
}
if let Some(databases) = databases {
url.query_pairs_mut().append_pair("databases", databases);
}
if let Some(start_time) = start_time {
url.query_pairs_mut().append_pair("startTime", start_time);
}
if let Some(end_time) = end_time {
url.query_pairs_mut().append_pair("endTime", end_time);
}
if let Some(interval) = interval {
url.query_pairs_mut().append_pair("interval", interval);
}
if let Some(aggregation_function) = aggregation_function {
url.query_pairs_mut().append_pair("aggregationFunction", aggregation_function);
}
if let Some(observation_metric) = observation_metric {
url.query_pairs_mut().append_pair("observationMetric", observation_metric);
}
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_managed_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_managed_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TopQueriesListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_managed_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_managed_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_managed_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 failover(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
replica_type: Option<&str>,
subscription_id: &str,
) -> std::result::Result<failover::Response, failover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/failover",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(failover::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(failover::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(replica_type) = replica_type {
url.query_pairs_mut().append_pair("replicaType", replica_type);
}
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(failover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(failover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(failover::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(failover::Response::Accepted202),
status_code => Err(failover::Error::DefaultResponse { status_code }),
}
}
pub mod failover {
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 },
#[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,
) -> std::result::Result<models::ManagedInstanceListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/managedInstances",
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::ManagedInstanceListResult =
serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list::Error::DefaultResponse { status_code }),
}
}
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 },
#[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 managed_instance_azure_ad_only_authentications {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
authentication_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceAzureAdOnlyAuthentication, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/azureADOnlyAuthentications/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
authentication_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::ManagedInstanceAzureAdOnlyAuthentication =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
managed_instance_name: &str,
authentication_name: &str,
parameters: &models::ManagedInstanceAzureAdOnlyAuthentication,
subscription_id: &str,
) -> 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.Sql/managedInstances/{}/azureADOnlyAuthentications/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
authentication_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(parameters).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::ManagedInstanceAzureAdOnlyAuthentication = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceAzureAdOnlyAuthentication = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ManagedInstanceAzureAdOnlyAuthentication),
Accepted202,
Created201(models::ManagedInstanceAzureAdOnlyAuthentication),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
managed_instance_name: &str,
authentication_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/azureADOnlyAuthentications/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name,
authentication_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ManagedInstanceAzureAdOnlyAuthListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/azureADOnlyAuthentications",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ManagedInstanceAzureAdOnlyAuthListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 server_trust_groups {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
server_trust_group_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerTrustGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/serverTrustGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
server_trust_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::ServerTrustGroup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
location_name: &str,
server_trust_group_name: &str,
parameters: &models::ServerTrustGroup,
subscription_id: &str,
) -> 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.Sql/locations/{}/serverTrustGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
server_trust_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(parameters).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::ServerTrustGroup = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::ServerTrustGroup = 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 => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerTrustGroup),
Accepted202,
Created201(models::ServerTrustGroup),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
location_name: &str,
server_trust_group_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/serverTrustGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name,
server_trust_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_location(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerTrustGroupListResult, list_by_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/serverTrustGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_location::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_location::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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerTrustGroupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_instance(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
managed_instance_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerTrustGroupListResult, list_by_instance::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/managedInstances/{}/serverTrustGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
managed_instance_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_instance::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_instance::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_instance::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_instance::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerTrustGroupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_instance::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_instance::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_instance {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 server_dev_ops_audit_settings {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
dev_ops_auditing_settings_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerDevOpsAuditingSettings, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/devOpsAuditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
dev_ops_auditing_settings_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::ServerDevOpsAuditingSettings =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
dev_ops_auditing_settings_name: &str,
parameters: &models::ServerDevOpsAuditingSettings,
subscription_id: &str,
) -> 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.Sql/servers/{}/devOpsAuditingSettings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
dev_ops_auditing_settings_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(parameters).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::ServerDevOpsAuditingSettings = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::ServerDevOpsAuditingSettings),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ServerDevOpsAuditSettingsListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/devOpsAuditingSettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ServerDevOpsAuditSettingsListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 long_term_retention_backups {
use super::{models, API_VERSION};
pub async fn copy(
operation_config: &crate::OperationConfig,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
parameters: &models::CopyLongTermRetentionBackupParameters,
subscription_id: &str,
) -> std::result::Result<copy::Response, copy::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}/copy" , operation_config . base_path () , subscription_id , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(copy::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(copy::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(parameters).map_err(copy::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(copy::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(copy::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupOperationResult =
serde_json::from_slice(rsp_body).map_err(|source| copy::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(copy::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(copy::Response::Accepted202),
status_code => Err(copy::Error::DefaultResponse { status_code }),
}
}
pub mod copy {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::LongTermRetentionBackupOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
parameters: &models::UpdateLongTermRetentionBackupParameters,
subscription_id: &str,
) -> std::result::Result<update::Response, update::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}/update" , operation_config . base_path () , subscription_id , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_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::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::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(parameters).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::LongTermRetentionBackupOperationResult =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
status_code => Err(update::Error::DefaultResponse { status_code }),
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::LongTermRetentionBackupOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackup, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}" , operation_config . base_path () , subscription_id , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_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::LongTermRetentionBackup =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}" , operation_config . base_path () , subscription_id , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_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),
status_code => Err(delete::Error::DefaultResponse { status_code }),
}
}
pub mod delete {
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 },
#[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_database(
operation_config: &crate::OperationConfig,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackupListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups" , operation_config . base_path () , subscription_id , location_name , long_term_retention_server_name , long_term_retention_database_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_location(
operation_config: &crate::OperationConfig,
location_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackupListResult, list_by_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionBackups",
operation_config.base_path(),
subscription_id,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_location::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_location::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
location_name: &str,
long_term_retention_server_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackupListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionBackups",
operation_config.base_path(),
subscription_id,
location_name,
long_term_retention_server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 copy_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
parameters: &models::CopyLongTermRetentionBackupParameters,
subscription_id: &str,
) -> std::result::Result<copy_by_resource_group::Response, copy_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}/copy" , operation_config . base_path () , subscription_id , resource_group_name , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(copy_by_resource_group::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(copy_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);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(parameters).map_err(copy_by_resource_group::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(copy_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(copy_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupOperationResult = serde_json::from_slice(rsp_body)
.map_err(|source| copy_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(copy_by_resource_group::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(copy_by_resource_group::Response::Accepted202),
status_code => Err(copy_by_resource_group::Error::DefaultResponse { status_code }),
}
}
pub mod copy_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::LongTermRetentionBackupOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
parameters: &models::UpdateLongTermRetentionBackupParameters,
subscription_id: &str,
) -> std::result::Result<update_by_resource_group::Response, update_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}/update" , operation_config . base_path () , subscription_id , resource_group_name , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(update_by_resource_group::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_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);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(parameters).map_err(update_by_resource_group::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupOperationResult = serde_json::from_slice(rsp_body)
.map_err(|source| update_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_by_resource_group::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => Ok(update_by_resource_group::Response::Accepted202),
status_code => Err(update_by_resource_group::Error::DefaultResponse { status_code }),
}
}
pub mod update_by_resource_group {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::LongTermRetentionBackupOperationResult),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackup, get_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}" , operation_config . base_path () , subscription_id , resource_group_name , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(get_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(get_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(get_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackup = serde_json::from_slice(rsp_body)
.map_err(|source| get_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get_by_resource_group::Error::DefaultResponse { status_code }),
}
}
pub mod get_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 },
#[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_by_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
backup_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_by_resource_group::Response, delete_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups/{}" , operation_config . base_path () , subscription_id , resource_group_name , location_name , long_term_retention_server_name , long_term_retention_database_name , backup_name) ;
let mut url = url::Url::parse(url_str).map_err(delete_by_resource_group::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_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(delete_by_resource_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_by_resource_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_by_resource_group::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(delete_by_resource_group::Response::Accepted202),
status_code => Err(delete_by_resource_group::Error::DefaultResponse { status_code }),
}
}
pub mod delete_by_resource_group {
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 },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
long_term_retention_server_name: &str,
long_term_retention_database_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackupListResult, list_by_resource_group_database::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionDatabases/{}/longTermRetentionBackups" , operation_config . base_path () , subscription_id , resource_group_name , location_name , long_term_retention_server_name , long_term_retention_database_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_database::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_database::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_resource_group_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_location(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackupListResult, list_by_resource_group_location::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionBackups",
operation_config.base_path(),
subscription_id,
resource_group_name,
location_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_location::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_location::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_location::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_location::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_location::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group_location::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_resource_group_location {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
location_name: &str,
long_term_retention_server_name: &str,
only_latest_per_database: Option<bool>,
database_state: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionBackupListResult, list_by_resource_group_server::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/locations/{}/longTermRetentionServers/{}/longTermRetentionBackups" , operation_config . base_path () , subscription_id , resource_group_name , location_name , long_term_retention_server_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group_server::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_server::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(only_latest_per_database) = only_latest_per_database {
url.query_pairs_mut()
.append_pair("onlyLatestPerDatabase", only_latest_per_database.to_string().as_str());
}
if let Some(database_state) = database_state {
url.query_pairs_mut().append_pair("databaseState", database_state);
}
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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_resource_group_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionBackupListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_resource_group_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_resource_group_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 long_term_retention_policies {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
policy_name: &str,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionPolicy, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/backupLongTermRetentionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
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::LongTermRetentionPolicy =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
database_name: &str,
policy_name: &str,
parameters: &models::LongTermRetentionPolicy,
subscription_id: &str,
) -> 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.Sql/servers/{}/databases/{}/backupLongTermRetentionPolicies/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name,
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(parameters).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::LongTermRetentionPolicy = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::LongTermRetentionPolicy),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_database(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
database_name: &str,
subscription_id: &str,
) -> std::result::Result<models::LongTermRetentionPolicyListResult, list_by_database::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/databases/{}/backupLongTermRetentionPolicies",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
database_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_database::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_database::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_database::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_database::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::LongTermRetentionPolicyListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_database::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_database {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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 private_endpoint_connections {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
private_endpoint_connection_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PrivateEndpointConnection, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/privateEndpointConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
private_endpoint_connection_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::PrivateEndpointConnection =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(get::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_group_name: &str,
server_name: &str,
private_endpoint_connection_name: &str,
parameters: &models::PrivateEndpointConnection,
subscription_id: &str,
) -> 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.Sql/servers/{}/privateEndpointConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
private_endpoint_connection_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(parameters).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::PrivateEndpointConnection = 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::ACCEPTED => Ok(create_or_update::Response::Accepted202),
status_code => Err(create_or_update::Error::DefaultResponse { status_code }),
}
}
pub mod create_or_update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::PrivateEndpointConnection),
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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_group_name: &str,
server_name: &str,
private_endpoint_connection_name: &str,
subscription_id: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/privateEndpointConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name,
private_endpoint_connection_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 => Err(delete::Error::DefaultResponse { status_code }),
}
}
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 },
#[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_server(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
server_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PrivateEndpointConnectionListResult, list_by_server::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Sql/servers/{}/privateEndpointConnections",
operation_config.base_path(),
subscription_id,
resource_group_name,
server_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_server::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_server::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_server::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_server::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PrivateEndpointConnectionListResult =
serde_json::from_slice(rsp_body).map_err(|source| list_by_server::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => Err(list_by_server::Error::DefaultResponse { status_code }),
}
}
pub mod list_by_server {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("HTTP status code {}", status_code)]
DefaultResponse { status_code: http::StatusCode },
#[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),
}
}
}
|
use parser::ast::visitor::{ResultCombineErr, Visitable, Visitor, VisitorResult, VisitorResultVec};
use parser::ast::*;
use std::fmt::{self, Display, Formatter};
#[derive(Debug)]
pub struct SemanticVerifier {
globals: Vec<Declaration>,
locals: Vec<String>,
}
impl SemanticVerifier {
pub fn new() -> SemanticVerifier {
SemanticVerifier {
globals: vec![],
locals: vec![],
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum Error {
InvalidArrayRange { name: String, start: i64, end: i64 },
UndeclaredVariable { name: String },
ForCounterModification { name: String },
InvalidVariableUsage { name: String },
}
impl Display for Error {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
use Error::*;
match self {
InvalidArrayRange { name, start, end } => write!(f, "invalid array range: {}({}:{})", name, start, end),
UndeclaredVariable { name } => write!(f, "undeclared variable {}", name),
ForCounterModification { name } => write!(f, "illegal modification of for loop counter {}", name),
InvalidVariableUsage { name } => write!(f, "invalid variable usage: {}", name),
}
}
}
pub fn verify(program: Program) -> Result<Program, Vec<Error>> {
let mut verifier = SemanticVerifier::new();
let result = program.accept(&mut verifier);
result.into_result().map(|_| program).map_err(|v| v.into_vec())
}
impl SemanticVerifier {
fn get_global(&self, name: &str) -> Option<&Declaration> {
self.globals.iter().find(|&global| global.name() == name)
}
fn get_local(&self, name: &str) -> Option<&str> {
self.locals
.iter()
.find(|&local| local == name)
.map(|s| s.as_str())
}
fn check_modification(&self, name: &str) -> Result<(), Error> {
self.get_local(name)
.map_or(
Ok(()),
|_| {
Err(Error::ForCounterModification {
name: name.to_owned(),
})
}
)
}
fn check_var_usage(&self, name: &str) -> Result<(), Error> {
self.get_global(name)
.map(|g| {
match g {
Declaration::Var { .. } => Ok(()),
Declaration::Array { .. } => Err(Error::InvalidVariableUsage { name: name.to_owned() }),
}
})
.unwrap_or(Ok(()))
}
fn check_array_usage(&self, name: &str) -> Result<(), Error> {
self.get_global(name)
.map(|g| {
match g {
Declaration::Var { .. } => Err(Error::InvalidVariableUsage { name: name.to_owned() }.into()),
Declaration::Array { .. } => Ok(()),
}
})
.unwrap_or_else(|| {
self.get_local(name)
.map(|_| Err(Error::InvalidVariableUsage { name: name.to_owned() }.into()))
.unwrap_or(Ok(()))
})
}
fn check_identifier_usage(&self, identifier: &Identifier) -> <Self as Visitor>::Result {
match identifier {
Identifier::VarAccess { name } => {
self.check_var_usage(name).map_err(Into::into).into()
},
Identifier::ArrAccess { name, index } => {
let main: ResultCombineErr<_, _> = self.check_array_usage(name).map_err(Into::into).into();
main.combine(
self.get_global(index)
.map(|g| {
match g {
Declaration::Var { .. } => Ok(()),
Declaration::Array { .. } => Err(Error::InvalidVariableUsage { name: name.to_owned() }.into()),
}
})
.unwrap_or(Ok(()))
.into()
)
},
Identifier::ArrConstAccess { name, index } => {
self.get_global(name)
.map(|g| {
match g {
Declaration::Var { .. } => Err(Error::InvalidVariableUsage { name: name.to_owned() }.into()),
Declaration::Array { start, end, .. } => {
if index >= start && index <= end {
Ok(())
} else {
Err(Error::InvalidVariableUsage { name: name.to_owned() }.into())
}
},
}
})
.unwrap_or_else(|| {
self.get_local(name)
.map(|_| Err(Error::InvalidVariableUsage { name: name.to_owned() }.into()))
.unwrap_or(Ok(()))
}).into()
},
}
}
}
impl<'a> Visitor for SemanticVerifier {
type Result = ResultCombineErr<(), VisitorResultVec<Error>>;
fn visit_declarations(&mut self, declarations: &Declarations) -> Self::Result {
let results = declarations
.iter()
.map(|declaration| self.visit(declaration));
let res = Self::Result::combine_collection(results);
self.globals = declarations.clone();
res
}
fn visit_declaration(&mut self, declaration: &Declaration) -> Self::Result {
match declaration {
Declaration::Var { .. } => Self::Result::identity(),
Declaration::Array { name, start, end } => {
if start > end {
Err(Error::InvalidArrayRange {
name: name.clone(),
start: *start,
end: *end,
}
.into())
.into()
} else {
Self::Result::identity()
}
}
}
}
fn visit_for_command(
&mut self,
counter: &str,
_ascending: bool,
from: &Value,
to: &Value,
commands: &Commands,
) -> Self::Result {
let result = self.visit(from).combine(self.visit(to));
self.locals.push(counter.to_string());
let result = result.combine(self.visit_commands(commands));
self.locals.pop();
result
}
fn visit_read_command(&mut self, target: &Identifier) -> Self::Result {
self.visit(target)
.combine(self.check_modification(target.name()).map_err(Into::into).into())
}
fn visit_assign_command(&mut self, target: &Identifier, expr: &Expression) -> Self::Result {
self.visit(target)
.combine(self.check_modification(target.name()).map_err(Into::into).into())
.combine(self.visit(expr))
}
fn visit_num_value(&mut self, _: i64) -> Self::Result {
// nothing to be done - allow anything
Self::Result::identity()
}
fn visit_identifier(&mut self, identifier: &Identifier) -> Self::Result {
let results = identifier.all_names().into_iter().map(|name| {
self.get_global(name)
.map(|_| ())
.or_else(|| self.get_local(name).map(|_| ()))
.ok_or(
Error::UndeclaredVariable {
name: name.to_owned(),
}
.into(),
)
.into()
});
let undeclared = Self::Result::combine_collection(results);
let usage = self.check_identifier_usage(identifier);
undeclared.combine(usage)
}
}
|
#![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)]
NetworkManagers_Get(#[from] network_managers::get::Error),
#[error(transparent)]
NetworkManagers_CreateOrUpdate(#[from] network_managers::create_or_update::Error),
#[error(transparent)]
NetworkManagers_PatchTags(#[from] network_managers::patch_tags::Error),
#[error(transparent)]
NetworkManagers_Delete(#[from] network_managers::delete::Error),
#[error(transparent)]
NetworkManagerCommits_Post(#[from] network_manager_commits::post::Error),
#[error(transparent)]
NetworkManagerDeploymentStatus_List(#[from] network_manager_deployment_status::list::Error),
#[error(transparent)]
NetworkManagers_ListBySubscription(#[from] network_managers::list_by_subscription::Error),
#[error(transparent)]
NetworkManagers_List(#[from] network_managers::list::Error),
#[error(transparent)]
EffectiveVirtualNetworks_ListByNetworkManager(#[from] effective_virtual_networks::list_by_network_manager::Error),
#[error(transparent)]
NetworkGroups_Get(#[from] network_groups::get::Error),
#[error(transparent)]
NetworkGroups_CreateOrUpdate(#[from] network_groups::create_or_update::Error),
#[error(transparent)]
NetworkGroups_Delete(#[from] network_groups::delete::Error),
#[error(transparent)]
NetworkGroups_List(#[from] network_groups::list::Error),
#[error(transparent)]
EffectiveVirtualNetworks_ListByNetworkGroup(#[from] effective_virtual_networks::list_by_network_group::Error),
#[error(transparent)]
ActiveConnectivityConfigurations_List(#[from] active_connectivity_configurations::list::Error),
#[error(transparent)]
ActiveSecurityAdminRules_List(#[from] active_security_admin_rules::list::Error),
#[error(transparent)]
ActiveSecurityUserRules_List(#[from] active_security_user_rules::list::Error),
#[error(transparent)]
EffectiveConnectivityConfigurations_List(#[from] effective_connectivity_configurations::list::Error),
#[error(transparent)]
NetworkManagerEffectiveSecurityAdminRules_List(#[from] network_manager_effective_security_admin_rules::list::Error),
#[error(transparent)]
ConnectivityConfigurations_Get(#[from] connectivity_configurations::get::Error),
#[error(transparent)]
ConnectivityConfigurations_CreateOrUpdate(#[from] connectivity_configurations::create_or_update::Error),
#[error(transparent)]
ConnectivityConfigurations_Delete(#[from] connectivity_configurations::delete::Error),
#[error(transparent)]
ConnectivityConfigurations_List(#[from] connectivity_configurations::list::Error),
#[error(transparent)]
SecurityAdminConfigurations_List(#[from] security_admin_configurations::list::Error),
#[error(transparent)]
SecurityAdminConfigurations_Get(#[from] security_admin_configurations::get::Error),
#[error(transparent)]
SecurityAdminConfigurations_CreateOrUpdate(#[from] security_admin_configurations::create_or_update::Error),
#[error(transparent)]
SecurityAdminConfigurations_Delete(#[from] security_admin_configurations::delete::Error),
#[error(transparent)]
AdminRuleCollections_List(#[from] admin_rule_collections::list::Error),
#[error(transparent)]
AdminRuleCollections_Get(#[from] admin_rule_collections::get::Error),
#[error(transparent)]
AdminRuleCollections_CreateOrUpdate(#[from] admin_rule_collections::create_or_update::Error),
#[error(transparent)]
AdminRuleCollections_Delete(#[from] admin_rule_collections::delete::Error),
#[error(transparent)]
AdminRules_List(#[from] admin_rules::list::Error),
#[error(transparent)]
AdminRules_Get(#[from] admin_rules::get::Error),
#[error(transparent)]
AdminRules_CreateOrUpdate(#[from] admin_rules::create_or_update::Error),
#[error(transparent)]
AdminRules_Delete(#[from] admin_rules::delete::Error),
#[error(transparent)]
SecurityUserConfigurations_List(#[from] security_user_configurations::list::Error),
#[error(transparent)]
SecurityUserConfigurations_Get(#[from] security_user_configurations::get::Error),
#[error(transparent)]
SecurityUserConfigurations_CreateOrUpdate(#[from] security_user_configurations::create_or_update::Error),
#[error(transparent)]
SecurityUserConfigurations_Delete(#[from] security_user_configurations::delete::Error),
#[error(transparent)]
UserRuleCollections_List(#[from] user_rule_collections::list::Error),
#[error(transparent)]
UserRuleCollections_Get(#[from] user_rule_collections::get::Error),
#[error(transparent)]
UserRuleCollections_CreateOrUpdate(#[from] user_rule_collections::create_or_update::Error),
#[error(transparent)]
UserRuleCollections_Delete(#[from] user_rule_collections::delete::Error),
#[error(transparent)]
UserRules_List(#[from] user_rules::list::Error),
#[error(transparent)]
UserRules_Get(#[from] user_rules::get::Error),
#[error(transparent)]
UserRules_CreateOrUpdate(#[from] user_rules::create_or_update::Error),
#[error(transparent)]
UserRules_Delete(#[from] user_rules::delete::Error),
#[error(transparent)]
NetworkSecurityPerimeters_Get(#[from] network_security_perimeters::get::Error),
#[error(transparent)]
NetworkSecurityPerimeters_CreateOrUpdate(#[from] network_security_perimeters::create_or_update::Error),
#[error(transparent)]
NetworkSecurityPerimeters_Delete(#[from] network_security_perimeters::delete::Error),
#[error(transparent)]
NetworkSecurityPerimeters_ListBySubscription(#[from] network_security_perimeters::list_by_subscription::Error),
#[error(transparent)]
NetworkSecurityPerimeters_List(#[from] network_security_perimeters::list::Error),
#[error(transparent)]
PerimeterAssociableResourceTypes_Get(#[from] perimeter_associable_resource_types::get::Error),
}
pub mod network_managers {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
) -> std::result::Result<models::NetworkManager, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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::NetworkManager =
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,
network_manager_name: &str,
parameters: &models::NetworkManager,
) -> 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.Network/networkManagers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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(parameters).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::NetworkManager = 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::NetworkManager = 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::NetworkManager),
Created201(models::NetworkManager),
}
#[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 patch_tags(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
parameters: &models::TagsObject,
) -> std::result::Result<models::NetworkManager, patch_tags::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name
);
let mut url = url::Url::parse(url_str).map_err(patch_tags::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(patch_tags::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(parameters).map_err(patch_tags::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(patch_tags::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(patch_tags::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::NetworkManager =
serde_json::from_slice(rsp_body).map_err(|source| patch_tags::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| patch_tags::Error::DeserializeError(source, rsp_body.clone()))?;
Err(patch_tags::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod patch_tags {
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,
network_manager_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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_subscription(
operation_config: &crate::OperationConfig,
subscription_id: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::NetworkManagerListResult, list_by_subscription::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Network/networkManagers",
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);
if let Some(top) = top {
url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::NetworkManagerListResult = 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 list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::NetworkManagerListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers",
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(top) = top {
url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::NetworkManagerListResult =
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 network_manager_commits {
use super::{models, API_VERSION};
pub async fn post(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
parameters: &models::NetworkManagerCommit,
) -> std::result::Result<models::NetworkManagerCommit, post::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/commit",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name
);
let mut url = url::Url::parse(url_str).map_err(post::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(post::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(parameters).map_err(post::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(post::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(post::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::NetworkManagerCommit =
serde_json::from_slice(rsp_body).map_err(|source| post::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| post::Error::DeserializeError(source, rsp_body.clone()))?;
Err(post::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod post {
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 network_manager_deployment_status {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
parameters: &models::NetworkManagerDeploymentStatusParameter,
) -> std::result::Result<models::NetworkManagerDeploymentStatusListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/listDeploymentStatus",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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::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::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(parameters).map_err(list::Error::SerializeError)?;
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::NetworkManagerDeploymentStatusListResult =
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 effective_virtual_networks {
use super::{models, API_VERSION};
pub async fn list_by_network_manager(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
parameters: &models::EffectiveVirtualNetworksParameter,
) -> std::result::Result<models::EffectiveVirtualNetworksListResult, list_by_network_manager::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/listEffectiveVirtualNetworks",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_network_manager::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_by_network_manager::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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(parameters).map_err(list_by_network_manager::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_network_manager::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_network_manager::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::EffectiveVirtualNetworksListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_network_manager::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_network_manager::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_network_manager::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_network_manager {
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_network_group(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
network_group_name: &str,
parameters: &models::QueryRequestOptions,
) -> std::result::Result<models::EffectiveVirtualNetworksListResult, list_by_network_group::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/networkGroups/{}/listEffectiveVirtualNetworks" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , network_group_name) ;
let mut url = url::Url::parse(url_str).map_err(list_by_network_group::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_by_network_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);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(parameters).map_err(list_by_network_group::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_by_network_group::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_by_network_group::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::EffectiveVirtualNetworksListResult = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_network_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_network_group::Error::DeserializeError(source, rsp_body.clone()))?;
Err(list_by_network_group::Error::DefaultResponse {
status_code,
value: rsp_value,
})
}
}
}
pub mod list_by_network_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 mod network_groups {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
network_group_name: &str,
) -> std::result::Result<models::NetworkGroup, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/networkGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
network_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::NetworkGroup =
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,
network_manager_name: &str,
network_group_name: &str,
parameters: &models::NetworkGroup,
if_match: Option<&str>,
) -> 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.Network/networkManagers/{}/networkGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
network_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(parameters).map_err(create_or_update::Error::SerializeError)?;
if let Some(if_match) = if_match {
req_builder = req_builder.header("If-Match", if_match);
}
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::NetworkGroup = 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::NetworkGroup = 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::NetworkGroup),
Created201(models::NetworkGroup),
}
#[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,
network_manager_name: &str,
network_group_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/networkGroups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
network_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 async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::NetworkGroupListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/networkGroups",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::NetworkGroupListResult =
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 active_connectivity_configurations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
parameters: &models::ActiveConfigurationParameter,
) -> std::result::Result<models::ActiveConnectivityConfigurationsListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/listActiveConnectivityConfigurations",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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::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::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(parameters).map_err(list::Error::SerializeError)?;
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::ActiveConnectivityConfigurationsListResult =
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 active_security_admin_rules {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
parameters: &models::ActiveConfigurationParameter,
) -> std::result::Result<models::ActiveSecurityAdminRulesListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/listActiveSecurityAdminRules",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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::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::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(parameters).map_err(list::Error::SerializeError)?;
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::ActiveSecurityAdminRulesListResult =
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 active_security_user_rules {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
parameters: &models::ActiveConfigurationParameter,
) -> std::result::Result<models::ActiveSecurityUserRulesListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/listActiveSecurityUserRules",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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::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::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(parameters).map_err(list::Error::SerializeError)?;
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::ActiveSecurityUserRulesListResult =
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 effective_connectivity_configurations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
virtual_network_name: &str,
parameters: &models::QueryRequestOptions,
) -> std::result::Result<models::NetworkManagerEffectiveConnectivityConfigurationListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/listNetworkManagerEffectiveConnectivityConfigurations" , operation_config . base_path () , subscription_id , resource_group_name , virtual_network_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::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::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(parameters).map_err(list::Error::SerializeError)?;
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::NetworkManagerEffectiveConnectivityConfigurationListResult =
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 network_manager_effective_security_admin_rules {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
virtual_network_name: &str,
parameters: &models::QueryRequestOptions,
) -> std::result::Result<models::NetworkManagerEffectiveSecurityAdminRulesListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/virtualNetworks/{}/listNetworkManagerEffectiveSecurityAdminRules" , operation_config . base_path () , subscription_id , resource_group_name , virtual_network_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::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::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(parameters).map_err(list::Error::SerializeError)?;
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::NetworkManagerEffectiveSecurityAdminRulesListResult =
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 connectivity_configurations {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
) -> std::result::Result<models::ConnectivityConfiguration, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/connectivityConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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::ConnectivityConfiguration =
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,
network_manager_name: &str,
configuration_name: &str,
connectivity_configuration: &models::ConnectivityConfiguration,
) -> 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.Network/networkManagers/{}/connectivityConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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(connectivity_configuration).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::ConnectivityConfiguration = 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::ConnectivityConfiguration = 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::ConnectivityConfiguration),
Created201(models::ConnectivityConfiguration),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/connectivityConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::ConnectivityConfigurationListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/connectivityConfigurations",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::ConnectivityConfigurationListResult =
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 security_admin_configurations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::SecurityConfigurationListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::SecurityConfigurationListResult =
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,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
) -> std::result::Result<models::SecurityConfiguration, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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::SecurityConfiguration =
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,
network_manager_name: &str,
configuration_name: &str,
security_admin_configuration: &models::SecurityConfiguration,
) -> 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.Network/networkManagers/{}/securityAdminConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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_admin_configuration).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::SecurityConfiguration = 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::SecurityConfiguration = 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::SecurityConfiguration),
Created201(models::SecurityConfiguration),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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 admin_rule_collections {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::RuleCollectionListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::RuleCollectionListResult =
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,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
) -> std::result::Result<models::RuleCollection, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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::RuleCollection =
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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_collection: &models::RuleCollection,
) -> 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.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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(rule_collection).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::RuleCollection = 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::RuleCollection = 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::RuleCollection),
Created201(models::RuleCollection),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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 admin_rules {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::AdminRuleListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}/rules" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::AdminRuleListResult =
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,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_name: &str,
) -> std::result::Result<models::BaseAdminRule, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}/rules/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_name , 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::BaseAdminRule =
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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_name: &str,
admin_rule: &models::BaseAdminRule,
) -> 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.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}/rules/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_name , rule_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(admin_rule).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::BaseAdminRule = 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::BaseAdminRule = 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::BaseAdminRule),
Created201(models::BaseAdminRule),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityAdminConfigurations/{}/ruleCollections/{}/rules/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_name , 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::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 security_user_configurations {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::SecurityConfigurationListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::SecurityConfigurationListResult =
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,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
) -> std::result::Result<models::SecurityConfiguration, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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::SecurityConfiguration =
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,
network_manager_name: &str,
configuration_name: &str,
security_user_configuration: &models::SecurityConfiguration,
) -> 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.Network/networkManagers/{}/securityUserConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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_user_configuration).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::SecurityConfiguration = 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::SecurityConfiguration = 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::SecurityConfiguration),
Created201(models::SecurityConfiguration),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_manager_name,
configuration_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 user_rule_collections {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::RuleCollectionListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::RuleCollectionListResult =
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,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
) -> std::result::Result<models::RuleCollection, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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::RuleCollection =
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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
user_rule_collection: &models::RuleCollection,
) -> 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.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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(user_rule_collection).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::RuleCollection = 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::RuleCollection = 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::RuleCollection),
Created201(models::RuleCollection),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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 user_rules {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::UserRuleListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}/rules" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_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());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::UserRuleListResult =
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,
resource_group_name: &str,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_name: &str,
) -> std::result::Result<models::BaseUserRule, get::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}/rules/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_name , 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::BaseUserRule =
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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_name: &str,
user_rule: &models::BaseUserRule,
) -> 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.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}/rules/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_name , rule_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(user_rule).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::BaseUserRule = 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::BaseUserRule = 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::BaseUserRule),
Created201(models::BaseUserRule),
}
#[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,
network_manager_name: &str,
configuration_name: &str,
rule_collection_name: &str,
rule_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkManagers/{}/securityUserConfigurations/{}/ruleCollections/{}/rules/{}" , operation_config . base_path () , subscription_id , resource_group_name , network_manager_name , configuration_name , rule_collection_name , 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::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 network_security_perimeters {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
network_security_perimeter_name: &str,
) -> std::result::Result<models::NetworkSecurityPerimeter, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkSecurityPerimeters/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_security_perimeter_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::NetworkSecurityPerimeter =
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,
network_security_perimeter_name: &str,
parameters: &models::NetworkSecurityPerimeter,
) -> 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.Network/networkSecurityPerimeters/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_security_perimeter_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(parameters).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::NetworkSecurityPerimeter = 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::NetworkSecurityPerimeter = 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::NetworkSecurityPerimeter),
Created201(models::NetworkSecurityPerimeter),
}
#[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,
network_security_perimeter_name: &str,
) -> std::result::Result<delete::Response, delete::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkSecurityPerimeters/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
network_security_perimeter_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_subscription(
operation_config: &crate::OperationConfig,
subscription_id: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::NetworkSecurityPerimeterListResult, list_by_subscription::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Network/networkSecurityPerimeters",
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);
if let Some(top) = top {
url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::NetworkSecurityPerimeterListResult = 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 list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
resource_group_name: &str,
top: Option<i32>,
skip_token: Option<&str>,
) -> std::result::Result<models::NetworkSecurityPerimeterListResult, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Network/networkSecurityPerimeters",
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(top) = top {
url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
}
if let Some(skip_token) = skip_token {
url.query_pairs_mut().append_pair("$skipToken", skip_token);
}
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::NetworkSecurityPerimeterListResult =
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 perimeter_associable_resource_types {
use super::{models, API_VERSION};
pub async fn get(
operation_config: &crate::OperationConfig,
subscription_id: &str,
location: &str,
) -> std::result::Result<models::PerimeterAssociableResourcesListResult, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Network/locations/{}/perimeterAssociableResourceTypes",
operation_config.base_path(),
subscription_id,
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::PerimeterAssociableResourcesListResult =
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),
}
}
}
|
extern crate reqwest;
extern crate hmac;
extern crate sha2;
extern crate hex;
extern crate serde;
extern crate serde_derive;
use serde_derive::{Serialize, Deserialize};
use sha2::Sha256;
use hmac::{Hmac, Mac};
use std::time::{SystemTime, UNIX_EPOCH};
use reqwest::header;
pub struct Binance{
api_key: String,
secret_key: String,
}
#[derive(Debug)]
pub struct Ticker{
pub symbol: String,
pub price: f32,
}
#[derive(Debug)]
pub struct Balance{
asset: String,
free: f32,
locked: f32,
}
#[derive(Serialize, Deserialize)]
struct BalanceRaw {
asset: String,
free: String,
locked: String,
}
#[derive(Serialize, Deserialize)]
struct BalancesRaw {
balances: Vec<BalanceRaw>,
}
#[derive(Serialize, Deserialize)]
struct TickerRaw{
symbol: String,
price: String,
}
type HmacSha256 = Hmac<Sha256>;
impl Binance {
pub fn new(api_key: String, secret_key: String) -> Binance {
Binance{api_key, secret_key}
}
pub fn get_balances(&self) -> Vec<Balance> {
let body = self.get_response("/account", "", true);
let res: BalancesRaw = serde_json::from_str(&body).unwrap();
res.balances
.iter()
.filter_map(|x| {
let free = x.free.parse::<f32>().unwrap();
let locked = x.locked.parse::<f32>().unwrap();
if free > 0.0 || locked > 0.0 {
return Some(Balance{asset: x.asset.clone(), free, locked});
}
None
})
.collect::<Vec<Balance>>()
}
pub fn get_tickers(&self) -> Vec<Ticker> {
let body = self.get_response("/ticker/price", "", false);
let res: Vec<TickerRaw> = serde_json::from_str(&body).unwrap();
res
.iter()
.map(|x| Ticker{
symbol: x.symbol.clone(),
price: x.price.parse::<f32>().unwrap(),
})
.collect::<Vec<Ticker>>()
}
fn format_request(&self, path: &str, query: &str) -> String {
let mut mac = HmacSha256::new_varkey(self.secret_key.as_bytes()).expect("HMAC error");
let start = SystemTime::now();
let ts = start.duration_since(UNIX_EPOCH).expect("Time error");
let ts = ts.as_secs() * 1000 + ts.subsec_nanos() as u64 / 1_000_000;
let input = query.to_owned() + "×tamp=" + &ts.to_string().to_owned();
mac.input(input.as_bytes());
let result = mac.result();
let code_bytes = result.code();
path.to_string()
+ &"?".to_string()
+ &input
+ &"&signature=".to_string()
+ &hex::encode(code_bytes)
}
fn get_response(&self, path: &str, query: &str, sign_request: bool) -> String {
let uri = "https://api.binance.com/api/v3".to_string();
let mut headers = header::HeaderMap::new();
headers.insert("X-MBX-APIKEY", header::HeaderValue::from_str(&self.api_key.to_owned()).unwrap());
let client = reqwest::Client::builder()
.default_headers(headers)
.build()
.unwrap();
let url = if sign_request {uri + &self.format_request(path, query)} else {uri + &path};
client.get(&url)
.send()
.unwrap()
.text()
.unwrap()
}
}
|
//! This module implements helpers for generating tfrecord files for object detection.
use std::collections::HashMap;
use std::fs::{self, OpenOptions};
use std::io::{BufWriter, Error as IoError};
use std::mem;
use std::path::Path;
use protobuf::Message;
use tensorflow::io::RecordWriter;
use thiserror::Error;
use super::label_map::LabelMap;
use super::parser::Annotation;
use crate::math;
use crate::tensorflow_protos::example::Example;
use crate::tensorflow_protos::feature::{Feature, Features};
/// Allows building tfrecord files by adding PASCAL VOC annotated examples
#[derive(Debug, Default)]
pub struct RecordBuilder {
// Map labels to integers
label_map: LabelMap,
// Max sized allowed for each output file
max_size: usize,
// Current estimate of the output file size
// @TODO: currently unused, update when record splitting is implemented
current_size: usize,
// Current chunk
// @TODO: currently unused, update when record splitting is implemented
current_chunk: u64,
// Examples that should be part of the output tfrecord file
examples: Vec<ExampleImage>,
}
// Flat representation of an example
#[derive(Debug, Default)]
struct ExampleImage {
height: i64,
width: i64,
filename: String,
image_bytes: Vec<u8>,
image_format: String,
xmins: Vec<f32>, // List of normalized left x coordinates in bounding box (1 per box)
xmaxs: Vec<f32>, // List of normalized right x coordinates in bounding box # (1 per box)
ymins: Vec<f32>, // List of normalized top y coordinates in bounding box (1 per box)
ymaxs: Vec<f32>, // List of normalized bottom y coordinates in bounding box # (1 per box)
classes: Vec<i64>, // List of integer class id of bounding box (1 per box)
classes_text: Vec<String>, // List of string class name of bounding box (1 per box)
}
impl RecordBuilder {
/// Initialize a new RecordBuilder
pub fn new(max_size: usize, label_map: LabelMap) -> RecordBuilder {
RecordBuilder {
label_map,
max_size,
..Default::default()
}
}
/// Add an example to the to the set
pub fn add_example(&mut self, example: Annotation) {
let ext = example
.path
.extension()
.and_then(|s| s.to_str())
.and_then(|ext| match ext.to_lowercase().as_ref() {
"png" | "jpg" | "jpeg" => Some(ext),
_ => None,
});
if let (Some(ext), Ok(bytes)) = (ext, fs::read(&example.system_path)) {
// First, map labels to their id and bail on error
let classes = if let Some(classes) = map_labels(&example, &self.label_map) {
classes
} else {
return;
};
self.current_size += bytes.len();
let (xmins, xmaxs, ymins, ymaxs) = get_normalized_coordinates(&example);
let input = ExampleImage {
height: example.size.height as i64,
width: example.size.width as i64,
filename: example.filename.clone(),
image_bytes: bytes,
image_format: ext.to_owned(),
xmins,
xmaxs,
ymins,
ymaxs,
classes,
classes_text: example.objects.iter().map(|o| o.name.clone()).collect(),
};
self.examples.push(input);
}
}
/// Write examples added to the builder to a tfrecord file
pub fn write_tfrecord(&mut self, path: &Path) -> Result<(), TfRecordError> {
let file = OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.open(path)?;
let buffered_writer = BufWriter::new(file);
let mut record_writer = RecordWriter::new(buffered_writer);
mem::take(&mut self.examples)
.into_iter()
.for_each(|example| {
let protobuf = Example::from(example);
protobuf
.write_to_bytes()
.ok()
.and_then(|bytes| record_writer.write_record(&bytes).ok());
});
Ok(())
}
}
// Map labels to integers. Option is Some if all operations succeed
fn map_labels(input: &Annotation, label_map: &LabelMap) -> Option<Vec<i64>> {
input
.objects
.iter()
.map(|object| label_map.get(&object.name))
.collect()
}
// Outputs vectors of normalized coordinates, tuple structure is (xmins, xmaxs, ymins, ymaxs)
fn get_normalized_coordinates(input: &Annotation) -> (Vec<f32>, Vec<f32>, Vec<f32>, Vec<f32>) {
let labels_count = input.objects.len();
let width = input.size.width;
let height = input.size.height;
let mut xmins = Vec::with_capacity(labels_count);
let mut xmaxs = Vec::with_capacity(labels_count);
let mut ymins = Vec::with_capacity(labels_count);
let mut ymaxs = Vec::with_capacity(labels_count);
input.objects.iter().for_each(|object| {
xmins.push(math::normalize(object.bndbox.xmin, 0, width) as f32);
xmaxs.push(math::normalize(object.bndbox.xmax, 0, width) as f32);
ymins.push(math::normalize(object.bndbox.ymin, 0, height) as f32);
ymaxs.push(math::normalize(object.bndbox.ymax, 0, height) as f32);
});
(xmins, xmaxs, ymins, ymaxs)
}
// Map our internal representation of an example to the generic version used by TensorFlow
impl From<ExampleImage> for Example {
fn from(input: ExampleImage) -> Example {
let mut output = Example::new();
let mut features = Features::new();
let mut features_map = HashMap::new();
insert_feature(&mut features_map, "image/height", input.height);
insert_feature(&mut features_map, "image/width", input.width);
// According to the docs, "image/filename" and "image/source_id"
// are both based on file name, see python sample code:
// https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/using_your_own_dataset.md
let source_id = input.filename.clone();
insert_feature(&mut features_map, "image/filename", input.filename);
insert_feature(&mut features_map, "image/source_id", source_id);
insert_feature(&mut features_map, "image/encoded", input.image_bytes);
insert_feature(&mut features_map, "image/format", input.image_format);
insert_feature(&mut features_map, "image/object/bbox/xmin", input.xmins);
insert_feature(&mut features_map, "image/object/bbox/xmax", input.xmaxs);
insert_feature(&mut features_map, "image/object/bbox/ymin", input.ymins);
insert_feature(&mut features_map, "image/object/bbox/ymax", input.ymaxs);
insert_feature(&mut features_map, "image/object/class/text", input.classes);
insert_feature(
&mut features_map,
"image/object/class/label",
input.classes_text,
);
features.set_feature(features_map);
output.set_features(features);
output
}
}
// Helper function, converts a list of values into a TensorFlow Feature and insert it into a map
fn insert_feature<V: Into<Feature>>(map: &mut HashMap<String, Feature>, attr: &str, values: V) {
let attr = String::from(attr);
map.insert(attr, values.into());
}
/// Error types you might encounter while working with tfrecord files
#[derive(Debug, Error)]
pub enum TfRecordError {
#[error("Io error while attempting to write tfrecord file")]
Io(#[from] IoError),
}
|
#[allow(unused_imports)]
use http;
#[allow(unused_imports)]
use net;
use std::collections::HashMap;
use std::fmt;
pub struct Response
{
pub version: http::Version,
pub status_code: http::StatusCode,
pub header: HashMap<String, String>,
pub content: Vec<u8>
}
impl Response
{
pub fn new() -> Self
{
Response
{
version: http::Version::Undefined,
status_code: http::StatusCode::Undefined,
header: HashMap::new(),
content: Vec::new()
}
}
pub fn parse_line(&mut self, line : &str) -> Result<bool, http::Error>
{
if let Some(header_assign) = line.find(":")
{
let (mut key, mut value) = line.split_at(header_assign);
self.header.insert(
key.to_string().to_lowercase(),
value[2..].trim_left().to_string().to_lowercase()
);
Ok(true)
}
else
{
let prob_status_line : Vec<&str> = line.split(" ").collect();
if prob_status_line.len() < 3
{
Ok(false)
}
else
{
let version = http::Version::from(prob_status_line[0]);
let status_code = http::StatusCode::from(prob_status_line[1]);
if version == http::Version::Undefined
|| status_code == http::StatusCode::Undefined
{
Err(http::Error::Malformed(String::from(line)))
}
else
{
self.version = version;
self.status_code = status_code;
Ok(true)
}
}
}
}
pub fn is_valid(&self) -> bool
{
self.status_code != http::StatusCode::Undefined
&& self.version != http::Version::Undefined
}
}
impl fmt::Display for Response
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
{
write!(f, "Response({}, {} bytes)", self.status_code, self.content.len())
}
} |
use base::Base;
mod base {
pub struct Base(u32);
impl Base {
pub fn new(input: u32) -> Option<Self> {
if input <= 1 { None } else { Some(Base(input)) }
}
}
impl From<Base> for u32 {
fn from(base: Base) -> Self {
base.0
}
}
}
#[derive(Debug)]
pub enum Error {
InvalidBase,
DigitDoesNotFitBase,
}
pub fn convert(number: &[u32], from_base_int: u32, to_base_int: u32) -> Result<Vec<u32>, Error> {
let from_base = Base::new(from_base_int).ok_or(Error::InvalidBase)?;
let to_base = Base::new(to_base_int).ok_or(Error::InvalidBase)?;
to_int(number, from_base).map(|number_as_int| to_vec(number_as_int, to_base))
}
fn to_int(number: &[u32], base: Base) -> Result<u32, Error> {
let base_int = u32::from(base);
if number.iter().any(|&digit| digit >= base_int) {
Err(Error::DigitDoesNotFitBase)
} else {
Ok(number.iter()
.rev()
.enumerate()
.map(|(place, digit)| digit * base_int.pow(place as u32))
.sum())
}
}
fn to_vec(number: u32, base: Base) -> Vec<u32> {
let base_int = u32::from(base);
let mut digits = vec![];
let mut remaining = number;
while remaining > 0 {
digits.push(remaining % base_int);
remaining = remaining / base_int;
}
digits.reverse();
digits
}
|
use c_utils::fs::cwd;
fn main() {
let _ = cwd();
}
|
struct Solution;
/// https://leetcode.com/problems/pascals-triangle-ii/
impl Solution {
/// 0 ms 2 MB rust
pub fn get_row(row_index: i32) -> Vec<i32> {
let row_index = row_index as usize;
let mut row = vec![1; row_index + 1];
for i in 2..row_index + 1 {
let mut prev = 1;
for j in 1..i {
let cur = row[j];
row[j] = prev + cur;
prev = cur;
}
}
row
}
}
#[cfg(test)]
mod tests {
use super::*;
use rstest::rstest;
#[rstest(
num_rows,
expected,
case(0, &[1]),
case(1, &[1, 1]),
case(2, &[1, 2, 1]),
case(3, &[1, 3, 3, 1]),
case(4, &[1, 4, 6, 4, 1]),
)]
fn get_row(num_rows: i32, expected: &[i32]) {
assert_eq!(Solution::get_row(num_rows), expected.to_vec());
}
}
|
use imgui::Ui;
use std::time::{Duration, SystemTime};
use winit::event::VirtualKeyCode;
pub const CHORD_COOLDOWN: Duration = Duration::from_millis(500);
#[derive(Clone, Copy)]
pub struct Shortcut {
ctrl: bool,
shift: bool,
alt: bool,
key: VirtualKeyCode,
}
impl Shortcut {
pub const fn new(key: VirtualKeyCode) -> Self {
Self {
ctrl: false,
shift: false,
alt: false,
key,
}
}
pub const fn ctrl(self, required: bool) -> Self {
Self {
ctrl: required,
..self
}
}
pub const fn shift(self, required: bool) -> Self {
Self {
shift: required,
..self
}
}
pub const fn alt(self, required: bool) -> Self {
Self {
alt: required,
..self
}
}
/// Returns true if every key in the chord was just released or is pressed
pub fn is_released(&self, keys: &Keyboard) -> bool {
if self.ctrl != keys.is_ctrl_down() {
return false;
}
if self.shift != keys.is_shift_down() {
return false;
}
if self.alt != keys.is_alt_down() {
return false;
}
if !keys.is_key_down(self.key) {
return false;
}
true
}
}
pub struct Keyboard {
keys_down_last: [bool; 512],
keys_down: [bool; 512],
chord_last_time: SystemTime,
}
impl Keyboard {
pub fn update(&mut self, ui: &Ui) {
for (i, key) in ui.io().keys_down.iter().enumerate() {
self.keys_down_last[i] = self.keys_down[i];
self.keys_down[i] = *key;
}
}
pub fn is_key_down(&self, key: VirtualKeyCode) -> bool {
self.keys_down[key as usize]
}
pub fn is_key_up(&self, key: VirtualKeyCode) -> bool {
!self.is_key_down(key)
}
pub fn is_key_released(&self, key: VirtualKeyCode) -> bool {
let key = key as usize;
self.keys_down_last[key] && !self.keys_down[key]
}
/// Returns true if the key is down or was down
pub fn is_key_active(&self, key: VirtualKeyCode) -> bool {
let key = key as usize;
self.keys_down_last[key] || self.keys_down[key]
}
pub fn is_ctrl_down(&self) -> bool {
self.keys_down[VirtualKeyCode::LControl as usize]
|| self.keys_down[VirtualKeyCode::RControl as usize]
}
pub fn is_shift_down(&self) -> bool {
self.keys_down[VirtualKeyCode::LShift as usize]
|| self.keys_down[VirtualKeyCode::RControl as usize]
}
pub fn is_alt_down(&self) -> bool {
self.keys_down[VirtualKeyCode::LAlt as usize] || self.keys_down[VirtualKeyCode::RAlt as usize]
}
pub fn chord_available(&self) -> bool {
CHORD_COOLDOWN < self.chord_last_time.elapsed().expect("SystemTime error???")
}
pub fn trigger_chord(&mut self) {
self.chord_last_time = SystemTime::now()
}
}
impl Default for Keyboard {
fn default() -> Self {
Self {
keys_down_last: [false; 512],
keys_down: [false; 512],
chord_last_time: SystemTime::now(),
}
}
}
|
//#![allow(warnings)]
#[macro_use]
extern crate enum_primitive_derive;
extern crate num_traits;
mod config;
mod deserialize;
mod html;
mod image;
mod io;
mod json_ld;
mod minify;
mod models;
mod tools;
use colored::*;
use config::{BlogConfig, BlogLog, FeaturedPost};
use image::cwebp;
use io::{read, Writer};
use models::{Blog, Photo};
use std::{
self, env, fs,
path::{Path, PathBuf},
process,
};
use tools::folder_name;
// TODO: read and process GPX files
static RUN_HELP: &str = "
-h Show help
-d Set working directory (current directory assumed if not given)
Example: exifweb -d=./some/path
-auto Detect changes and render differences
-init Create post configuration
-force Comma-delimited list of posts, maps, photos or tags
=posts Re-render all post HTML and basic root pages
=maps Re-download map images for post and category pages
=photos Recreate all resized photos
=tags Re-render all photo tag pages
Example: exifweb -force=posts,tags
";
/// Override normal rendering behavior which is to only reprocess when changes
/// are detected
#[derive(Default)]
struct Override {
posts: bool,
maps: bool,
photos: bool,
tags: bool,
}
fn main() {
// Default path is current directory
let mut path: String = String::from(".");
let mut overrides: Override = Override::default();
let mut rendering: bool = true;
let mut args = env::args();
while let Some(a) = args.next() {
match a.as_ref() {
"-h" => {
// show help regardless of other arguments
print!("{}", RUN_HELP);
process::exit(0);
}
"-init" => {
rendering = false;
}
_ => {
if a.starts_with("-d=") {
path = args.next().expect("Invalid directory parameter");
} else if a.starts_with("-force=") {
let list = args.next().expect("Invalid force parameter");
for f in list.split(',') {
match f {
"posts" => overrides.posts = true,
"maps" => overrides.maps = true,
"photos" => overrides.photos = true,
"tags" => overrides.tags = true,
_ => (),
}
}
}
}
}
}
if rendering {
render(&path, overrides);
} else {
initialize(&path);
}
}
fn initialize(path: &str) {
let name = format!("{}/{}", path, config::CONFIG_FILE);
match fs::write(
Path::new(path).join(config::CONFIG_FILE),
config::post::EMPTY_CONFIG,
) {
Ok(_) => {
println!("Created {}", name);
process::Command::new("notepad")
.current_dir(path)
.arg(config::CONFIG_FILE);
}
Err(e) => println!("Error writing {} {:?}", name, e),
};
}
fn render(path: &str, overrides: Override) {
let root = Path::new(path);
let entries = load_root_directory(&root);
let mut config = load_config(&root, overrides);
let mut blog = Blog::default();
blog.history = BlogLog::load(&root).unwrap_or_else(BlogLog::empty);
// iterate over every file or directory within root
for entry in entries {
post_from_entry(&mut blog, entry.unwrap(), &config);
}
print!("\n");
success_metric(blog.post_count(), "total posts");
if blog.is_empty() {
return;
}
blog.correlate_posts();
for (_, p) in blog
.posts
.iter_mut()
.filter(|(_, p)| p.photos.is_empty() && p.sequence_changed())
{
// posts that changed order need to be re-rendered which requires all
// their photo data to be loaded
p.add_photos(read::load_photos(&root.join(&p.path), &config.photo));
}
blog.prepare_maps(&config);
let render_count = blog.needs_render_count();
let render_html =
render_count > 0 || config.force.html || config.force.tags;
success_metric(render_count, "posts need rendered");
if render_html || config.force.maps || config.force.photos {
blog.collate_tags();
blog.sanitize_exif(&config.photo.exif);
if let Some(p) = config
.featured_post
.and_then(|f| blog.get_featured(&f.path))
{
config.featured_post = Some(FeaturedPost {
path: p.path.clone(),
title: p.title.clone(),
});
success_metric(1, "featured post");
} else {
config.featured_post = None;
success_metric(0, "featured posts");
}
success_metric(blog.category_count(), "post categories");
success_metric(blog.tag_count(), "unique photo tags");
BlogLog::write(root, &blog);
let write = Writer::new(root, &config, &blog);
if render_html {
write.posts();
write.home_page();
write.sitemap();
write.category_menu();
write.mobile_menu();
write.photo_tags();
write.about_page();
write.error_pages();
write.categories();
}
write.post_maps();
for (path, post) in blog.posts {
let last_render = post.history.as_of;
let full_path = root.join(&path).to_string_lossy().to_string();
let mut count: usize = 0;
println!(
"\nExamining {} photos in {}",
post.title.yellow(),
full_path.cyan()
);
for p in post.photos {
if p.file.created > last_render {
count += 1;
cwebp::create_sizes(&full_path, &p, &config.photo);
}
}
if count > 0 {
println!(" Resized {} photo(s)", count);
} else {
println!(" All photos are current");
}
}
}
}
/// Load all entries (files and directories) from the root directory
fn load_root_directory(root: &Path) -> fs::ReadDir {
match fs::read_dir(root) {
Ok(entries) => entries,
_ => {
println!(
"{} {}",
"Failed to open root directory".red(),
folder_name(root).red()
);
process::exit(1)
}
}
}
/// Load configuration file and apply command line arguments and environment
/// variables
fn load_config(root: &Path, overrides: Override) -> BlogConfig {
let mut config: BlogConfig = match BlogConfig::load(root) {
Some(config) => config,
_ => {
println!("{}", "Missing root configuration file".red());
process::exit(1)
}
};
let notify = |label: &str, force: bool| {
println!("{}", format!("Force {}: {}", label, force).cyan().bold())
};
config.force.html = overrides.posts;
config.force.maps = overrides.maps;
config.force.photos = overrides.photos;
config.force.tags = overrides.tags;
println!("");
notify("HTML re-render", config.force.html);
notify("static map re-download", config.force.maps);
notify("photo resizing", config.force.photos);
notify("tag page re-render", config.force.tags);
config
}
/// Create post(s) from a directory entry. The number of posts created for the
/// blog may be one, several or none depending on whether the entry is a
/// post-containing directory, a series-containing directory or neither,
/// respectively.
fn post_from_entry(blog: &mut Blog, entry: fs::DirEntry, config: &BlogConfig) {
let path: PathBuf = entry.path();
let dir_name: &str = folder_name(&path);
if !path.is_dir() || config.ignore_folders.contains(&dir_name.to_string()) {
// ignore root files and specified folders
return;
}
println!("\n{} └ {}", "Found root directory".bold(), dir_name.bold());
if let Some(posts) = read::series(&path, &config) {
println!(" Series of {} posts:", posts.len());
for p in posts {
println!("{:6}{} ({} photos)", "", p.title.yellow(), p.photo_count);
blog.add_post(p);
}
// skip to next path entry if series was found
return;
}
if let Some(post) = read::post(path.as_path(), &config) {
println!(" {} ({} photos)", post.title.yellow(), post.photo_count);
blog.add_post(post);
}
}
fn success_metric(count: usize, label: &str) {
println!("{}", format!("{:>5} {}", count, label).bold().green());
}
|
use extend::ext;
use skorm_store::{NamedNode, NamedOrBlankNode, RdfStore, SubjectExt};
#[derive(Debug, Clone, Copy)]
pub struct RdfProp<'a> {
store: &'a RdfStore,
name: NamedNode<'a>,
}
impl<'a> RdfProp<'a> {
pub fn name(&self) -> &'a str {
self.name.iri().as_ref()
}
#[inline]
pub fn node(&self) -> NamedNode<'a> {
self.name
}
pub fn base_props(&self) -> impl Iterator<Item = RdfProp<'a>> {
let store = self.store;
self
.name
.term("rdfs:subPropertyOf")
.unwrap()
.filter_map(move |term| term.as_named().map(|name| RdfProp { name, store }))
}
pub fn domains(&self) -> impl Iterator<Item = NamedNode<'a>> {
self
.name
.term("rdfs:domain")
.unwrap()
.filter_map(|term| term.as_named())
}
pub fn triples(&self) -> skorm_store::Triples<'a> {
self.name.triples()
}
}
#[ext(pub, name = RdfStorePropExt)]
impl RdfStore {
fn props<'a>(&'a self) -> Box<dyn Iterator<Item = RdfProp<'a>> + 'a> {
let iter = self
.subjects_of_type("rdf:Property")
.unwrap()
.filter_map(move |sub| match sub {
NamedOrBlankNode::Named(name) => Some(RdfProp { store: self, name }),
NamedOrBlankNode::Blank(_) => None,
});
Box::new(iter)
}
}
|
#![no_std]
#![no_main]
#![feature(min_type_alias_impl_trait)]
#![feature(impl_trait_in_bindings)]
#![feature(type_alias_impl_trait)]
#![allow(incomplete_features)]
#[path = "../example_common.rs"]
mod example_common;
use example_common::*;
use defmt::panic;
use embassy::executor::Spawner;
use embassy::traits::uart::{Read, Write};
use embassy_nrf::gpio::NoPin;
use embassy_nrf::{interrupt, uarte, Peripherals};
#[embassy::main]
async fn main(_spawner: Spawner, p: Peripherals) {
let mut config = uarte::Config::default();
config.parity = uarte::Parity::EXCLUDED;
config.baudrate = uarte::Baudrate::BAUD115200;
let irq = interrupt::take!(UARTE0_UART0);
let mut uart =
unsafe { uarte::Uarte::new(p.UARTE0, irq, p.P0_08, p.P0_06, NoPin, NoPin, config) };
info!("uarte initialized!");
// Message must be in SRAM
let mut buf = [0; 8];
buf.copy_from_slice(b"Hello!\r\n");
unwrap!(uart.write(&buf).await);
info!("wrote hello in uart!");
loop {
info!("reading...");
unwrap!(uart.read(&mut buf).await);
info!("writing...");
unwrap!(uart.write(&buf).await);
}
}
|
#![allow(dead_code)]
use async_std::net::{TcpListener, TcpStream};
use futures_io::AsyncRead;
use futures_util::future::poll_fn;
use futures_util::{AsyncReadExt, AsyncWriteExt};
use hreq_h1::buf_reader::BufIo;
use hreq_h1::server::SendResponse;
use hreq_h1::Error;
use std::future::Future;
use std::io;
use std::str::FromStr;
use std::sync::Once;
pub async fn serve<F, R>(mut f: F) -> Result<Connector, io::Error>
where
F: Send + 'static,
F: FnMut(String, BufIo<TcpStream>, usize) -> R,
R: Future<Output = Result<(BufIo<TcpStream>, bool), Error>>,
R: Send,
{
setup_logger();
let l = TcpListener::bind("127.0.0.1:0").await?;
let p = l.local_addr()?.port();
async_std::task::spawn(async move {
let mut call_count = 1;
let (tcp, _) = l.accept().await.expect("Accept failed");
let mut brd = BufIo::with_capacity(16_384, tcp);
loop {
let head = match test_read_header(&mut brd).await {
Ok(v) => v,
Err(_e) => {
// client closed the connection
return;
}
};
let fut = f(head, brd, call_count);
let (brd_ret, again) = fut.await.expect("Handler fail");
brd = brd_ret;
brd.flush().await.expect("Flush fail");
call_count += 1;
if !again {
break;
}
}
});
let addr = format!("127.0.0.1:{}", p);
Ok(Connector(addr))
}
pub async fn serve_once<F, R>(mut f: F) -> Result<Connector, io::Error>
where
F: Send + 'static,
F: FnMut(String, BufIo<TcpStream>) -> R,
R: Future<Output = Result<(), Error>>,
R: Send,
{
setup_logger();
let l = TcpListener::bind("127.0.0.1:0").await?;
let p = l.local_addr()?.port();
async_std::task::spawn(async move {
let (tcp, _) = l.accept().await.expect("Accept failed");
let mut brd = BufIo::with_capacity(16_384, tcp);
let head = match test_read_header(&mut brd).await {
Ok(v) => v,
Err(_e) => {
// client closed the connection
return;
}
};
let fut = f(head, brd);
fut.await.expect("Handler fail");
});
let addr = format!("127.0.0.1:{}", p);
Ok(Connector(addr))
}
pub struct Connector(pub String);
impl Connector {
pub async fn connect(&self) -> Result<TcpStream, Error> {
Ok(TcpStream::connect(&self.0).await?)
}
}
pub async fn run<B: AsRef<[u8]>>(
tcp: TcpStream,
req: http::Request<B>,
) -> Result<(http::response::Parts, Vec<u8>), Error> {
let (mut send, conn) = hreq_h1::client::handshake(tcp);
async_std::task::spawn(async move {
if let Err(_e) = conn.await {
// println!("{:?}", _e);
}
});
let (parts, body) = req.into_parts();
let req = http::Request::from_parts(parts, ());
let body: &[u8] = body.as_ref();
let (fut, body_send) = send.send_request(req, body.is_empty())?;
if !body.is_empty() {
send_body_chunks(body_send, body, 10_000).await?;
}
let res = fut.await?;
let (parts, mut body) = res.into_parts();
let mut v = vec![];
body.read_to_end(&mut v).await?;
Ok((parts, v))
}
use hreq_h1::SendStream;
/// send body in reasonable chunks
pub async fn send_body_chunks(
mut body_send: SendStream,
body: &[u8],
size: usize,
) -> Result<(), Error> {
let mut i = 0;
while i < body.len() {
let max = (body.len() - i).min(size);
body_send.send_data(&body[i..(i + max)], false).await?;
i += max;
}
body_send.send_data(&[], true).await?;
Ok(())
}
pub async fn run_server<F, R>(mut f: F) -> Result<Connector, io::Error>
where
F: Send + 'static,
F: FnMut(http::request::Parts, io::Result<Vec<u8>>, SendResponse, usize) -> R,
R: Future<Output = Result<bool, Error>>,
R: Send,
{
setup_logger();
let l = TcpListener::bind("127.0.0.1:0").await?;
let p = l.local_addr().unwrap().port();
let addr = format!("127.0.0.1:{}", p);
async_std::task::spawn(async move {
let mut call_count = 1;
let mut keep_going = true;
loop {
if !keep_going {
break;
}
let (tcp, _) = l.accept().await.expect("Accept incoming");
let mut conn = hreq_h1::server::handshake(tcp);
while let Some(x) = conn.accept().await {
let (req, respond) = x.expect("Handshaken");
let (parts, mut body) = req.into_parts();
let mut v = vec![];
let bod_res = body.read_to_end(&mut v).await.map(|_| v);
let again = f(parts, bod_res, respond, call_count)
.await
.expect("Handler");
call_count += 1;
keep_going = again;
if !again {
conn.close().await;
break;
}
}
}
});
Ok(Connector(addr))
}
pub async fn test_read_header<S: AsyncRead + Unpin>(io: &mut BufIo<S>) -> Result<String, Error> {
Ok(poll_fn(|cx| {
hreq_h1::http11::poll_for_crlfcrlf(cx, io, |buf, _| {
String::from_utf8(buf.to_vec()).unwrap()
})
})
.await?)
}
pub fn setup_logger() {
static START: Once = Once::new();
START.call_once(|| {
let test_log = std::env::var("TEST_LOG")
.map(|x| x != "0" && x.to_lowercase() != "false")
.unwrap_or(false);
let level = if test_log {
log::LevelFilter::Trace
} else {
log::LevelFilter::Info
};
pretty_env_logger::formatted_builder()
.filter_level(log::LevelFilter::Warn)
.filter_module("hreq_h1", level)
.target(env_logger::Target::Stdout)
.init();
});
}
/// Internal extension of `HeaderMap`.
pub(crate) trait HeaderMapExt {
/// Get a header, ignore incorrect header values.
fn get_str(&self, key: &str) -> Option<&str>;
fn get_as<T: FromStr>(&self, key: &str) -> Option<T>;
fn set<T: Into<String>>(&mut self, key: &'static str, key: T);
}
impl HeaderMapExt for http::HeaderMap {
//
fn get_str(&self, key: &str) -> Option<&str> {
self.get(key).and_then(|v| v.to_str().ok())
}
fn get_as<T: FromStr>(&self, key: &str) -> Option<T> {
self.get_str(key).and_then(|v| v.parse().ok())
}
fn set<T: Into<String>>(&mut self, key: &'static str, value: T) {
let s: String = value.into();
let header = s.parse().unwrap();
self.insert(key, header);
}
}
|
use std::cmp::PartialOrd;
use std::fmt::Display;
fn main() {
let v1 = vec![1, 2, 3, 4];
println!("m int: {}", max(&v1));
let s1 = vec!["a", "b", "c"];
println!("m str: {}", max(&s1));
let p = Pair::new(1, 2);
println!("p = {:?}", p);
let p2 = Pair::new("1", "2");
println!("p2 = {:?}", p2);
/*
{
let r;
{
let x = 5;
r = &x;
}
println!("r = {}", r);
}
*/
let s1 = "hello";
let s2 = "hi";
let m = longest(s1, s2);
println!("m = {}", m);
let lwn = longest_with_ann("abc", "b", "OMG");
println!("lwn: {}", lwn);
}
fn longest_with_ann<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
where
T: Display,
{
println!("ann: {}", ann);
if x.len() > y.len() {
x
} else {
y
}
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
#[derive(Debug)]
struct Pair<T> {
x: T,
y: T,
}
impl<T> Pair<T> {
fn new(x: T, y: T) -> Self {
Self { x, y }
}
}
fn max<T>(list: &[T]) -> T
where
T: PartialOrd + Copy,
{
let mut m = list[0];
for &item in list.iter() {
if item > m {
m = item;
}
}
m
}
|
use crate::{SoundChip, Stereo, Vtx};
use aym::{AySample, AymBackend};
use num_traits::Num;
pub type PrecisePlayer = Player<aym::AymPrecise>;
/// Performs sound sample generation using provided vtx file
pub struct Player<AY: AymBackend> {
vtx: Vtx,
frame: usize,
frame_sample: usize,
stereo: bool,
ay: AY,
samples_per_frame: usize,
}
/// This trait is not meant to be implemented by the
/// client code and it is subject to change
pub trait PlayerSample: Num {
/// Constructs self from f64 sample
fn from_aym_sample(sample: impl aym::AySample) -> Self;
}
impl PlayerSample for i8 {
fn from_aym_sample(sample: impl AySample) -> Self {
sample.to_i8()
}
}
impl PlayerSample for i16 {
fn from_aym_sample(sample: impl AySample) -> Self {
sample.to_i16()
}
}
impl PlayerSample for i32 {
fn from_aym_sample(sample: impl AySample) -> Self {
sample.to_i32()
}
}
impl PlayerSample for f32 {
fn from_aym_sample(sample: impl AySample) -> Self {
sample.to_f32()
}
}
impl PlayerSample for f64 {
fn from_aym_sample(sample: impl AySample) -> Self {
sample.to_f64()
}
}
impl<AY: AymBackend> Player<AY> {
/// Constructs player instance from the given `vtx` file, `sample_rate` and `stereo`.
/// `stereo` flag enables 2-channel sample generation.
pub fn new(vtx: Vtx, sample_rate: usize, stereo: bool) -> Self {
let chip_type = match vtx.chip {
SoundChip::AY => aym::SoundChip::AY,
SoundChip::YM => aym::SoundChip::YM,
};
let mode = if stereo {
match vtx.stereo {
Stereo::Mono => aym::AyMode::Mono,
Stereo::ABC => aym::AyMode::ABC,
Stereo::ACB => aym::AyMode::ACB,
Stereo::BAC => aym::AyMode::BAC,
Stereo::BCA => aym::AyMode::BCA,
Stereo::CAB => aym::AyMode::CAB,
Stereo::CBA => aym::AyMode::CBA,
}
} else {
aym::AyMode::Mono
};
let ay = AY::new(chip_type, mode, vtx.frequency as usize, sample_rate);
let samples_per_frame = sample_rate / vtx.player_frequency as usize;
Self {
vtx,
frame: 0,
frame_sample: 0,
stereo,
ay,
samples_per_frame,
}
}
fn update_ay(&mut self) -> bool {
if let Some(frame) = self.vtx.frame_registers(self.frame) {
for (idx, value) in frame.iter().copied().enumerate() {
if idx == 13 && value == 0xFF {
continue;
}
self.ay.write_register(idx as u8, value);
}
return true;
}
false
}
/// Fills given `samples` slice with sound sample data.
/// Returns quantity of samples which were filed in the buffer.
/// When stereo mode is enabled, method returns overall samples count multiplied by
/// thc channel count (2), so that regardless of the stereo mode there will be always
/// `samples[..sample_count]` filled.
pub fn play<S: PlayerSample>(&mut self, samples: &mut [S]) -> usize {
let mut processed_samples = 0;
if self.stereo {
for sample in samples.chunks_exact_mut(2) {
// On first frame sample - update ay state
if self.frame_sample == 0 && !self.update_ay() {
return processed_samples * 2;
}
let ay_sample = self.ay.next_sample();
sample[0] = S::from_aym_sample(ay_sample.left);
sample[1] = S::from_aym_sample(ay_sample.right);
processed_samples += 1;
self.frame_sample += 1;
if self.frame_sample == self.samples_per_frame {
self.frame_sample = 0;
self.frame += 1;
}
}
processed_samples * 2
} else {
for sample in samples {
if self.frame_sample == 0 && !self.update_ay() {
return processed_samples;
}
let ay_sample = self.ay.next_sample();
*sample = S::from_aym_sample(ay_sample.left);
processed_samples += 1;
self.frame_sample += 1;
if self.frame_sample == self.samples_per_frame {
self.frame_sample = 0;
self.frame += 1;
}
}
processed_samples
}
}
/// Reset playback state
pub fn rewind(&mut self) {
self.frame = 0;
self.frame_sample = 0;
// Force reset envelope
self.ay.write_register(13, 0);
}
/// Reset to start of the looped record
pub fn rewind_loop(&mut self) {
self.frame = self.vtx.loop_start_frame as usize;
self.frame_sample = 0;
self.ay.write_register(13, 0);
}
/// Sets frame position for playback
pub fn set_frame(&mut self, frame: usize) -> bool {
if frame >= self.vtx.frames_count() {
return false;
}
self.frame = frame;
self.frame_sample = 0;
self.ay.write_register(13, 0);
true
}
}
#[cfg(test)]
mod tests {
use super::*;
use expect_test::expect;
use sha2::{Digest, Sha256};
fn generate_samples_hash_for_vtx<B: AymBackend>(data: &[u8]) -> String {
const SAMPLE_RATE: usize = 44100;
let vtx = Vtx::load(std::io::Cursor::new(data)).unwrap();
let buffer_size = SAMPLE_RATE * 15; // 15 seconds will be enough for validation
let mut buffer = vec![0i16; buffer_size];
let mut player = PrecisePlayer::new(vtx, SAMPLE_RATE, true);
let actual_length = player.play(&mut buffer);
buffer.truncate(actual_length);
let mut hashable_buffer = Vec::with_capacity(buffer.len() * 2);
buffer.into_iter().for_each(|sample| {
hashable_buffer.extend_from_slice(&sample.to_ne_bytes());
});
let mut hasher = Sha256::default();
hasher.update(&hashable_buffer);
let frame_data_fingerprint = hasher.finalize();
format!("{:x}", frame_data_fingerprint)
}
#[test]
fn precise_player_wroks_normally() {
// This test also doubles as test for `aym` crate with AymPrecise backend selected
expect![[r#"65127ad0e493b23b43e838b6281d7f8d07a47549efd0c9d1eda3d3ccaf0b7e5c"#]].assert_eq(
&generate_samples_hash_for_vtx::<aym::AymPrecise>(include_bytes!("test/csoon.vtx")),
)
}
}
|
use ws::listen;
use std::thread;
use rand;
use rand::Rng;
use std::sync::{Arc, Mutex};
mod client;
mod gamestate;
pub fn new(){
let gamestate = Arc::new(Mutex::new(gamestate::new()));
thread::spawn(move ||{
let mut rng = rand::thread_rng();
let err = listen("0.0.0.0:3012",|out|{
let client = client::new(rng.gen::<u64>(), out.clone(),gamestate.clone());
let mutex = gamestate.clone();
let mut gs = mutex.lock().unwrap();
gs.register(out.clone(),client.id);
return client;
});
match err {
Err(err) =>println!("Socket error"),
Ok(_)=> println!("Listening"),
};
});
} |
// q0075_sort_colors
struct Solution;
impl Solution {
pub fn sort_colors(nums: &mut Vec<i32>) {
if nums.is_empty() {
return;
}
let mut p1 = 0;
let mut p2 = nums.len() - 1;
let mut next_0 = p1;
let mut next_2 = p2;
while p1 <= p2 {
// println!(" begin -- p1: {} p2: {} 0: {} 2: {}", p1, p2, next_0, next_2);
if nums[p1] == 0 {
let t = nums[p1];
nums[p1] = nums[next_0];
nums[next_0] = t;
if p1 == nums.len() - 1 {
break;
}
next_0 += 1;
p1 += 1;
} else if nums[p1] == 2 {
let t = nums[p1];
nums[p1] = nums[next_2];
nums[next_2] = t;
if p2 == 0 {
break;
}
next_2 -= 1;
if p2 > next_2 {
p2 -= 1;
}
} else {
if p1 == nums.len() - 1 {
break;
}
p1 += 1;
}
if p1 > p2 {
break;
}
// println!(" sort p1: {:?}", nums);
if nums[p2] == 2 {
let t = nums[p2];
nums[p2] = nums[next_2];
nums[next_2] = t;
if p2 == 0 {
break;
}
next_2 -= 1;
p2 -= 1;
} else if nums[p2] == 0 {
let t = nums[p2];
nums[p2] = nums[next_0];
nums[next_0] = t;
if p1 == nums.len() - 1 {
break;
}
next_0 += 1;
if p1 < next_0 {
p1 += 1;
}
} else {
if p2 == 0 {
break;
}
p2 -= 1;
}
// println!(" sort p2: {:?}", nums);
}
}
}
#[cfg(test)]
mod tests {
use super::Solution;
#[test]
fn it_works() {
let mut arr = vec![2, 0, 2, 1, 1, 0];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![0, 0, 1, 1, 2, 2]);
let mut arr = vec![
2, 0, 2, 1, 1, 0, 0, 1, 0, 2, 0, 2, 0, 1, 0, 2, 1, 1, 1, 0, 2, 0, 2, 2, 2,
];
Solution::sort_colors(&mut arr);
assert_eq!(
arr,
vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2]
);
let mut arr = vec![2, 2];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![2, 2]);
let mut arr = vec![0, 0];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![0, 0]);
let mut arr = vec![1, 1];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![1, 1]);
let mut arr = vec![2, 1];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![1, 2]);
let mut arr = vec![0, 2, 1];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![0, 1, 2]);
let mut arr = vec![0];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![0]);
let mut arr = vec![2];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![2]);
let mut arr = vec![2, 1, 0];
Solution::sort_colors(&mut arr);
assert_eq!(arr, vec![0, 1, 2]);
}
}
|
#[doc = "Reader of register STAT"]
pub type R = crate::R<u32, super::STAT>;
#[doc = "Reader of field `CKOKIF`"]
pub type CKOKIF_R = crate::R<bool, bool>;
#[doc = "Reader of field `CKWARNIF`"]
pub type CKWARNIF_R = crate::R<bool, bool>;
#[doc = "Reader of field `ERRIF`"]
pub type ERRIF_R = crate::R<bool, bool>;
#[doc = "Reader of field `EREFIF`"]
pub type EREFIF_R = crate::R<bool, bool>;
#[doc = "Reader of field `CKERR`"]
pub type CKERR_R = crate::R<bool, bool>;
#[doc = "Reader of field `REFMISS`"]
pub type REFMISS_R = crate::R<bool, bool>;
#[doc = "Reader of field `TRIMERR`"]
pub type TRIMERR_R = crate::R<bool, bool>;
#[doc = "Reader of field `REFDIR`"]
pub type REFDIR_R = crate::R<bool, bool>;
#[doc = "Reader of field `REFCAP`"]
pub type REFCAP_R = crate::R<u16, u16>;
impl R {
#[doc = "Bit 0 - Clock trim OK interrupt flag"]
#[inline(always)]
pub fn ckokif(&self) -> CKOKIF_R {
CKOKIF_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Clock trim warning interrupt flag"]
#[inline(always)]
pub fn ckwarnif(&self) -> CKWARNIF_R {
CKWARNIF_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Error interrupt flag"]
#[inline(always)]
pub fn errif(&self) -> ERRIF_R {
ERRIF_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Expect reference interrupt flag"]
#[inline(always)]
pub fn erefif(&self) -> EREFIF_R {
EREFIF_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 8 - Clock trim error bit"]
#[inline(always)]
pub fn ckerr(&self) -> CKERR_R {
CKERR_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - Reference sync pulse miss"]
#[inline(always)]
pub fn refmiss(&self) -> REFMISS_R {
REFMISS_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Trim value error bit"]
#[inline(always)]
pub fn trimerr(&self) -> TRIMERR_R {
TRIMERR_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 15 - CTC trim counter direction when reference sync pulse"]
#[inline(always)]
pub fn refdir(&self) -> REFDIR_R {
REFDIR_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bits 16:31 - CTC counter capture when reference sync pulse"]
#[inline(always)]
pub fn refcap(&self) -> REFCAP_R {
REFCAP_R::new(((self.bits >> 16) & 0xffff) as u16)
}
}
|
use zoon::*;
use std::ops::Not;
blocks!{
#[el]
pub fn root() -> View {
view![
font::size(14),
font::family!("Helvetica Neue", "Helvetica", "Arial", font::sans_serif()),
font::color(hsl(0, 0, 5.1))
background::color(hsl(0, 0, 96.5)),
column![
width!(fill(), minimum(230), maximum(550)),
center_x(),
header(),
panel(),
footer(),
]
]
}
#[el]
fn header() -> El {
el![
region::header(),
width!(fill()),
padding!(top(35), bottom(32)),
el![
region::h1(),
center_x(),
font::size(80),
font::color(hsl(10.5, 62.8, 44.5)),
font::extra_light(),
"todos",
],
]
}
#[el]
fn panel() -> Column {
let todos_exist = super::todos_exist().inner();
column![
region::section(),
width!(fill()),
background::color(hsl(0, 0, 100)),
border::shadow!(
shadow::offsetXY(0, 2),
shadow::size(0),
shadow::blur(4),
shadow::color(hsla(0, 0, 0, 20)),
),
border::shadow!(
shadow::offsetXY(0, 25),
shadow::size(0),
shadow::blur(50),
shadow::color(hsla(0, 0, 0, 10)),
),
panel_header(),
todos_exist().then(|| elements![
todos(),
panel_footer(),
]),
]
}
#[el]
fn panel_header() -> Row {
let todos_exist = super::todos_exist().inner();
row![
width!(fill()),
background::color(hsla(0, 0, 0, 0.3)),
padding!(16),
border::shadow!(
shadow::inner(),
shadow::offsetXY(-2, 1),
shadow::size(0),
shadow::color(hsla(0, 0, 0, 3)),
),
todos_exist.then(toggle_all_checkbox),
new_todo_title(),
]
}
#[el]
fn toggle_all_checkbox() -> Checkbox {
let checked = super::are_all_completed().inner();
checkbox![
checkbox::checked(checked),
checkbox::on_change(super::check_or_uncheck_all),
input::label_hidden("Toggle All"),
el![
font::color(hsla(0, 0, if checked { 48.4 } else { 91.3 })),
font::size(22),
rotate(90),
"❯",
],
]
}
#[el]
fn new_todo_title() -> TextInput {
let new_todo_title = super::new_todo_title().inner();
text_input![
do_once(focus),
text_input::on_change(super::set_new_todo_title),
input::label_hidden("New Todo Title"),
placeholder![
font::italic(),
font::light(),
font::color(hsla(0, 0, 0, 40)),
placeholder::text("what needs to be done?"),
],
on_key_down(|event| if let Key::Enter = event.key { super::add_todo() }),
new_todo_title,
]
}
#[el]
fn todos() -> Column {
let filtered_todos = super::filtered_todos()
.inner();
.map(|todos| todos.iter_vars().map(todo));
column![
filtered_todos
]
}
fn active_todo_checkbox_icon() -> &'static str {
"data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2240%22%20height%3D%2240%22%20viewBox%3D%22-10%20-18%20100%20135%22%3E%3Ccircle%20cx%3D%2250%22%20cy%3D%2250%22%20r%3D%2250%22%20fill%3D%22none%22%20stroke%3D%22%23ededed%22%20stroke-width%3D%223%22/%3E%3C/svg%3E"
}
fn completed_todo_checkbox_icon() -> &'static str {
"data:image/svg+xml;utf8,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20width%3D%2240%22%20height%3D%2240%22%20viewBox%3D%22-10%20-18%20100%20135%22%3E%3Ccircle%20cx%3D%2250%22%20cy%3D%2250%22%20r%3D%2250%22%20fill%3D%22none%22%20stroke%3D%22%23bddad5%22%20stroke-width%3D%223%22/%3E%3Cpath%20fill%3D%22%235dc2af%22%20d%3D%22M72%2025L42%2071%2027%2056l-4%204%2020%2020%2034-52z%22/%3E%3C/svg%3E"
}
#[el]
fn todo(todo: Var<super::Todo>) -> Row {
let selected = Some(todo) == super::selected_todo().inner();
let checkbox_id = el_var(ElementId::new);
let row_hovered = el_var(|| false);
row![
font::size(24),
padding!(15),
spacing(10),
on_hovered_change(row_hovered.setter()),
todo_checkbox(checkbox_id, todo),
selected.not().then(|| todo_label(checkbox_id, todo)),
selected.then(selected_todo_title),
row_hovered.inner().then(|| remove_todo_button(todo)),
]
}
#[el]
fn todo_checkbox(checkbox_id: ElVar<ElementId>, todo: Var<super::Todo>) -> CheckBox {
let completed = todo.map(|todo| todo.completed);
checkbox![
id(checkbox_id.inner()),
checkbox::checked(completed),
checkbox::on_change(|_| super::toggle_todo(todo)),
el![
background::image(if completed {
completed_todo_checkbox_icon()
} else {
active_todo_checkbox_icon()
}),
],
]
}
#[el]
fn todo_label(checkbox_id: ElVar<ElementId>, todo: Var<super::Todo>) -> Label {
label![
label::for_input(checkbox_id.inner()),
checked.then(font::strike),
font::regular(),
font::color(hsl(0, 0, 32.7)),
on_double_click(|| select_todo(Some(todo))),
todo.map(|todo| todo.title.clone()),
]
}
#[el]
fn selected_todo_title() -> TextInput {
let selected_todo = super::selected_todo().inner().unwrap();
text_input![
width!(fill()),
paddingXY(16, 12),
border::solid(),
border::width!(1),
border::color(hsl(0, 0, 63.2)),
border::shadow!(
shadow::inner(),
shadow::offsetXY(-1, 5),
shadow::size(0),
shadow::color(hsla(0, 0, 0, 20)),
),
do_once(focus),
on_blur(super::save_selected_todo),
on_key_down(|event| {
match event.key {
Key::Escape => super::select_todo(None),
Key::Enter => super::save_selected_todo(),
_ => (),
}
}),
text_input::on_change(super::set_selected_todo_title),
selected_todo.map(|todo| todo.title.clone()),
]
}
#[el]
fn remove_todo_button(todo: Var<super::Todo>) -> Button {
let hovered = el_var(|| false);
button![
size::width!(20),
size::height!(20),
font::size(30),
font::color(hsl(12.2, 34.7, 68.2)),
on_hovered_change(hovered.setter()),
font::color(if hovered().inner() { hsl(10.5, 37.7, 48.8) } else { hsl(12.2, 34.7, 68.2) }),
button::on_press(|| super::remove_todo(todo)),
"×",
]
}
#[el]
fn panel_footer() -> Row {
let completed_exist = super::completed_exist();
row![
active_items_count(),
filters(),
completed_exist.then(clear_completed_button),
]
}
#[el]
fn active_items_count() -> Paragraph {
let active_count = super::active_count().inner();
paragraph![
el![
font::bold(),
active_count,
],
format!(" item{} left", if active_count == 1 { "" } else { "s" }),
]
}
#[el]
fn filters() -> Row {
let filters = super::filters();
row![
filters.map(|filters| filters.iter().map(filter))
]
}
#[el]
fn filter(filter: super::Filter) -> Button {
let selected = super::selected_filter().inner() == filter;
let hovered = el_var(|| false);
let (title, route) = match filter {
super::Filter::All => ("All", super::Route::root()),
super::Filter::Active => ("Active", super::Route::active()),
super::Filter::Completed => ("Completed", super::Route::completed()),
};
let border_alpha = if selected { 20 } else if hovered { 10 } else { 0 };
button![
on_hovered_change(hovered.setter()),
paddingXY(7, 3),
border::solid(),
border::width!(1),
border::color(hsla(12.2, 72.8, 40.2, border_alpha)),
button::on_press(|| super::set_route(route)),
title,
]
}
#[el]
fn clear_completed_button() -> Button {
let hovered = el_var(|| false);
button![
on_hovered_change(hovered.setter()),
hovered.inner().then(font::underline),
button::on_press(super::remove_completed),
"Clear completed",
]
}
#[el]
fn footer() -> Column {
column![
paragraph![
"Double-click to edit a todo",
],
paragraph![
"Created by ",
link![
link::new_tab(),
link::url("https://github.com/MartinKavik"),
"Martin Kavík",
],
],
paragraph![
"Part of ",
link![
link::new_tab(),
link::url("http://todomvc.com"),
"TodoMVC",
],
],
]
}
}
|
use super::rendering::*;
use super::*;
use gfx_h::MenuParticles;
use std::collections::HashMap;
use std::convert::TryFrom;
pub struct MenuRenderingSystem;
impl<'a> System<'a> for MenuRenderingSystem {
type SystemData = (
ReadExpect<'a, ThreadPin<red::GL>>,
WriteExpect<'a, Canvas>,
ReadExpect<'a, red::Viewport>,
Write<'a, EventChannel<Primitive>>,
Write<'a, UI>,
Write<'a, UIState>,
Write<'a, EventChannel<InsertEvent>>,
WriteExpect<'a, PreloadedImages>,
WriteExpect<'a, ThreadPin<MenuParticles>>,
Read<'a, Mouse>,
Write<'a, AppState>,
ReadExpect<'a, Description>,
Read<'a, Vec<UpgradeCardRaw>>,
Write<'a, Vec<UpgradeCard>>,
Read<'a, HashMap<String, AtlasImage>>,
WriteExpect<'a, MacroGame>,
Write<'a, EventChannel<Sound>>,
ReadExpect<'a, PreloadedSounds>,
);
fn run(&mut self, data: Self::SystemData) {
let (
gl,
canvas,
viewport,
mut primitives_channel,
mut ui,
mut ui_state,
mut insert_channel,
preloaded_images,
mut menu_particles,
mouse,
mut app_state,
// text_data
description,
upgrade_cards_raw,
mut avaliable_upgrades,
name_to_atlas,
mut macro_game,
mut sounds_channel,
preloaded_sounds,
) = data;
let mut frame = red::Frame::new(&gl);
// frame.set_clear_color(0.0, 0.0, 0.0, 1.0);
// frame.clear_color();
let dims = viewport.dimensions();
let (w, h) = (dims.0 as f32, dims.1 as f32);
// return;
// darker background
ui.primitives.push(Primitive {
kind: PrimitiveKind::Picture(Picture {
position: Point2::new(0f32, 0f32),
width: w,
height: h,
image: preloaded_images.transparent_sqr,
}),
with_projection: false,
});
ui.primitives.push(Primitive {
kind: PrimitiveKind::Text(Text {
position: Point2::new(w - w / 7.0, h / 20.0),
color: (1.0, 1.0, 1.0, 1.0),
text: format!("$ {}", macro_game.coins).to_string(),
font_size: 1.0,
}),
with_projection: false,
});
let button_w = w / 12f32;
let button_h = button_w;
let mut buttons = vec![];
let buttons_names = vec!["", ""];
let guns = vec![Widgets::BlasterGun, Widgets::LazerGun];
let locked_guns_ids =
vec![Widgets::LockedBlasterGun, Widgets::LockedLazerGun];
let buttons_num = buttons_names.len();
let button_images = vec![
preloaded_images.blaster,
preloaded_images.lazer,
preloaded_images.blaster,
];
let shift_between = w / 20f32;
let shift_init = w / 2.0 - shift_between - button_w - button_w / 2.0;
// -button_w / 2.0 since start draw from left corner :)
for i in 0..buttons_num {
let unlocked = macro_game.guns_unlocked[i];
let button_position = Point2::new(
shift_init + i as f32 * (shift_between + button_w),
button_h / 2f32,
);
if unlocked {
let button = Button::new(
button_position,
button_w,
button_h,
None,
false,
Some(button_images[i]),
buttons_names[i].to_string(),
guns[i] as usize,
Some(Sound(
preloaded_sounds.hover,
Point2::new(0f32, 0f32),
)),
Some(Sound(
preloaded_sounds.click,
Point2::new(0f32, 0f32),
)),
);
buttons.push(button);
} else {
let button = Button::new(
button_position,
button_w,
button_h,
None,
false,
Some(preloaded_images.locked),
format!("{} $", description.gun_costs[i]),
locked_guns_ids[i] as usize,
Some(Sound(
preloaded_sounds.hover,
Point2::new(0f32, 0f32),
)),
Some(Sound(preloaded_sounds.deny, Point2::new(0f32, 0f32))),
);
buttons.push(button);
}
}
let weapon_selector = Selector {
buttons: buttons,
id: Widgets::WeaponSelector as usize,
mask: Some(macro_game.guns_unlocked.clone()),
};
if let Some(selected_id) =
weapon_selector.place_and_check(&mut ui, &*mouse)
{
match Widgets::try_from(selected_id).expect("unknown widget id") {
Widgets::BlasterGun => {
ui_state.chosed_gun =
Some(description.player_guns[0].clone());
// sounds_channel.single_write(Sound(
// coin_sound,
// Point2::new(collectable_position.x, collectable_position.y)
// )
// );
}
Widgets::LazerGun => {
ui_state.chosed_gun =
Some(description.player_guns[1].clone());
}
Widgets::ShotGun => {
ui_state.chosed_gun =
Some(description.player_guns[2].clone());
}
Widgets::LockedLazerGun => {
if macro_game.coins >= description.gun_costs[1] {
macro_game.guns_unlocked[1] = true;
sounds_channel.single_write(Sound(
preloaded_sounds.buy,
Point2::new(0f32, 0f32),
));
macro_game.coins -= description.gun_costs[1];
ui_state.chosed_gun =
Some(description.player_guns[1].clone());
}
}
_ => (),
}
}
let mut buttons = vec![];
let ships_ids =
vec![Widgets::BasicShip, Widgets::HeavyShip, Widgets::SuperShip];
let ship_images = vec![
preloaded_images.basic_ship,
preloaded_images.heavy_ship,
preloaded_images.super_ship,
];
let locked_ships_ids = vec![
Widgets::LockedBasicShip,
Widgets::LockedHeavyShip,
Widgets::LockedSuperShip,
];
for (i, ship) in description.player_ships.iter().enumerate() {
#[cfg(target_os = "android")]
trace!("{} of / {}", i, buttons_num);
let unlocked = macro_game.ships_unlocked[i];
let button_position = Point2::new(
shift_init + i as f32 * (shift_between + button_w),
button_h + button_h,
);
if unlocked {
let button = Button::new(
button_position,
button_w,
button_h,
None,
false,
Some(ship.image),
"".to_string(),
ships_ids[i] as usize,
Some(Sound(
preloaded_sounds.hover,
Point2::new(0f32, 0f32),
)),
Some(Sound(
preloaded_sounds.click,
Point2::new(0f32, 0f32),
)),
);
buttons.push(button);
} else {
let button = Button::new(
button_position,
button_w,
button_h,
None,
false,
Some(preloaded_images.locked),
format!("{} $", description.ship_costs[i]),
locked_ships_ids[i] as usize,
Some(Sound(
preloaded_sounds.hover,
Point2::new(0f32, 0f32),
)),
Some(Sound(preloaded_sounds.deny, Point2::new(0f32, 0f32))),
);
buttons.push(button);
}
}
let ships_selector = Selector {
buttons: buttons,
id: Widgets::ShipsSelector as usize,
mask: Some(macro_game.ships_unlocked.clone()),
};
if let Some(selected_id) =
ships_selector.place_and_check(&mut ui, &*mouse)
{
// ui_state.chosed_ship = Some(selected_id);
match Widgets::try_from(selected_id).expect("unknown widget id") {
Widgets::BasicShip => {
ui_state.chosed_ship = Some(0);
}
Widgets::HeavyShip => {
ui_state.chosed_ship = Some(1);
}
Widgets::SuperShip => {
ui_state.chosed_ship = Some(2);
}
Widgets::LockedHeavyShip => {
if macro_game.coins >= description.ship_costs[1] {
macro_game.ships_unlocked[1] = true;
sounds_channel.single_write(Sound(
preloaded_sounds.buy,
Point2::new(0f32, 0f32),
));
macro_game.coins -= description.ship_costs[1];
}
}
Widgets::LockedSuperShip => {
if macro_game.coins >= description.ship_costs[2] {
macro_game.ships_unlocked[2] = true;
sounds_channel.single_write(Sound(
preloaded_sounds.buy,
Point2::new(0f32, 0f32),
));
macro_game.coins -= description.ship_costs[2];
}
}
_ => (),
}
}
let button_w = w / 6.0;
let button_h = button_w;
let score_table_button = Button::new(
Point2::new(w / 2.0, 1.5 * button_h + shift_between),
button_w,
button_h / 5.0,
None,
false,
Some(preloaded_images.upg_bar),
"Score Table".to_string(),
Widgets::ScoreTable as usize,
Some(Sound(preloaded_sounds.hover, Point2::new(0f32, 0f32))),
Some(Sound(preloaded_sounds.click, Point2::new(0f32, 0f32))),
);
if score_table_button.place_and_check(&mut ui, &*mouse) {
*app_state = AppState::ScoreTable;
}
let button_w = button_w / 2.0;
let button_h = button_w;
let button = Button::new(
Point2::new(w / 2.0 - button_w / 2.0, h - button_h),
// Point2::new(0f32, 0f32),
button_w,
button_h / 4.0,
None,
false,
Some(preloaded_images.upg_bar),
"Play".to_string(),
Widgets::Play as usize,
Some(Sound(preloaded_sounds.hover, Point2::new(0f32, 0f32))),
Some(Sound(preloaded_sounds.play, Point2::new(0f32, 0f32))),
);
if let (Some(ship), Some(gun)) =
(ui_state.chosed_ship.clone(), ui_state.chosed_gun.clone())
{
if button.place_and_check(&mut ui, &*mouse) {
*app_state = AppState::Play(PlayState::Action);
insert_channel.single_write(InsertEvent::Character {
gun_kind: gun.clone(),
ship_stats: description.player_ships[ship].ship_stats,
image: ship_images[ship],
});
*avaliable_upgrades = get_avaliable_cards(
&upgrade_cards_raw,
&gun.clone(),
&name_to_atlas,
);
}
}
primitives_channel.iter_write(ui.primitives.drain(..));
sounds_channel.iter_write(ui.sounds.drain(..));
}
}
|
use std::collections::HashMap;
fn main() {
let input = vec![16, 11, 15, 0, 1, 7];
// Challenge1
let mut mem: HashMap<usize, Vec<usize>> = HashMap::new();
for (i, n) in input.iter().enumerate() {
let mut v: Vec<usize> = Vec::new();
v.push(i + 1);
mem.insert(*n, v);
}
let mut spoken = input[input.len() - 1];
let mut round = input.len() + 1;
while round <= 30000000 {
if mem.get(&spoken).unwrap().len() < 2 {
spoken = 0;
} else {
let v = mem.get(&spoken).unwrap();
spoken = v[v.len() - 1] - v[v.len() - 2];
}
let v = mem.entry(spoken).or_insert(Vec::new());
v.push(round);
round += 1;
}
println!("Challenge1: {}", spoken);
}
|
#[doc = "Register `PMEM3` reader"]
pub type R = crate::R<PMEM3_SPEC>;
#[doc = "Register `PMEM3` writer"]
pub type W = crate::W<PMEM3_SPEC>;
#[doc = "Field `MEMSETx` reader - MEMSETx"]
pub type MEMSETX_R = crate::FieldReader;
#[doc = "Field `MEMSETx` writer - MEMSETx"]
pub type MEMSETX_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 8, O>;
#[doc = "Field `MEMWAITx` reader - MEMWAITx"]
pub type MEMWAITX_R = crate::FieldReader;
#[doc = "Field `MEMWAITx` writer - MEMWAITx"]
pub type MEMWAITX_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 8, O>;
#[doc = "Field `MEMHOLDx` reader - MEMHOLDx"]
pub type MEMHOLDX_R = crate::FieldReader;
#[doc = "Field `MEMHOLDx` writer - MEMHOLDx"]
pub type MEMHOLDX_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 8, O>;
#[doc = "Field `MEMHIZx` reader - MEMHIZx"]
pub type MEMHIZX_R = crate::FieldReader;
#[doc = "Field `MEMHIZx` writer - MEMHIZx"]
pub type MEMHIZX_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 8, O>;
impl R {
#[doc = "Bits 0:7 - MEMSETx"]
#[inline(always)]
pub fn memsetx(&self) -> MEMSETX_R {
MEMSETX_R::new((self.bits & 0xff) as u8)
}
#[doc = "Bits 8:15 - MEMWAITx"]
#[inline(always)]
pub fn memwaitx(&self) -> MEMWAITX_R {
MEMWAITX_R::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 16:23 - MEMHOLDx"]
#[inline(always)]
pub fn memholdx(&self) -> MEMHOLDX_R {
MEMHOLDX_R::new(((self.bits >> 16) & 0xff) as u8)
}
#[doc = "Bits 24:31 - MEMHIZx"]
#[inline(always)]
pub fn memhizx(&self) -> MEMHIZX_R {
MEMHIZX_R::new(((self.bits >> 24) & 0xff) as u8)
}
}
impl W {
#[doc = "Bits 0:7 - MEMSETx"]
#[inline(always)]
#[must_use]
pub fn memsetx(&mut self) -> MEMSETX_W<PMEM3_SPEC, 0> {
MEMSETX_W::new(self)
}
#[doc = "Bits 8:15 - MEMWAITx"]
#[inline(always)]
#[must_use]
pub fn memwaitx(&mut self) -> MEMWAITX_W<PMEM3_SPEC, 8> {
MEMWAITX_W::new(self)
}
#[doc = "Bits 16:23 - MEMHOLDx"]
#[inline(always)]
#[must_use]
pub fn memholdx(&mut self) -> MEMHOLDX_W<PMEM3_SPEC, 16> {
MEMHOLDX_W::new(self)
}
#[doc = "Bits 24:31 - MEMHIZx"]
#[inline(always)]
#[must_use]
pub fn memhizx(&mut self) -> MEMHIZX_W<PMEM3_SPEC, 24> {
MEMHIZX_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 = "Common memory space timing register 3\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`pmem3::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 [`pmem3::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct PMEM3_SPEC;
impl crate::RegisterSpec for PMEM3_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`pmem3::R`](R) reader structure"]
impl crate::Readable for PMEM3_SPEC {}
#[doc = "`write(|w| ..)` method takes [`pmem3::W`](W) writer structure"]
impl crate::Writable for PMEM3_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets PMEM3 to value 0xfcfc_fcfc"]
impl crate::Resettable for PMEM3_SPEC {
const RESET_VALUE: Self::Ux = 0xfcfc_fcfc;
}
|
use structopt::StructOpt;
mod commands;
mod model;
use commands::*;
const PROJECT_FILE_NAME: &'static str = ".gitproject";
const PROJECT_TEMP_FILE: &'static str = ".git/.gitproject~";
/// Git-based project boards.
#[derive(Debug, StructOpt)]
enum Args {
/// Opens the project board UI
Open,
/// Creates a new project, or sets up your repo to support git projects
Init(Init),
/// Check the tasks currently assigned to you
Current,
/// Adds the hooks to your repository.
///
/// The git-project hooks will be appended to the end of your existing Git hooks, if any.
/// If you did not have existing Git hooks, this will be done automatically on running
/// `git project init`, so you should not need to use this command.
///
/// If you wish to customize this behaviour, to better integrate with your workflow or
/// existing git hooks, feel free to add them manually.
///
/// Note that hooks are *not* included when distributing your repository, so subsequent clones
/// will require you to install hooks again.
Hooks,
/// The built in Git hooks. Not meant to be used manually.
Hook(Hook),
}
#[paw::main]
fn main(args: Args) {
let result = match args {
Args::Open => open(),
Args::Init(args) => init(args),
Args::Current => current(),
Args::Hooks => hooks(),
Args::Hook(args) => hook(args),
};
if let Err(error) = result {
eprintln!("{}", error);
std::process::exit(1);
}
}
|
impl Solution {
pub fn max_turbulence_size(arr: Vec<i32>) -> i32 {
let n = arr.len();
let mut start = 0;
let mut end = 1;
let mut direction = false;
let mut ans = 1;
while end < n{
if start + 1 == end {
if arr[end - 1 ] > arr[end]{
direction = true;
ans = ans.max(2);
}else if arr[end - 1] < arr[end]{
direction = false;
ans = ans.max(2);
}else{
start+=1;
}
end += 1 ;
}else{
if (arr[end-1] > arr[end] && !direction) || (arr[end-1] < arr[end] && direction){
ans = ans.max(end - start + 1);
end += 1;
direction = !direction;
}else{
start = end - 1;
}
}
}
return ans as i32;
}
} |
use std::collections::HashMap;
fn main(){
let puzzle_input = include_str!("puzzle_input.txt");
println!("{}", largest_value_after_processing(puzzle_input));
}
#[derive(Debug)]
enum Change {
Increment,
Decrement
}
impl Change {
fn from_str(input: &str) -> Change {
match input {
"dec" => Change::Decrement,
"inc" => Change::Increment,
_ => panic!("Unsupported instruction."),
}
}
}
#[derive(Debug)]
enum Comparison {
GreaterThan,
EqualTo,
GreaterThanOrEqualTo,
LessThan,
LessThanOrEqualTo,
NotEqualTo,
}
impl Comparison {
fn from_str(input: &str) ->Comparison {
match input {
">" => Comparison::GreaterThan,
"==" => Comparison::EqualTo,
">=" => Comparison::GreaterThanOrEqualTo,
"<" => Comparison::LessThan,
"<=" => Comparison::LessThanOrEqualTo,
"!=" => Comparison::NotEqualTo,
_ => panic!("Operator not recognized."),
}
}
}
#[derive(Debug)]
struct Condition {
other_register: String,
comparison: Comparison,
comparison_value: i32,
}
#[derive(Debug)]
struct Instruction {
register: String,
change: Change,
change_amount: i32,
condition: Condition,
}
impl Instruction {
fn from(raw_instruction: &str) -> Instruction {
let mut parts: Vec<&str> = raw_instruction.split_whitespace().collect();
//e.g b inc 5 if a > 1
Instruction {
register: parts[0].to_owned(),
change: Change::from_str(parts[1]),
change_amount: parts[2].parse::<i32>().unwrap(),
condition: Condition {
other_register: parts[4].to_owned(),
comparison: Comparison::from_str(parts[5]),
comparison_value: parts[6].parse::<i32>().unwrap(),
},
}
}
}
#[derive(Debug)]
struct Computer {
registers: HashMap<String, i32>,
}
impl Computer{
fn new()->Computer{
Computer{
registers:HashMap::new(),
}
}
fn execute(&mut self, instructions: Vec<Instruction>) {
instructions.iter().for_each(|instruction|{
let condition_result = self.condition_is_true(&instruction.condition);
let register_value = self.registers
.entry(instruction.register.to_owned())
.or_insert(0);
if condition_result {
match instruction.change {
Change::Increment => *register_value += instruction.change_amount,
Change::Decrement => *register_value -= instruction.change_amount,
}
}
})
}
fn largest_value(&self) -> i32 {
let mut values: Vec<&i32> = self.registers.values().collect();
values.sort();
**values.last().unwrap()
}
fn condition_is_true(&self, condition: &Condition) -> bool {
let other_value = match self.registers.get(&condition.other_register){
Some(value) => value,
None => &0,
};
match condition.comparison{
Comparison::EqualTo => *other_value == condition.comparison_value,
Comparison::GreaterThan => *other_value > condition.comparison_value,
Comparison::GreaterThanOrEqualTo => *other_value >= condition.comparison_value,
Comparison::LessThan => *other_value < condition.comparison_value,
Comparison::LessThanOrEqualTo => *other_value <= condition.comparison_value,
Comparison::NotEqualTo => *other_value != condition.comparison_value,
}
}
}
fn largest_value_after_processing(input: &str) -> i32{
let instructions:Vec<Instruction> = input.lines().map(|line| Instruction::from(line)).collect();
let mut computer = Computer::new();
computer.execute(instructions);
computer.largest_value()
}
#[test]
fn example(){
let puzzle_input = include_str!("example.txt");
assert_eq!(1, largest_value_after_processing(puzzle_input));
} |
#![feature(test)]
// #[macro_use]
// extern crate serde_derive;
#[macro_use]
extern crate serde_json;
#[macro_use]
extern crate criterion;
use criterion::Criterion;
use doc_store::DocLoader;
use rand::Rng;
use veloci::{search::*, *};
static TEST_FOLDER: &str = "veloci_bins/jmdict";
//fn load_persistence_im() -> persistence::Persistence {
//persistence::Persistence::load(TEST_FOLDER.to_string()).expect("Could not load persistence")
//}
fn load_persistence_disk() -> persistence::Persistence {
persistence::Persistence::load(TEST_FOLDER.to_string()).expect("Could not load persistence")
}
// fn load_gutenberg_persistence() -> persistence::Persistence {
// persistence::Persistence::load("gutenberg".to_string()).expect("Could not load persistence")
// }
#[cfg(test)]
mod bench_jmdict {
// fn search_testo_to_doc(req: Value) -> Result<Vec<search::DocWithHit>, VelociError> {
// let persistences = PERSISTENCES.read().unwrap();
// let pers = persistences.get(&"default".to_string()).unwrap();
// let requesto: search::Request = serde_json::from_str(&req.to_string()).expect("Can't parse json");
// let hits = search::search(requesto, pers)?;
// Ok(search::to_documents(pers, &hits.data))
// }
#[bench]
fn highlight_in_book(b: &mut Bencher) {
let pers = load_gutenberg_persistence();
b.iter(|| highlight("pride", "content", &pers));
}
// #[bench]
// fn get_text_ids_fst(b: &mut Bencher) {
// let mut rng = rand::thread_rng();
// let between = Range::new(0, 7000);
// let pers = load_gutenberg_persistence();
// b.iter(|| {
// search_field::get_text_for_id(
// &pers,
// "content.textindex",
// between.ind_sample(&mut rng) as u32,
// )
// });
// }
// #[bench]
// fn get_text_ids_fst_cache(b: &mut Bencher) {
// let mut rng = rand::thread_rng();
// let between = Range::new(0, 7000);
// let pers = load_gutenberg_persistence();
// let mut bytes = vec![];
// b.iter(|| {
// search_field::get_text_for_id_2(
// &pers,
// "content.textindex",
// between.ind_sample(&mut rng) as u32,
// &mut bytes,
// )
// });
// }
// #[bench]
// fn get_text_ids_disk(b: &mut Bencher) {
// let mut rng = rand::thread_rng();
// let between = Range::new(0, 7000);
// let pers = load_gutenberg_persistence();
// b.iter(|| {
// search_field::get_text_for_id_disk(
// &pers,
// "content.textindex",
// between.ind_sample(&mut rng) as u32,
// )
// });
// }
// #[bench]
// fn get_text_ids_cache_fst_cache_bytes(b: &mut Bencher) {
// let mut rng = rand::thread_rng();
// let between = Range::new(0, 7000);
// let pers = load_gutenberg_persistence();
// let map = pers.cache.fst.get("content.textindex").unwrap();
// let mut bytes = vec![];
// b.iter(|| {
// search_field::ord_to_term(
// map.as_fst(),
// between.ind_sample(&mut rng) as u64,
// &mut bytes,
// )
// });
// }
// #[test]
// fn highlight_in_book_yeah() {
// let pers = load_gutenberg_persistence();
// assert_eq!(highlight("pride", "content", &pers)[0].0, "QUAARK");
// }
}
fn get_request(term: &str, levenshtein_distance: u32) -> search::Request {
let query = json!({
"or": {
"queries": [
{
"search": {
"terms": vec![term.to_string()],
"path": "kanji[].text",
"levenshtein_distance": levenshtein_distance,
"starts_with": true,
"options": {
"boost": [
{
"path": "commonness",
"boost_fun": "Log10",
"param": 1
},
{
"path": "kanji[].commonness",
"boost_fun": "Log10",
"param": 1
}
]
}
},
},
{
"search": {
"terms": vec![term.to_string()],
"path": "kana[].text",
"levenshtein_distance": levenshtein_distance,
"starts_with": true,
"options": {
"boost": [
{
"path": "commonness",
"boost_fun": "Log10",
"param": 1
},
{
"path": "kana[].commonness",
"boost_fun": "Log10",
"param": 1
}
]
}
},
},
{
"search": {
"terms": vec![term.to_string()],
"path": "kana[].text",
"levenshtein_distance": levenshtein_distance,
"starts_with": true,
"options": {
"boost": [
{
"path": "commonness",
"boost_fun": "Log10",
"param": 1
},
{
"path": "kana[].commonness",
"boost_fun": "Log10",
"param": 1
}
]
}
}
},
{
"search": {
"terms": vec![term.to_string()],
"path": "meanings.ger[].text",
"levenshtein_distance": levenshtein_distance,
"options": {
"boost": [
{
"path": "commonness",
"boost_fun": "Log10",
"param": 0
},
{
"path": "meanings.ger[].rank",
"expression": "10 / $SCORE"
}
]
}
},
},
{
"search": {
"terms": vec![term.to_string()],
"path": "meanings.eng[]",
"levenshtein_distance": levenshtein_distance,
"options": {
"boost": [
{
"path": "commonness",
"boost_fun": "Log10",
"param": 1
}
]
}
},
}
],
"options":{
"top": 10,
"skip": 0
}
}
});
let requesto: SearchRequest = serde_json::from_str(&query.to_string()).expect("Can't parse json");
search::Request {
search_req: Some(requesto),
..Default::default()
}
}
fn search(term: &str, pers: &persistence::Persistence, levenshtein_distance: u32) -> Vec<search::DocWithHit> {
let requesto = get_request(term, levenshtein_distance);
let hits = search::search(requesto, pers).unwrap();
search::to_documents(pers, &hits.data, &None, &hits)
}
fn search_freestyle(term: &str, pers: &persistence::Persistence) -> Vec<search::DocWithHit> {
let yop = query_generator::SearchQueryGeneratorParameters {
search_term: term.to_string(),
..Default::default()
};
let requesto = query_generator::search_query(pers, yop).unwrap();
let hits = search::search(requesto, pers).unwrap();
search::to_documents(pers, &hits.data, &None, &hits)
}
fn suggest(term: &str, path: &str, pers: &persistence::Persistence) -> search_field::SuggestFieldResult {
let req = json!({
"terms":[term],
"path": path,
"levenshtein_distance": 0,
"starts_with":true,
"top":10,
"skip":0
});
let requesto: search::RequestSearchPart = serde_json::from_str(&req.to_string()).expect("Can't parse json");
search_field::suggest(pers, &requesto).unwrap()
}
fn highlight(term: &str, path: &str, pers: &persistence::Persistence) -> search_field::SuggestFieldResult {
let req = json!({
"terms":[term],
"path": path,
"levenshtein_distance": 0,
"starts_with":true,
"snippet":true,
"top":10,
"skip":0
});
let mut requesto: search::RequestSearchPart = serde_json::from_str(&req.to_string()).expect("Can't parse json");
search_field::highlight(pers, &mut requesto).unwrap()
}
// fn get_text_ids_cache_fst_cache_bytes(c: &mut Criterion) {
// let mut rng = rand::thread_rng();
// let between = Range::new(0, 7000);
// let pers = load_gutenberg_persistence();
// let map = pers.cache.fst.get("content.textindex").unwrap();
// let mut bytes = vec![];
// Criterion::default()
// .bench_function("get_text_ids_cache_fst_cache_bytes", |b| b.iter(|| {
// search_field::ord_to_term(
// map.as_fst(),
// 4350 as u64,
// &mut bytes,
// )
// }));
// let mut bytes = vec![];
// Criterion::default()
// .bench_function("get_text_ids_disk", |b| b.iter(|| {
// search_field::get_text_for_id_2(
// &pers,
// "content.textindex",
// 4350 as u32,
// &mut bytes,
// )
// }));
// Criterion::default()
// .bench_function("get_text_ids_fst_cache", |b| b.iter(|| {
// search_field::get_text_for_id_2(
// &pers,
// "content.textindex",
// 4350 as u32,
// &mut bytes,
// )
// }));
// Criterion::default()
// .bench_function("get_text_ids_fst", |b| b.iter(|| {
// search_field::get_text_for_id(
// &pers,
// "content.textindex",
// 4350 as u32,
// )
// }));
// }
fn searches(c: &mut Criterion) {
let pers = load_persistence_disk();
//let pers_im = load_persistence_im();
c.bench_function("jmdict_search_anschauen_fuzzy", |b| b.iter(|| search("anschauen", &pers, 1)));
c.bench_function("jmdict_search_anschauen_exact", |b| b.iter(|| search("anschauen", &pers, 0)));
c.bench_function("jmdict_search_haus", |b| b.iter(|| search("haus", &pers, 1)));
c.bench_function("jmdict_search_freestyle_haus", |b| b.iter(|| search_freestyle("haus", &pers)));
c.bench_function("jmdict_search_in_a_hurry", |b| b.iter(|| search_freestyle("in a hurry", &pers)));
c.bench_function("jmdict_search_japanese", |b| b.iter(|| search("家", &pers, 0)));
let facets: Vec<FacetRequest> = vec![FacetRequest {
field: "commonness".to_string(),
..Default::default()
}];
let req = json!({
"search": {
"terms": ["the"],
"path": "meanings.eng[]",
"levenshtein_distance":0
},
"top": 10,
"skip": 0,
"facets": [ {"field":"commonness"}]
});
let requesto: search::Request = serde_json::from_str(&req.to_string()).expect("Can't parse json");
c.bench_function("jmdict_search_facets", |b| b.iter(|| search::search(requesto.clone(), &pers)));
//c.bench_function("jmdict_search_facets_im", |b| b.iter(|| search::search(requesto.clone(), &pers_im)));
c.bench_function("jmdict_suggest_an", |b| b.iter(|| suggest("an", "meanings.ger[].text", &pers)));
let mut rng = rand::thread_rng();
let fields = pers.metadata.get_all_fields();
let tree = get_read_tree_from_fields(&pers, &fields);
let single_tree = get_read_tree_from_fields(&pers, &vec!["ent_seq".to_string()]);
let doc_store_data = pers.get_file_bytes("data").expect("could not open document store");
let doc_loader = DocLoader::open(&doc_store_data);
c.bench_function("load_documents_direct_large", |b| b.iter(|| doc_loader.get_doc(166600)));
c.bench_function("load_documents_tree_large", |b| b.iter(|| search::read_tree(&pers, 166600, &tree)));
c.bench_function("load_documents_direct_random", |b| b.iter(|| doc_loader.get_doc(rng.gen_range(0..166600))));
c.bench_function("load_documents_cache:tree_random", |b| b.iter(|| search::read_tree(&pers, rng.gen_range(0..166600), &tree)));
c.bench_function("load_documents_new_tree_random", |b| {
b.iter(|| {
let fields = pers.metadata.get_all_fields();
let tree = get_read_tree_from_fields(&pers, &fields);
search::read_tree(&pers, rng.gen_range(0..166600), &tree)
})
});
c.bench_function("load_documents_tree_random_single_field", |b| {
b.iter(|| search::read_tree(&pers, rng.gen_range(0..166600), &single_tree))
});
c.bench_function("jmdict_suggest_a", |b| b.iter(|| suggest("a", "meanings.ger[].text", &pers)));
c.bench_function("jmdict_suggest_kana_a", |b| b.iter(|| suggest("あ", "kana[].text", &pers)));
c.bench_function("jmdict_suggest_kana_a", |b| b.iter(|| suggest("あ", "kana[].text", &pers)));
}
criterion_group!(benches, searches);
criterion_main!(benches);
|
use std::alloc::{alloc, dealloc, Layout};
use super::bindings::consts::*;
use super::bindings::types::*;
pub struct SafeSetup {
pub bustype: u16,
pub vendor: u16,
pub product: u16,
pub version: u16,
pub ff_effects_max: u32,
pub name: &'static str,
}
pub struct Setup {
layout: Layout,
raw_ptr: *mut u8,
}
impl Setup {
pub fn new() -> Setup {
let layout = Layout::new::<uinput_setup>();
let raw_ptr = unsafe { alloc(layout) };
Self { layout, raw_ptr }
}
pub fn const_ptr(&self) -> *const uinput_setup {
self.raw_ptr as *const uinput_setup
}
}
impl From<SafeSetup> for Setup {
fn from(safe: SafeSetup) -> Self {
let setup = Self::new();
let setup_ptr = setup.raw_ptr as *mut uinput_setup;
unsafe {
(*setup_ptr).id.bustype = safe.bustype;
(*setup_ptr).id.vendor = safe.vendor;
(*setup_ptr).id.product = safe.product;
(*setup_ptr).id.version = safe.version;
(*setup_ptr).ff_effects_max = safe.ff_effects_max;
libc::strcpy(
(*setup_ptr).name.as_mut_ptr(),
safe.name.as_ptr() as *const i8,
);
}
setup
}
}
impl Drop for Setup {
fn drop(&mut self) {
unsafe {
dealloc(self.raw_ptr, self.layout);
}
}
}
pub struct SafeAbsSetup {
pub code: u16,
pub value: i32,
pub minimum: i32,
pub maximum: i32,
pub fuzz: i32,
pub flat: i32,
pub resolution: i32,
}
pub struct AbsSetup {
layout: Layout,
raw_ptr: *mut u8,
}
impl AbsSetup {
pub fn new() -> AbsSetup {
let layout = Layout::new::<uinput_abs_setup>();
let raw_ptr = unsafe { alloc(layout) };
Self { layout, raw_ptr }
}
pub fn const_ptr(&self) -> *const uinput_abs_setup {
self.raw_ptr as *const uinput_abs_setup
}
}
impl From<SafeAbsSetup> for AbsSetup {
fn from(safe: SafeAbsSetup) -> Self {
let setup = Self::new();
let setup_ptr = setup.raw_ptr as *mut uinput_abs_setup;
unsafe {
(*setup_ptr).code = safe.code;
(*setup_ptr).absinfo.value = safe.value;
(*setup_ptr).absinfo.minimum = safe.minimum;
(*setup_ptr).absinfo.maximum = safe.maximum;
(*setup_ptr).absinfo.fuzz = safe.fuzz;
(*setup_ptr).absinfo.flat = safe.flat;
(*setup_ptr).absinfo.resolution = safe.resolution;
}
setup
}
}
impl Drop for AbsSetup {
fn drop(&mut self) {
unsafe {
dealloc(self.raw_ptr, self.layout);
}
}
}
#[derive(Debug)]
pub struct SafeInputEvent {
pub code: u16,
pub r#type: u16,
pub value: i32,
pub time: (i64, i64),
}
impl From<InputEvent> for SafeInputEvent {
fn from(event: InputEvent) -> Self {
let ptr = unsafe { *(event.raw_ptr as *const input_event) };
Self {
code: ptr.code,
r#type: ptr.type_,
value: ptr.value,
time: (ptr.time.tv_sec, ptr.time.tv_usec),
}
}
}
pub struct InputEvent {
layout: Layout,
raw_ptr: *mut u8,
}
impl InputEvent {
pub fn new() -> InputEvent {
let layout = Layout::new::<input_event>();
let raw_ptr = unsafe { alloc(layout) };
Self { layout, raw_ptr }
}
pub fn size() -> usize {
std::mem::size_of::<input_event>()
}
pub fn c_ptr(&self) -> *mut libc::c_void {
self.raw_ptr as *mut libc::c_void
}
}
impl From<SafeInputEvent> for InputEvent {
fn from(safe: SafeInputEvent) -> Self {
let event = Self::new();
let event_ptr = event.raw_ptr as *mut input_event;
unsafe {
(*event_ptr).time.tv_sec = safe.time.0;
(*event_ptr).time.tv_usec = safe.time.1;
(*event_ptr).type_ = safe.r#type;
(*event_ptr).code = safe.code;
(*event_ptr).value = safe.value;
}
event
}
}
impl Drop for InputEvent {
fn drop(&mut self) {
unsafe {
dealloc(self.raw_ptr, self.layout);
}
}
}
pub enum ForceFeedback {
Rumble { large_motor: u16, small_motor: u16 },
Unsupported,
}
pub struct ForceFeedbackUpload {
layout: Layout,
raw_ptr: *mut u8,
}
impl ForceFeedbackUpload {
pub fn new(request_id: u32) -> Self {
let layout = Layout::new::<uinput_ff_upload>();
let raw_ptr = unsafe { alloc(layout) };
unsafe {
(*(raw_ptr as *mut uinput_ff_upload)).request_id = request_id;
}
Self { layout, raw_ptr }
}
pub fn mut_ptr(&self) -> *mut uinput_ff_upload {
self.raw_ptr as *mut uinput_ff_upload
}
pub fn set_retval(&mut self, retval: i32) {
unsafe {
(*(self.raw_ptr as *mut uinput_ff_upload)).retval = retval;
}
}
pub fn get_data(&self) -> (u32, ForceFeedback) {
let ptr = self.raw_ptr as *const uinput_ff_upload;
unsafe {
let force_feedback = if (*ptr).effect.type_ == FF_RUMBLE as u16 {
ForceFeedback::Rumble {
large_motor: (*ptr).effect.u.rumble.strong_magnitude,
small_motor: (*ptr).effect.u.rumble.weak_magnitude,
}
} else {
ForceFeedback::Unsupported
};
((*ptr).effect.id as u32, force_feedback)
}
}
}
impl Drop for ForceFeedbackUpload {
fn drop(&mut self) {
unsafe {
dealloc(self.raw_ptr, self.layout);
}
}
}
pub struct ForceFeedbackErase {
layout: Layout,
raw_ptr: *mut u8,
}
impl ForceFeedbackErase {
pub fn new(request_id: u32) -> Self {
let layout = Layout::new::<uinput_ff_erase>();
let raw_ptr = unsafe { alloc(layout) };
unsafe {
(*(raw_ptr as *mut uinput_ff_erase)).request_id = request_id;
}
Self { layout, raw_ptr }
}
pub fn mut_ptr(&self) -> *mut uinput_ff_erase {
self.raw_ptr as *mut uinput_ff_erase
}
pub fn set_retval(&mut self, retval: i32) {
unsafe {
(*(self.raw_ptr as *mut uinput_ff_erase)).retval = retval;
}
}
pub fn get_effect_id(&self) -> u32 {
unsafe { (*(self.raw_ptr as *const uinput_ff_erase)).effect_id }
}
}
impl Drop for ForceFeedbackErase {
fn drop(&mut self) {
unsafe {
dealloc(self.raw_ptr, self.layout);
}
}
}
|
use super::*;
/// A custom keyboard with reply options.
#[derive(Debug,Serialize)]
pub struct ReplyKeyboardMarkup {
/// An array of button rows, each containing an array of buttons.
pub keyboard: Vec<Vec<Box<KeyboardButton>>>,
/// Requests client to resize the keyboard vertically for an optimal
/// fit.
pub resize_keyboard: Option<bool>,
/// Requests clients to hide the keyboard once it has been used.
pub one_time_keyboard: Option<bool>,
/// If set, only show the keyboard to users mentioned in the text of the
/// message, or the sender of the original message if this is a reply.
pub selective: Option<bool>
}
|
use syn::{self, Ident, Type};
use overrides::Overrides;
pub struct Field {
pub name: String,
pub ident: Ident,
pub type_: Type,
}
impl Field {
pub fn parse(raw: &syn::Field) -> Result<Field, String> {
let overrides = Overrides::extract(&raw.attrs)?;
let ident = raw.ident.as_ref().unwrap().clone();
Ok(Field {
name: overrides.name.unwrap_or_else(|| ident.to_string()),
ident,
type_: raw.ty.clone(),
})
}
}
|
pub mod message_type;
pub mod lib;
pub mod encryption;
pub mod debug_message; |
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Search {
Limit(i32),
Text(String)
}
pub struct Videos {
}
impl Videos {
pub fn search(search : Option<Search>) {
}
}
|
#[doc = r"Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - MDMA Global Interrupt/Status Register"]
pub gisr0: GISR0,
_reserved1: [u8; 0x3c],
#[doc = "0x40..0x440 - Channel cluster: C?ISR, C?IFCR, C?ESR, C?CR, C?TCR, C?BNDTR, C?SAR, C?DAR, C?BRUR, C?LAR, C?TBR, C?MAR and C?MDR registers"]
pub ch: [CH; 16],
}
#[doc = "GISR0 (r) register accessor: MDMA Global Interrupt/Status Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`gisr0::R`]. See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [`gisr0`]
module"]
pub type GISR0 = crate::Reg<gisr0::GISR0_SPEC>;
#[doc = "MDMA Global Interrupt/Status Register"]
pub mod gisr0;
#[doc = "Channel cluster: C?ISR, C?IFCR, C?ESR, C?CR, C?TCR, C?BNDTR, C?SAR, C?DAR, C?BRUR, C?LAR, C?TBR, C?MAR and C?MDR registers"]
pub use self::ch::CH;
#[doc = r"Cluster"]
#[doc = "Channel cluster: C?ISR, C?IFCR, C?ESR, C?CR, C?TCR, C?BNDTR, C?SAR, C?DAR, C?BRUR, C?LAR, C?TBR, C?MAR and C?MDR registers"]
pub mod ch;
|
pub fn length_of_longest_substring(s: String) -> i32 {
let s: Vec<char> = s.chars().collect();
let n = s.len();
if n <= 1 {
return n as i32;
}
let mut location_arr: Vec<usize> = vec![0; n];
let mut next_location_table: Vec<i32> = vec![-1; 256];
for i in (0..n).rev() {
let char = s[i] as usize;
match next_location_table[char] {
-1 => {
// This char is first seen.
location_arr[i] = i;
next_location_table[char] = i as i32;
},
k => {
// This char has been seen before.
location_arr[i] = k as usize;
next_location_table[char] = i as i32;
},
}
}
let mut longest = 0;
for end in (1..n).rev() {
for start in (0..end).rev() {
if location_arr[start] <= end && location_arr[start] > start {
longest = std::cmp::max(longest, end-start);
break;
}
longest = std::cmp::max(longest, end-start+1);
}
}
longest as i32
}
#[test]
pub fn test_length_of_longest_substring() {
assert_eq!(length_of_longest_substring(String::from("abcabcbb")), 3);
assert_eq!(length_of_longest_substring(String::from("pwwkew")), 3);
assert_eq!(length_of_longest_substring(String::from("bbbbb")), 1);
assert_eq!(length_of_longest_substring(String::from("au")), 2);
} |
use crate::rtb_type;
rtb_type! {
DoohVenueType,
500,
Airborne=1
}
|
use std::fs::{self, File};
use std::path::PathBuf;
pub fn create_log_file(log_path_buf: &PathBuf) -> File {
let log_path = log_path_buf.as_path();
match log_path.parent() {
Some(log_folder) => fs::create_dir_all(log_folder).expect(&format!("Failed to create log folder: {}", log_folder.display())),
None => (), // current folder.
}
let log_file = match File::create(&log_path) {
Err(e) => panic!("Failed to create log file: {}: {}", log_path.display(), e),
Ok(file) => file,
};
return log_file;
}
|
#![cfg_attr(not(feature = "std"), no_std)]
use codec::{Decode, Encode};
use frame_support::{
decl_error, decl_event, decl_module, decl_storage, ensure, weights::Weight, Parameter,
};
use frame_system::ensure_signed;
#[cfg(feature = "std")]
use serde::{Deserialize, Serialize};
use sp_runtime::{
traits::{CheckedAdd, MaybeSerializeDeserialize, Member, StaticLookup},
DispatchError, DispatchResult, RuntimeDebug,
};
use sp_std::result;
use ternoa_common::traits::{LockableNFTs, NFTs};
#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;
mod default_weights;
#[cfg(test)]
mod tests;
/// Data related to an NFT, such as who is its owner.
#[derive(Encode, Decode, Clone, PartialEq, Eq, Default, RuntimeDebug)]
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
pub struct NFTData<AccountId, NFTDetails> {
pub owner: AccountId,
pub details: NFTDetails,
/// Set to true to prevent further modifications to the details struct
pub sealed: bool,
/// Set to true to prevent changes to the owner variable
pub locked: bool,
}
pub trait WeightInfo {
fn create() -> Weight;
fn mutate() -> Weight;
fn seal() -> Weight;
fn transfer() -> Weight;
}
pub trait Trait: frame_system::Trait {
/// Because this pallet emits events, it depends on the runtime's definition of an event.
type Event: From<Event<Self>> + Into<<Self as frame_system::Trait>::Event>;
/// How NFTs are represented
type NFTId: Parameter + Default + CheckedAdd + Copy + Member + From<u8>;
/// How NFT details are represented
type NFTDetails: Parameter + Member + MaybeSerializeDeserialize + Default;
type WeightInfo: WeightInfo;
}
decl_storage! {
trait Store for Module<T: Trait> as NFTs {
/// The number of NFTs managed by this pallet
pub Total get(fn total): T::NFTId;
/// Data related to NFTs.
pub Data get(fn data): map hasher(blake2_128_concat) T::NFTId => NFTData<T::AccountId, T::NFTDetails>;
}
add_extra_genesis {
config(nfts): Vec<(T::AccountId, T::NFTDetails)>;
// ^^ begin, length, amount liquid at genesis
build(|config: &GenesisConfig<T>| {
&config.nfts
.clone()
.into_iter()
.for_each(|(account, details)| drop(<Module<T> as NFTs>::create(&account, details)));
});
}
}
decl_event!(
pub enum Event<T>
where
AccountId = <T as frame_system::Trait>::AccountId,
NFTId = <T as Trait>::NFTId,
{
/// A new NFT was created. \[nft id, owner\]
Created(NFTId, AccountId),
/// An NFT was transferred to someone else. \[nft id, old owner, new owner\]
Transfer(NFTId, AccountId, AccountId),
/// An NFT was updated by its owner. \[nft id\]
Mutated(NFTId),
/// An NFT was sealed, preventing any new mutations. \[nft id\]
Sealed(NFTId),
/// An NFT has been locked, preventing transfers until it is unlocked.
/// \[nft id\]
Locked(NFTId),
/// A locked NFT has been unlocked. \[nft id\]
Unlocked(NFTId),
}
);
decl_error! {
pub enum Error for Module<T: Trait> {
/// We do not have any NFT id left, a runtime upgrade is necessary.
NFTIdOverflow,
/// This function can only be called by the owner of the nft.
NotOwner,
/// NFT is sealed and no longer accepts mutations.
Sealed,
/// NFT is locked and thus its owner cannot be changed until it
/// is unlocked.
Locked,
}
}
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
fn deposit_event() = default;
/// Create a new NFT with the provided details. An ID will be auto
/// generated and logged as an event, The caller of this function
/// will become the owner of the new NFT.
#[weight = T::WeightInfo::create()]
fn create(origin, details: T::NFTDetails) {
let who = ensure_signed(origin)?;
let _id = <Self as NFTs>::create(&who, details)?;
}
/// Update the details included in an NFT. Must be called by the owner of
/// the NFT and while the NFT is not sealed.
#[weight = T::WeightInfo::mutate()]
fn mutate(origin, id: T::NFTId, details: T::NFTDetails) {
let who = ensure_signed(origin)?;
<Self as NFTs>::mutate(id, |owner, dets| -> DispatchResult {
ensure!(owner == &who, Error::<T>::NotOwner);
*dets = details;
Ok(())
})?;
}
/// Transfer an NFT from an account to another one. Must be called by the
/// actual owner of the NFT.
#[weight = T::WeightInfo::transfer()]
fn transfer(origin, id: T::NFTId, to: <T::Lookup as StaticLookup>::Source) {
let who = ensure_signed(origin)?;
let to_unlookup = T::Lookup::lookup(to)?;
let mut data = Data::<T>::get(id);
ensure!(data.owner == who, Error::<T>::NotOwner);
ensure!(!data.locked, Error::<T>::Locked);
data.owner = to_unlookup.clone();
Data::<T>::insert(id, data);
Self::deposit_event(RawEvent::Transfer(id, who, to_unlookup));
}
/// Mark an NFT as sealed, thus disabling further details modifications (but
/// not preventing future transfers). Must be called by the owner of the NFT.
#[weight = T::WeightInfo::seal()]
fn seal(origin, id: T::NFTId) {
let who = ensure_signed(origin)?;
let mut data = Data::<T>::get(id);
ensure!(!data.sealed, Error::<T>::Sealed);
ensure!(data.owner == who, Error::<T>::NotOwner);
data.sealed = true;
Data::<T>::insert(id, data);
Self::deposit_event(RawEvent::Sealed(id));
}
}
}
impl<T: Trait> NFTs for Module<T> {
type AccountId = T::AccountId;
type NFTDetails = T::NFTDetails;
type NFTId = T::NFTId;
fn create(
owner: &Self::AccountId,
details: Self::NFTDetails,
) -> result::Result<Self::NFTId, DispatchError> {
let id = Total::<T>::get();
Total::<T>::put(id.checked_add(&1.into()).ok_or(Error::<T>::NFTIdOverflow)?);
Data::<T>::insert(
id,
NFTData {
owner: owner.clone(),
details,
sealed: false,
locked: false,
},
);
Self::deposit_event(RawEvent::Created(id, owner.clone()));
Ok(id)
}
fn mutate<F: FnOnce(&Self::AccountId, &mut Self::NFTDetails) -> DispatchResult>(
id: Self::NFTId,
f: F,
) -> DispatchResult {
let mut data = Data::<T>::get(id);
let mut details = data.details;
ensure!(!data.sealed, Error::<T>::Sealed);
f(&data.owner, &mut details)?;
data.details = details;
Data::<T>::insert(id, data);
Self::deposit_event(RawEvent::Mutated(id));
Ok(())
}
fn set_owner(id: Self::NFTId, owner: &Self::AccountId) -> DispatchResult {
Data::<T>::try_mutate(id, |data| -> DispatchResult {
ensure!(!data.locked, Error::<T>::Locked);
(*data).owner = owner.clone();
Ok(())
})?;
Ok(())
}
fn details(id: Self::NFTId) -> Self::NFTDetails {
Data::<T>::get(id).details
}
fn owner(id: Self::NFTId) -> Self::AccountId {
Data::<T>::get(id).owner
}
fn seal(id: Self::NFTId) -> DispatchResult {
Data::<T>::mutate(id, |d| (*d).sealed = true);
Self::deposit_event(RawEvent::Sealed(id));
Ok(())
}
fn sealed(id: Self::NFTId) -> bool {
Data::<T>::get(id).sealed
}
}
impl<T: Trait> LockableNFTs for Module<T> {
type AccountId = T::AccountId;
type NFTId = T::NFTId;
fn lock(id: Self::NFTId) -> DispatchResult {
Data::<T>::try_mutate(id, |d| -> DispatchResult {
ensure!(!d.locked, Error::<T>::Locked);
(*d).locked = true;
Ok(())
})
}
fn unlock(id: Self::NFTId) {
Data::<T>::mutate(id, |d| (*d).locked = false);
}
fn locked(id: Self::NFTId) -> bool {
Data::<T>::get(id).locked
}
}
|
use std::intrinsics::write_bytes;
use std::net::SocketAddr;
use std::slice::Iter;
use std::thread::sleep;
use std::time::Duration;
use bytes::{Buf, BufMut, Bytes, BytesMut};
use clap::{App, Arg, ArgMatches, SubCommand};
use futures::sink::SinkExt;
use futures::stream::{self, StreamExt};
use tokio::io::AsyncWriteExt;
use tokio::io::Error;
use tokio::net::UdpSocket;
use tokio::prelude::*;
use stun_rs::codec::error::CodecError;
use stun_rs::codec::{Decoder, Encoder};
use stun_rs::messages::{Address, Attribute, Message, MessageClass, MessageMethod, TransactionID};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let args = parse_arguments();
let host = args.value_of("host").unwrap();
let port: u16 = args.value_of("port").unwrap().parse().unwrap();
let socket = UdpSocket::bind(format!("{}:{}", host, port)).await.unwrap();
match args.subcommand() {
("client", Some(opts)) => start_udp_client(socket, opts.value_of("server").unwrap()).await,
("server", _) => start_udp_server(socket).await,
(cmd, _) => {
eprintln!("unsupported command: {}", cmd);
println!("{}", args.usage());
Ok(())
}
}
}
fn parse_arguments() -> ArgMatches<'static> {
App::new("stun-rs")
.version("0.1.0")
.arg(
Arg::with_name("port")
.short("p")
.long("port")
.value_name("PORT")
.help("PORT to bind to")
.default_value("8081")
.takes_value(true),
)
.arg(
Arg::with_name("host")
.short("h")
.long("host")
.value_name("HOST")
.help("HOST to bind to")
.default_value("0.0.0.0")
.takes_value(true),
)
.subcommand(
SubCommand::with_name("client")
.about("run STUN client")
.arg(
Arg::with_name("server")
.short("s")
.long("server")
.takes_value(true)
.required(true),
),
)
.subcommand(SubCommand::with_name("server").about("run STUN server"))
.get_matches()
}
async fn start_udp_client(
mut socket: UdpSocket,
server: &str,
) -> Result<(), Box<dyn std::error::Error>> {
let msg = Message {
message_class: MessageClass::Request,
message_method: MessageMethod::Binding,
transaction_id: TransactionID::from([1u8; 12]),
attributes: vec![Attribute::Software("stun-rs:0.1.0".to_owned())],
};
let stun_encoder = Encoder::new();
let stun_decoder = Decoder::new();
let mut bytes_mut = BytesMut::new();
let size = stun_encoder.encode(&msg, &mut bytes_mut);
let bytes_sent = socket.send_to(bytes_mut.bytes(), server).await.unwrap();
assert_eq!(bytes_sent, bytes_mut.len());
loop {
let mut buf = [0u8; 1024];
let (bytes_recv, address) = socket.recv_from(&mut buf).await.unwrap();
let mut bytes = Bytes::copy_from_slice(&buf);
let message = stun_decoder.decode(&mut bytes).unwrap();
println!("receive from {}, message: {:?}", address, message);
}
Ok(())
}
async fn start_udp_server(mut socket: UdpSocket) -> Result<(), Box<dyn std::error::Error>> {
let stun_encoder = Encoder::new();
let stun_decoder = Decoder::new();
let mut buf = [0u8; 1024];
loop {
let (bytes_recv, address) = socket.recv_from(&mut buf).await?;
let mut bytes = Bytes::copy_from_slice(&buf);
let message = stun_decoder.decode(&mut bytes)?;
match message_handler(message, address) {
Some(reply) => {
println!("sending message: {:?}", reply);
let mut buf = BytesMut::new();
Encoder::new().encode(&reply, &mut buf);
socket.send_to(&mut buf.bytes(), address).await?;
}
None => {}
}
}
Ok(())
}
fn message_handler(message: Message, socket_addr: SocketAddr) -> Option<Message> {
println!("receive message: {:?}", message);
match (message.message_class, message.message_method) {
(MessageClass::Request, MessageMethod::Binding) => {
let reply = Message {
message_class: MessageClass::SuccessResponse,
message_method: MessageMethod::Binding,
transaction_id: TransactionID::from([1u8; 12]),
attributes: vec![
Attribute::Software("stun-rs:0.1.0".to_owned()),
Attribute::XorMappedAddress(get_address(socket_addr)),
],
};
Some(reply)
}
_ => None,
}
}
fn get_address(socket_addr: SocketAddr) -> Address {
match socket_addr {
SocketAddr::V4(address) => Address::ipv4(address.ip().octets(), address.port()),
SocketAddr::V6(address) => Address::ipv6(address.ip().octets(), address.port()),
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.