text stringlengths 8 4.13M |
|---|
use std::{sync::atomic::AtomicU32, time::Duration};
use async_trait::async_trait;
use messagebus::{
derive::{Error as MbError, Message},
error,
receivers::BufferUnorderedConfig,
AsyncHandler, Bus, Message, Module,
};
use thiserror::Error;
#[derive(Debug, Error, MbError)]
enum Error {
#[error("Error({0})")]
Error(anyhow::Error),
#[error("MyError")]
MyError,
}
impl<M: Message> From<error::Error<M>> for Error {
fn from(err: error::Error<M>) -> Self {
Self::Error(err.into())
}
}
#[derive(Debug, Clone, Message)]
struct Req(pub u32);
#[derive(Debug, Clone, Message)]
struct Resp(pub u32);
#[derive(Debug, Clone, Message)]
struct GetCount;
#[derive(Debug, Clone, Message)]
struct CountResult(pub u32);
struct TmpReceiver {
counter: AtomicU32,
}
#[async_trait]
impl AsyncHandler<Req> for TmpReceiver {
type Error = Error;
type Response = ();
async fn handle(&self, msg: Req, bus: &Bus) -> Result<Self::Response, Self::Error> {
tokio::time::sleep(Duration::from_millis((msg.0 % 20) as _)).await;
if msg.0 % 128 == 0 {
return Err(Error::MyError);
} else {
bus.send(Resp(msg.0)).await?;
}
Ok(())
}
}
#[async_trait]
impl AsyncHandler<Resp> for TmpReceiver {
type Error = Error;
type Response = ();
async fn handle(&self, _msg: Resp, _bus: &Bus) -> Result<Self::Response, Self::Error> {
self.counter
.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
Ok(())
}
}
#[async_trait]
impl AsyncHandler<GetCount> for TmpReceiver {
type Error = Error;
type Response = CountResult;
async fn handle(&self, _: GetCount, _bus: &Bus) -> Result<Self::Response, Self::Error> {
Ok(CountResult(
self.counter.load(std::sync::atomic::Ordering::SeqCst),
))
}
}
fn module() -> Module {
Module::new()
.register(TmpReceiver {
counter: AtomicU32::new(0),
})
.subscribe_async::<Req>(
1024,
BufferUnorderedConfig {
buffer_size: 1024,
max_parallel: 1024,
},
)
.subscribe_async::<Resp>(1024, Default::default())
.subscribe_async::<GetCount>(8, Default::default())
.done()
}
#[tokio::test]
async fn test_sync() {
let (b, poller) = Bus::build().add_module(module()).build();
let cnt = 4u32;
for i in 0..cnt {
for j in 0..32768 {
b.send(Req(i * 128 + j)).await.unwrap();
}
println!("{} sent", i);
}
println!("sent");
b.flush_all().await;
println!("flushed");
assert_eq!(
b.request_we::<_, CountResult, Error>(GetCount, Default::default())
.await
.unwrap()
.0,
cnt * 32768 - cnt * 256
);
b.close().await;
println!("closed");
poller.await;
}
|
extern crate hal;
use crate::graphics;
use graphics::gfxal;
/// a vertex buffer, this is used to represent the mesh
pub struct VertexBuffer {
buffer: gfxal::Buffer,
}
impl VertexBuffer {
/// Create a new vertex buffer, data is the raw vertex data
#[profiled]
pub fn new<T>(data: &mut [T]) -> VertexBuffer {
VertexBuffer {
buffer: gfxal::Buffer::new(data, hal::buffer::Usage::VERTEX),
}
}
/// binds the vertex buffer, this makes it the selected mesh for the next drawcall(s)
#[profiled]
pub fn bind(&mut self) {
use hal::command::CommandBuffer;
let mut ctx = crate_get_graphics_context!();
let idx = ctx.frame_idx;
let cmd_buffer = &mut ctx.command_buffers[idx];
unsafe {
cmd_buffer.bind_vertex_buffers(0, std::iter::once((&*self.buffer.buffer, 0)));
}
}
}
|
use interactive_process::InteractiveProcess;
use std::{process::Command, thread::sleep, time::Duration};
fn main() {
let mut cmd = Command::new("examples/echo_stream.py");
let mut proc = InteractiveProcess::new(&mut cmd, |line| {
println!("Got: {}", line.unwrap());
})
.unwrap();
proc.send("data1").unwrap();
sleep(Duration::from_secs(1));
proc.send("data2").unwrap();
sleep(Duration::from_secs(1));
proc.send("data3").unwrap();
// If we don't sleep here, the process won't have time to reply
// before we kill it.
sleep(Duration::from_millis(1));
proc.close().kill().unwrap();
}
|
use web_sys::WebGl2RenderingContext;
pub trait Drawwable {
// TODO(Angus): replace with api
fn draw(&self, context: &WebGl2RenderingContext) -> Result<(), DrawError>;
}
pub enum DrawError {
}
|
extern crate libc;
use std::fmt;
use std::ffi::CString;
use std::os::raw::c_char;
use super::tqapi_ffi::*;
// TradeApi
pub struct AccountInfo {
pub account_id : String, // ๅธๅท็ผๅท
pub broker : String, // ไบคๆๅๅ็งฐ๏ผๅฆๆๅ่ฏๅธ
pub account : String, // ไบคๆๅธๅท
pub status : String, // ่ฟๆฅ็ถๆ๏ผๅๅผ Disconnected, Connected, Connecting
pub msg : String, // ็ถๆไฟกๆฏ๏ผๅฆ็ปๅฝๅคฑ่ดฅๅๅ
pub account_type : String, // ๅธๅท็ฑปๅ๏ผๅฆ stock, ctp
}
impl fmt::Display for AccountInfo {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "AccountInfo({},{},{},{},{})", self.account_id, self.broker, self.account, self.status, self.msg)
}
}
pub struct Balance {
pub account_id : String,
pub fund_account : String,
pub init_balance : f64,
pub enable_balance : f64,
pub margin : f64,
pub float_pnl : f64,
pub close_pnl : f64,
}
#[derive(Debug,Clone,PartialEq, Eq)]
pub enum OrderStatus {
New,
Accepted,
Filled,
Rejected,
Cancelled,
// Other(String)
}
impl OrderStatus {
pub fn from ( s : &str) -> OrderStatus {
match s {
"New" => OrderStatus::New,
"Accepted" => OrderStatus::Accepted,
"Filled" => OrderStatus::Filled,
"Rejected" => OrderStatus::Rejected,
"Cancelled" => OrderStatus::Cancelled,
_ => panic!("unknown order status: {}", s)//OrderStatus::Other(String::from(s))
}
}
pub fn to_str(&self) -> &str {
match self {
OrderStatus::New => "New",
OrderStatus::Accepted => "Accepted",
OrderStatus::Filled => "Filled",
OrderStatus::Rejected => "Rejected",
OrderStatus::Cancelled => "Cancelled",
//OrderStatus::Other(s) => s
}
}
pub fn is_finished(&self) -> bool {
match self {
OrderStatus::Filled => true,
OrderStatus::Rejected => true,
OrderStatus::Cancelled => true,
_ => false
}
}
}
impl fmt::Display for OrderStatus {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.to_str())
}
}
#[derive(Debug,Clone, PartialEq)]
pub enum EntrustAction {
Buy,
Short,
Cover,
Sell,
CoverToday,
CoverYesterday,
SellToday,
SellYesterday,
// Other(String)
}
impl EntrustAction {
pub fn from( s : &str) -> EntrustAction {
match s {
"Buy" => EntrustAction::Buy,
"Short" => EntrustAction::Short,
"Cover" => EntrustAction::Cover,
"Sell" => EntrustAction::Sell,
"CoverToday" => EntrustAction::CoverToday,
"CoverYesterday"=> EntrustAction::CoverYesterday,
"SellToday" => EntrustAction::SellToday,
"SellYesterday" => EntrustAction::SellYesterday,
_ => panic!("unkown action"), //EntrustAction::Other(String::from(s))
}
}
pub fn to_str(&self) -> &str {
match self {
EntrustAction::Buy => "Buy" ,
EntrustAction::Short => "Short" ,
EntrustAction::Cover => "Cover" ,
EntrustAction::Sell => "Sell" ,
EntrustAction::CoverToday => "CoverToday" ,
EntrustAction::CoverYesterday => "CoverYesterday",
EntrustAction::SellToday => "SellToday" ,
EntrustAction::SellYesterday => "SellYesterday" ,
//EntrustAction::Other(s) => s,
}
}
pub fn is_long(&self) -> bool {
match self {
EntrustAction::Buy => true,
EntrustAction::Short => false,
EntrustAction::Cover => true,
EntrustAction::Sell => false,
EntrustAction::CoverToday => true,
EntrustAction::CoverYesterday => true,
EntrustAction::SellToday => false,
EntrustAction::SellYesterday => false,
//EntrustAction::Other(s) => false,
}
}
// 1.0 -> get money
// -1.0 -> pay
pub fn money_flow(&self) -> f64 {
if self.is_long() { -1.0 } else { 1.0 }
}
}
impl fmt::Display for EntrustAction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.to_str())
}
}
#[derive(Clone,Debug)]
pub struct Order {
pub account_id : String, // ๅธๅท็ผๅท
pub code : String, // ่ฏๅธไปฃ็
pub name : String, // ่ฏๅธๅ็งฐ
pub entrust_no : String, // ๅงๆ็ผๅท
pub entrust_action : EntrustAction, // ๅงๆๅจไฝ
pub entrust_price : f64, // ๅงๆไปทๆ ผ
pub entrust_size : i64, // ๅงๆๆฐ้๏ผๅไฝ๏ผ่ก
pub entrust_date : u32, // ๅงๆๆฅๆ
pub entrust_time : u32, // ๅงๆๆถ้ด
pub fill_price : f64, // ๆไบคไปทๆ ผ
pub fill_size : i64, // ๆไบคๆฐ้
pub status : OrderStatus, // ่ฎขๅ็ถๆ๏ผๅๅผ: OrderStatus
pub status_msg : String, // ็ถๆๆถๆฏ
pub order_id : i32 // ่ชๅฎไน่ฎขๅ็ผๅท
}
impl fmt::Display for Order {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Order({},{},{},{},{},{},{},{},{},{})", self.account_id, self.code,
self.entrust_action.to_str(), self.entrust_price, self.entrust_size,
self.entrust_date, self.entrust_time, self.entrust_no, self.status.to_str(), self.order_id)
}
}
#[derive(Debug)]
pub struct Trade {
pub account_id : String, // ๅธๅท็ผๅท
pub code : String, // ่ฏๅธไปฃ็
pub name : String, // ่ฏๅธๅ็งฐ
pub entrust_no : String, // ๅงๆ็ผๅท
pub entrust_action : EntrustAction, // ๅงๆๅจไฝ
pub fill_no : String, // ๆไบค็ผๅท
pub fill_size : i64, // ๆไบคๆฐ้
pub fill_price : f64, // ๆไบคไปทๆ ผ
pub fill_date : u32, // ๆไบคๆฅๆ
pub fill_time : u32, // ๆไบคๆถ้ด
pub order_id : i32, // ่ชๅฎไน่ฎขๅ็ผๅท
}
impl fmt::Display for Trade {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Trade({},{},{},{},{},{},{},{},{})", self.account_id, self.code,
self.entrust_action.to_str(), self.fill_price, self.fill_size, self.fill_time,
self.fill_no, self.entrust_no, self.order_id)
}
}
#[derive(Debug)]
pub enum Side {
Long,
Short,
// Other(String)
}
impl Side {
pub fn from( s : &str) -> Side {
match s {
"Long" => Side::Long,
"Short" => Side::Short,
_ => Side::Long,
// _ => Side::Other(String::from(s))
}
}
}
pub struct Position {
pub account_id : String, // ๅธๅท็ผๅท
pub code : String, // ่ฏๅธไปฃ็
pub name : String, // ่ฏๅธๅ็งฐ
pub current_size : i64, // ๅฝๅๆไป
pub enable_size : i64, // ๅฏ็จ๏ผๅฏไบคๆ๏ผๆไป
pub init_size : i64, // ๅๅงๆไป
pub today_size : i64, // ไปๆฅๆไป
pub frozen_size : i64, // ๅป็ปๆไป
pub side : Side, // ๆไปๆนๅ๏ผ่ก็ฅจ็ๆไปๆนๅไธบ Long, ๆ่ดงๅ Long, Short
pub cost : f64, // ๆๆฌ
pub cost_price : f64, // ๆๆฌไปทๆ ผ
pub last_price : f64, // ๆๆฐไปทๆ ผ
pub float_pnl : f64, // ๆไป็ไบ
pub close_pnl : f64, // ๅนณไป็ไบ
pub margin : f64, // ไฟ่ฏ้
pub commission : f64, // ๆ็ปญ่ดน
}
pub struct OrderID {
pub entrust_no : String, // ่ฎขๅๅงๆๅท
pub order_id : i32 // ่ชๅฎไน็ผๅท
}
pub struct NewOrder {
pub action : EntrustAction,
pub code : String,
pub size : i64,
pub price : f64,
pub order_type : String,
pub order_id : i32
}
pub trait TradeApiCallback {
fn on_order (&mut self, order : Order);
fn on_trade (&mut self, trade : Trade);
fn on_account_status (&mut self, account : AccountInfo);
}
struct NullTradeApiCallback;
impl TradeApiCallback for NullTradeApiCallback {
fn on_order (&mut self, _order : Order) {}
fn on_trade (&mut self, _trade : Trade) {}
fn on_account_status (&mut self, _account : AccountInfo) {}
}
struct TradeApiHook {
cb : *mut dyn TradeApiCallback,
}
pub struct TradeApi{
null_cb : *mut dyn TradeApiCallback,
hook : *mut TradeApiHook,
tapi : *mut CTradeApi,
is_owner : bool
}
impl Drop for TradeApi {
fn drop(&mut self) {
unsafe {
let old_cb = tqapi_tapi_set_callback(self.tapi, core::ptr::null_mut());
if !old_cb.is_null() {
Box::from_raw(old_cb);
}
Box::from_raw(self.hook);
Box::from_raw(self.null_cb);
if self.is_owner {
tqapi_free_trade_api(self.tapi);
}
}
}
}
impl TradeApi {
pub fn new(addr: &str) -> TradeApi {
let c_addr = CString::new(addr).unwrap();
unsafe {
let tapi = tqapi_create_trade_api(c_addr.as_ptr() as *const c_char);
let null_cb = Box::into_raw(Box::new(NullTradeApiCallback{}));
let hook = Box::into_raw(Box::new(TradeApiHook{ cb : null_cb}));
TradeApi{ null_cb : null_cb, hook : hook, tapi : tapi, is_owner: true}
}
}
pub fn from(tapi : *mut CTradeApi) -> TradeApi {
let null_cb = Box::into_raw(Box::new(NullTradeApiCallback{}));
let hook = Box::into_raw(Box::new(TradeApiHook{ cb : null_cb}));
TradeApi{ null_cb : null_cb, hook : hook, tapi : tapi, is_owner: false}
}
pub fn query_accounts(&mut self) -> Result<Vec<AccountInfo>, String> {
let result;
unsafe {
let r = tqapi_tapi_query_accounts(self.tapi);
if !(*r).array.is_null() {
let mut v = Vec::new();
for i in 0..(*r).array_size {
v.push( (*(*r).array.offset(i as isize)).to_rs());
}
result = Ok(v);
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_query_accounts_result(self.tapi, r);
}
return result;
}
pub fn query_balance(&mut self, account_id : &str) -> Result<Balance, String> {
let c_account = CString::new(account_id).unwrap();
let result;
unsafe {
let r = tqapi_tapi_query_balance(self.tapi, c_account.as_ptr());
if !(*r).balance.is_null() {
result = Ok( (*(*r).balance).to_rs());
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_query_balance_result(self.tapi, r);
}
return result;
}
pub fn query_orders(&mut self, account_id : &str, codes : &str) -> Result<Vec<Order>, String> {
let c_account = CString::new(account_id).unwrap();
let c_codes = CString::new(codes).unwrap();
let result;
unsafe {
let r = tqapi_tapi_query_orders(self.tapi, c_account.as_ptr(), c_codes.as_ptr());
//println!("query_orders result {:?}", *r);
if !(*r).array.is_null() {
let mut v = Vec::with_capacity((*r).array_size as usize);
for i in 0..(*r).array_size {
v.push( (*(*r).array.offset(i as isize)).to_rs());
}
result = Ok(v);
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_query_orders_result(self.tapi, r);
}
return result
}
pub fn query_trades(&mut self, account_id : &str, codes : &str) -> Result<Vec<Trade>, String> {
let c_account = CString::new(account_id).unwrap();
let c_codes = CString::new(codes).unwrap();
let result;
unsafe {
let r = tqapi_tapi_query_trades(self.tapi, c_account.as_ptr(), c_codes.as_ptr());
if !(*r).array.is_null() {
let mut v = Vec::with_capacity((*r).array_size as usize);
for i in 0..(*r).array_size {
v.push( (*(*r).array.offset(i as isize)).to_rs());
}
result = Ok(v);
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_query_trades_result(self.tapi, r);
}
return result
}
pub fn query_positions(&mut self, account_id : &str, codes : &str) -> Result<Vec<Position>, String> {
let c_account = CString::new(account_id).unwrap();
let c_codes = CString::new(codes).unwrap();
let result;
unsafe {
let r = tqapi_tapi_query_positions(self.tapi, c_account.as_ptr(), c_codes.as_ptr());
if !(*r).array.is_null() {
let mut v = Vec::new();
for i in 0..(*r).array_size {
v.push( (*(*r).array.offset(i as isize)).to_rs());
}
result = Ok(v);
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_query_positions_result(self.tapi, r);
}
return result
}
pub fn place_order(&mut self, account_id : &str, order: &NewOrder) -> Result<OrderID, String> {
let c_account = CString::new(account_id).unwrap();
let c_code = CString::new(order.code.as_str()).unwrap();
let c_action = CString::new(order.action.to_str()).unwrap();
let c_price_type = CString::new(order.order_type.as_str()).unwrap();
let c_order = CNewOrder {
action : c_action.as_ptr(),
code : c_code.as_ptr(),
size : order.size,
price : order.price,
order_type : c_price_type.as_ptr(),
order_id : order.order_id
};
let result;
unsafe {
let raw_c_order = Box::into_raw( Box::new(c_order));
let r = tqapi_tapi_place_order(self.tapi, c_account.as_ptr(), raw_c_order);
if !(*r).order_id.is_null() {
result = Ok(OrderID{
entrust_no : c_str_to_string((*(*r).order_id).entrust_no),
order_id : (*(*r).order_id).order_id});
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_place_order_result(self.tapi, r);
}
return result
}
pub fn cancel_order(&mut self, account_id: &str, code : &str, entrust_no: &str, order_id: i32) -> Result<bool, String> {
let c_account = CString::new(account_id).unwrap();
let c_code = CString::new(code).unwrap();
let c_entrust_no = CString::new(entrust_no).unwrap();
let c_oid = COrderId {
entrust_no : c_entrust_no.as_ptr(),
order_id : order_id
};
let result;
unsafe {
let raw_c_oid = Box::into_raw( Box::new(c_oid));
let r = tqapi_tapi_cancel_order(self.tapi, c_account.as_ptr(), c_code.as_ptr(), raw_c_oid);
if (*r).success == 1 {
result = Ok(true)
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_cancel_order_result(self.tapi, r);
}
return result
}
pub fn query(&mut self, account_id : &str, command : &str, params: &str) -> Result<String, String> {
let c_account = CString::new(account_id).unwrap();
let c_command = CString::new(command).unwrap();
let c_params = CString::new(params).unwrap();
let result;
unsafe {
let r = tqapi_tapi_query(self.tapi, c_account.as_ptr(), c_command.as_ptr(), c_params.as_ptr());
if !(*r).text.is_null() {
result = Ok(c_str_to_string((*r).text));
} else {
result = Err(c_str_to_string( (*r).msg) );
}
tqapi_tapi_free_query_result(self.tapi, r);
}
return result
}
extern "C" fn on_order(obj : *mut libc::c_void, c_order: *mut COrder) {
unsafe {
assert!(!c_order.is_null() && !obj.is_null());
let order = (*c_order).to_rs();
let cb = (*(obj as *mut TradeApiHook)).cb as *mut dyn TradeApiCallback;
(*cb).on_order(order);
}
}
extern "C" fn on_trade(obj : *mut libc::c_void, c_trade: *mut CTrade) {
unsafe {
assert!(!c_trade.is_null() && !obj.is_null());
let trade = (*c_trade).to_rs();
let cb = (*(obj as *mut TradeApiHook)).cb as *mut dyn TradeApiCallback;
(*cb).on_trade (trade);
}
}
extern "C" fn on_account_status(obj : *mut libc::c_void, account: *mut CAccountInfo) {
unsafe {
assert!(!account.is_null() && !obj.is_null());
let account = (*account).to_rs();
let cb = (*(obj as *mut TradeApiHook)).cb as *mut dyn TradeApiCallback;
(*cb).on_account_status(account);
}
}
pub fn set_callback(&mut self, cb : Option<Box<dyn TradeApiCallback>>) {
if !self.is_owner { return;}
unsafe {
let old_cb = tqapi_tapi_set_callback(self.tapi, core::ptr::null_mut());
if !old_cb.is_null() {
Box::from_raw((*old_cb).obj);
Box::from_raw(old_cb);
}
if let Some(callback) = cb {
(*self.hook).cb = Box::into_raw(callback);
let raw_cb = Box::into_raw(
Box::new(CTradeApiCallback {
obj : self.hook as *mut libc::c_void,
on_account_status : TradeApi::on_account_status,
on_order : TradeApi::on_order,
on_trade : TradeApi::on_trade,
}));
let old_cb = tqapi_tapi_set_callback(self.tapi, raw_cb);
if !old_cb.is_null() {
Box::from_raw( (*old_cb).obj);
Box::from_raw(old_cb);
}
}
}
}
}
|
use std::fs::File;
use std::io::{BufReader, prelude::*};
fn main() {
// creates a File object that requires a path argument
// at present this program will crash if "README.md" does not exist
let f = File::open("README.md").unwrap();
/*
// reader == new BufReader struct created using 'f' as the source
let mut reader = BufReader::new(f);
// reuses the 'line' String object over the lifetime of the program - String object is mutable
let mut line = String::new();
loop
{
// reading from disk can fail so the error needs to be handled, lazily in this case with unwrap()
let len = reader.read_line(&mut line).unwrap();
if len == 0
{
break
}
println!("{} ({} bytes long)", line, len);
// shrinks the String back to length 0 - preventing lines from persisting into following lines
line.truncate(0);
}*/
/*
manually looping through a file is unwieldy and
Rust provides an iterator to iterate through lines with BufReader::lines().
BufReader::lines() also removes the trailing newline character from each line
*/
// clears the compiler warning as reader no longer needs to be mutable
let reader = BufReader::new(f);
for line_ in reader.lines()
{
// unwraps the Result but at the risk of crashing the program if an error occurs
let line = line_.unwrap();
println!("{} ({} bytes long)", line, line.len());
}
}
|
use std::collections::HashMap;
use std::fs::File;
use std::io::{self, BufRead};
use std::path::{Path, PathBuf};
use anyhow::Result;
// The output is wrapped in a Result to allow matching on errors
// Returns an Iterator to the Reader of the lines of the file.
fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
where
P: AsRef<Path>,
{
let file = File::open(filename)?;
Ok(io::BufReader::new(file).lines())
}
#[inline]
fn strip_trailing_slash(x: &str) -> String {
if x.ends_with('/') {
let mut x: String = x.into();
x.pop();
x
} else {
x.into()
}
}
pub fn run(meta_path: PathBuf) -> Result<()> {
let mut lines = read_lines(meta_path)?;
// line 1:/doc/tags,/doc/tags-cn
// line 2:&runtimepath
if let Some(Ok(doc_tags)) = lines.next() {
if let Some(Ok(runtimepath)) = lines.next() {
for dt in doc_tags.split(',') {
let tags_files = runtimepath
.split(',')
.map(|x| format!("{}{}", strip_trailing_slash(x), dt));
let mut seen = HashMap::new();
let mut v: Vec<String> = Vec::new();
for tags_file in tags_files {
if let Ok(lines) = read_lines(tags_file) {
lines.for_each(|line| {
if let Ok(helptag) = line {
v = helptag.split('\t').map(Into::into).collect();
if !seen.contains_key(&v[0]) {
seen.insert(v[0].clone(), format!("{:<60}\t{}", v[0], v[1]));
}
}
});
}
}
let mut tag_lines = seen.values().collect::<Vec<_>>();
tag_lines.sort();
for line in tag_lines {
println!("{}", line);
}
}
}
}
Ok(())
}
|
use std::collections::HashMap;
use std::env;
use std::fs;
fn main()
{
let args : Vec<String> = env::args().collect();
if args.len() < 2 {
return;
}
let mut valid_rooms = 0;
for line in fs::read_to_string(&args[1]).unwrap().split('\n') {
let mut room_valid : bool = true;
let mut map = HashMap::new();
let mut match_phase : bool = false;
let mut sector_id : i32 = 0;
for letter in line.chars() {
match letter {
'0'..='9' => {
sector_id = sector_id * 10 + letter.to_digit(10).unwrap() as i32;
}
'-' => {},
'[' => {
if map.keys().count() < 5 {
room_valid = false;
break;
}
match_phase = true;
},
']' => {},
_ => {
if !match_phase {
if !map.contains_key(&letter) {
map.insert(letter, 0);
}
*map.get_mut(&letter).unwrap() += 1;
} else {
let maxcount = map.values().max().unwrap();
let mut top = map.keys()
.filter(|x| map[x] == *maxcount)
.collect::<Vec<&char>>();
top.sort();
let l = top[0].clone();
map.remove(&l);
if letter != l {
room_valid = false;
break;
}
}
}
}
}
if room_valid {
valid_rooms += sector_id;
}
}
println!("{}", valid_rooms);
}
|
#[doc = "Register `ACR` reader"]
pub type R = crate::R<ACR_SPEC>;
#[doc = "Register `ACR` writer"]
pub type W = crate::W<ACR_SPEC>;
#[doc = "Field `HLFCYA` reader - Flash half cycle access enable"]
pub type HLFCYA_R = crate::BitReader;
#[doc = "Field `HLFCYA` writer - Flash half cycle access enable"]
pub type HLFCYA_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bit 3 - Flash half cycle access enable"]
#[inline(always)]
pub fn hlfcya(&self) -> HLFCYA_R {
HLFCYA_R::new(((self.bits >> 3) & 1) != 0)
}
}
impl W {
#[doc = "Bit 3 - Flash half cycle access enable"]
#[inline(always)]
#[must_use]
pub fn hlfcya(&mut self) -> HLFCYA_W<ACR_SPEC, 3> {
HLFCYA_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 = "Flash access control register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`acr::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 [`acr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct ACR_SPEC;
impl crate::RegisterSpec for ACR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`acr::R`](R) reader structure"]
impl crate::Readable for ACR_SPEC {}
#[doc = "`write(|w| ..)` method takes [`acr::W`](W) writer structure"]
impl crate::Writable for ACR_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets ACR to value 0"]
impl crate::Resettable for ACR_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use crate::lib::environment::Environment;
use crate::lib::error::DfxResult;
use crate::lib::identity::Identity;
use crate::lib::provider::create_agent_environment;
use crate::lib::root_key::fetch_root_key_if_needed;
use crate::lib::waiter::waiter_with_timeout;
use crate::util::expiry_duration;
use candid::de::ArgumentDecoder;
use candid::CandidType;
use clap::Clap;
use ic_utils::call::SyncCall;
use tokio::runtime::Runtime;
mod add_controller;
mod authorize;
mod balance;
mod controllers;
mod custodians;
mod deauthorize;
mod list_addresses;
mod name;
mod remove_controller;
mod send;
mod set_name;
mod upgrade;
/// Helper commands to manage the user's cycles wallet.
#[derive(Clap)]
#[clap(name("wallet"))]
pub struct WalletOpts {
/// Override the compute network to connect to. By default, the local network is used.
/// A valid URL (starting with `http:` or `https:`) can be used here, and a special
/// ephemeral network will be created specifically for this request. E.g.
/// "http://localhost:12345/" is a valid network name.
#[clap(long)]
network: Option<String>,
#[clap(subcommand)]
subcmd: SubCommand,
}
#[derive(Clap)]
enum SubCommand {
Addresses(list_addresses::AddressesOpts),
AddController(add_controller::AddControllerOpts),
Authorize(authorize::AuthorizeOpts),
Balance(balance::WalletBalanceOpts),
Controllers(controllers::ControllersOpts),
Custodians(custodians::CustodiansOpts),
Deauthorize(deauthorize::DeauthorizeOpts),
Name(name::NameOpts),
RemoveController(remove_controller::RemoveControllerOpts),
Send(send::SendOpts),
SetName(set_name::SetNameOpts),
Upgrade(upgrade::UpgradeOpts),
}
pub fn exec(env: &dyn Environment, opts: WalletOpts) -> DfxResult {
let agent_env = create_agent_environment(env, opts.network.clone())?;
let runtime = Runtime::new().expect("Unable to create a runtime");
runtime.block_on(async {
match opts.subcmd {
SubCommand::Addresses(v) => list_addresses::exec(&agent_env, v).await,
SubCommand::AddController(v) => add_controller::exec(&agent_env, v).await,
SubCommand::Authorize(v) => authorize::exec(&agent_env, v).await,
SubCommand::Balance(v) => balance::exec(&agent_env, v).await,
SubCommand::Controllers(v) => controllers::exec(&agent_env, v).await,
SubCommand::Custodians(v) => custodians::exec(&agent_env, v).await,
SubCommand::Deauthorize(v) => deauthorize::exec(&agent_env, v).await,
SubCommand::Name(v) => name::exec(&agent_env, v).await,
SubCommand::RemoveController(v) => remove_controller::exec(&agent_env, v).await,
SubCommand::Send(v) => send::exec(&agent_env, v).await,
SubCommand::SetName(v) => set_name::exec(&agent_env, v).await,
SubCommand::Upgrade(v) => upgrade::exec(&agent_env, v).await,
}
})
}
async fn wallet_query<A, O>(env: &dyn Environment, method: &str, arg: A) -> DfxResult<O>
where
A: CandidType + Sync + Send,
O: for<'de> ArgumentDecoder<'de> + Sync + Send,
{
let identity_name = env
.get_selected_identity()
.expect("No selected identity.")
.to_string();
// Network descriptor will always be set.
let network = env.get_network_descriptor().unwrap();
let wallet =
Identity::get_or_create_wallet_canister(env, network, &identity_name, false).await?;
let out: O = wallet.query_(method).with_arg(arg).build().call().await?;
Ok(out)
}
async fn wallet_update<A, O>(env: &dyn Environment, method: &str, arg: A) -> DfxResult<O>
where
A: CandidType + Sync + Send,
O: for<'de> ArgumentDecoder<'de> + Sync + Send,
{
let identity_name = env
.get_selected_identity()
.expect("No selected identity.")
.to_string();
// Network descriptor will always be set.
let network = env.get_network_descriptor().unwrap();
let wallet =
Identity::get_or_create_wallet_canister(env, network, &identity_name, false).await?;
fetch_root_key_if_needed(env).await?;
let out: O = wallet
.update_(method)
.with_arg(arg)
.build()
.call_and_wait(waiter_with_timeout(expiry_duration()))
.await?;
Ok(out)
}
|
// std imports {{{
use std::fs;
use std::io::ErrorKind::NotFound;
use std::path::PathBuf;
// }}}
// 3rd party imports {{{
use serde_derive::{
Deserialize,
Serialize,
};
use url::Url;
// }}}
// Own imports {{{
use crate::error::Error;
// }}}
/// Binary name.
const BINARY_NAME: &str = env!("CARGO_PKG_NAME");
/// The default URL used for the AUR.
const AUR_URL: &str = "https://aur.archlinux.org/";
/// Pacman repository.
#[derive(Debug)]
pub struct Repository {
/// Name
pub name: String,
/// Servers
pub servers: Vec<String>,
}
impl Repository {
fn new(repository: &str) -> Self {
Self {
name: repository.to_string(),
servers: vec![
format!("https://archlinux.mailtunnel.eu/{}/os/x86_64", repository),
],
}
}
}
/// Configuration for mug.
#[derive(Debug)]
#[derive(Deserialize, Serialize)]
#[serde(default)]
pub struct Config {
pub aur_url: Url,
pub build_dir: PathBuf,
#[serde(skip)]
pub repos: Vec<Repository>,
}
impl Default for Config {
fn default() -> Self {
let aur_url = Url::parse(AUR_URL).expect("Failed to parse URL");
let cache_dir = dirs::cache_dir().expect("Failed to get cache directory");
let build_dir = cache_dir.join(BINARY_NAME);
Config {
aur_url,
build_dir,
repos: vec![
Repository::new("community"),
Repository::new("core"),
Repository::new("extra"),
Repository::new("multilib"),
],
}
}
}
impl Config {
pub fn load() -> Result<Self, Error> {
let config_dir = match dirs::config_dir() {
Some(d) => d,
None => return Err(Error::Config("Failed to get config directory".to_string())),
};
let config_dir = config_dir.join(BINARY_NAME);
let config_file = config_dir.join("config.toml");
let config = match fs::read_to_string(&config_file) {
Ok(c) => {
toml::from_str(&c).expect("Failed to parse toml in configuration file")
}
Err(ref e) if e.kind() == NotFound => {
let config = Config::default();
let toml = toml::to_string_pretty(&config).expect("Failed to convert config to toml");
fs::create_dir_all(config_dir).expect("Failed to create config directory");
fs::write(&config_file, toml).expect("Failed to write config file");
config
}
Err(_) => {
return Err(Error::Config("Failed to load configuration file".to_string()))
}
};
// Create build directory if it doesn't exist.
if !config.build_dir.is_dir() {
fs::create_dir_all(&config.build_dir).expect("Failed to create build directory");
}
Ok(config)
}
}
|
use silkenweb::{
elements::{div, hr, Div},
memo::{MemoCache, MemoFrame},
mount,
signal::Signal,
Builder,
};
use silkenweb_tutorial_common::define_counter;
// ANCHOR: main
fn main() {
let count = Signal::new(0);
mount(
"app",
div()
.text("How many counters would you like?")
.child(define_counter(&count))
.child(hr())
.child(count.read().map({
// ANCHOR: create_cache
let counter_elem_cache = MemoCache::new();
// ANCHOR_END: create_cache
move |&count| {
// ANCHOR: create_frame
let counter_elems = counter_elem_cache.frame();
// ANCHOR_END: create_frame
define_counter_list(&counter_elems, count)
}
})),
);
}
// ANCHOR_END: main
// ANCHOR: define_counter_list
fn define_counter_list(counter_elems: &MemoFrame, count: i64) -> Div {
let mut counters = div();
for i in 0..count {
// ANCHOR: get_cached_counter
let child = counter_elems.cache(i, || define_counter(&Signal::new(0)).build());
// ANCHOR_END: get_cached_counter
counters = counters.child(child);
}
counters.build()
}
// ANCHOR_END: define_counter_list
|
use {Errno, Result, NixPath};
use std::os::unix::io::AsRawFd;
pub mod vfs {
#[cfg(target_pointer_width = "32")]
pub mod hwdep {
use libc::{c_uint};
pub type FsType = c_uint;
pub type BlockSize = c_uint;
pub type NameLen = c_uint;
pub type FragmentSize = c_uint;
pub type SwordType = c_uint;
}
#[cfg(target_pointer_width = "64")]
pub mod hwdep {
use libc::{c_long};
pub type FsType = c_long;
pub type BlockSize = c_long;
pub type NameLen = c_long;
pub type FragmentSize = c_long;
pub type SwordType = c_long;
}
use sys::statfs::vfs::hwdep::*;
#[repr(C)]
#[derive(Debug,Copy,Clone)]
pub struct Statfs {
pub f_type: FsType,
pub f_bsize: BlockSize,
pub f_blocks: u64,
pub f_bfree: u64,
pub f_bavail: u64,
pub f_files: u64,
pub f_ffree: u64,
pub f_fsid: u64,
pub f_namelen: NameLen,
pub f_frsize: FragmentSize,
pub f_spare: [SwordType; 5],
}
pub const ADFS_SUPER_MAGIC : FsType = 0xadf5;
pub const AFFS_SUPER_MAGIC : FsType = 0xADFF;
pub const BEFS_SUPER_MAGIC : FsType = 0x42465331;
pub const BFS_MAGIC : FsType = 0x1BADFACE;
pub const CIFS_MAGIC_NUMBER : FsType = 0xFF534D42;
pub const CODA_SUPER_MAGIC : FsType = 0x73757245;
pub const COH_SUPER_MAGIC : FsType = 0x012FF7B7;
pub const CRAMFS_MAGIC : FsType = 0x28cd3d45;
pub const DEVFS_SUPER_MAGIC : FsType = 0x1373;
pub const EFS_SUPER_MAGIC : FsType = 0x00414A53;
pub const EXT_SUPER_MAGIC : FsType = 0x137D;
pub const EXT2_OLD_SUPER_MAGIC : FsType = 0xEF51;
pub const EXT2_SUPER_MAGIC : FsType = 0xEF53;
pub const EXT3_SUPER_MAGIC : FsType = 0xEF53;
pub const EXT4_SUPER_MAGIC : FsType = 0xEF53;
pub const HFS_SUPER_MAGIC : FsType = 0x4244;
pub const HPFS_SUPER_MAGIC : FsType = 0xF995E849;
pub const HUGETLBFS_MAGIC : FsType = 0x958458f6;
pub const ISOFS_SUPER_MAGIC : FsType = 0x9660;
pub const JFFS2_SUPER_MAGIC : FsType = 0x72b6;
pub const JFS_SUPER_MAGIC : FsType = 0x3153464a;
pub const MINIX_SUPER_MAGIC : FsType = 0x137F; /* orig. minix */
pub const MINIX_SUPER_MAGIC2 : FsType = 0x138F; /* 30 char minix */
pub const MINIX2_SUPER_MAGIC : FsType = 0x2468; /* minix V2 */
pub const MINIX2_SUPER_MAGIC2 : FsType = 0x2478; /* minix V2, 30 char names */
pub const MSDOS_SUPER_MAGIC : FsType = 0x4d44;
pub const NCP_SUPER_MAGIC : FsType = 0x564c;
pub const NFS_SUPER_MAGIC : FsType = 0x6969;
pub const NTFS_SB_MAGIC : FsType = 0x5346544e;
pub const OPENPROM_SUPER_MAGIC : FsType = 0x9fa1;
pub const PROC_SUPER_MAGIC : FsType = 0x9fa0;
pub const QNX4_SUPER_MAGIC : FsType = 0x002f;
pub const REISERFS_SUPER_MAGIC : FsType = 0x52654973;
pub const ROMFS_MAGIC : FsType = 0x7275;
pub const SMB_SUPER_MAGIC : FsType = 0x517B;
pub const SYSV2_SUPER_MAGIC : FsType = 0x012FF7B6;
pub const SYSV4_SUPER_MAGIC : FsType = 0x012FF7B5;
pub const TMPFS_MAGIC : FsType = 0x01021994;
pub const UDF_SUPER_MAGIC : FsType = 0x15013346;
pub const UFS_MAGIC : FsType = 0x00011954;
pub const USBDEVICE_SUPER_MAGIC : FsType = 0x9fa2;
pub const VXFS_SUPER_MAGIC : FsType = 0xa501FCF5;
pub const XENIX_SUPER_MAGIC : FsType = 0x012FF7B4;
pub const XFS_SUPER_MAGIC : FsType = 0x58465342;
pub const _XIAFS_SUPER_MAGIC : FsType = 0x012FD16D;
}
mod ffi {
use libc::{c_int,c_char};
use sys::statfs::vfs;
extern {
pub fn statfs(path: * const c_char, buf: *mut vfs::Statfs) -> c_int;
pub fn fstatfs(fd: c_int, buf: *mut vfs::Statfs) -> c_int;
}
}
pub fn statfs<P: ?Sized + NixPath>(path: &P, stat: &mut vfs::Statfs) -> Result<()> {
unsafe {
Errno::clear();
let res = try!(
path.with_nix_path(|path| ffi::statfs(path.as_ptr(), stat))
);
Errno::result(res).map(drop)
}
}
pub fn fstatfs<T: AsRawFd>(fd: &T, stat: &mut vfs::Statfs) -> Result<()> {
unsafe {
Errno::clear();
Errno::result(ffi::fstatfs(fd.as_raw_fd(), stat)).map(drop)
}
}
|
use crate::console;
use crate::preloader::WORKDIR;
use colored::Colorize;
use execute::Execute;
use std::process::{self, Command};
pub fn compile_app(directory: &str) -> Result<(), String> {
console::log(format!("{}", format!("Building {}...", directory).yellow()), true);
let mut build_command = Command::new("npx");
build_command.arg("parcel");
build_command.arg("build");
build_command.arg(format!("{}{}", WORKDIR.as_str(), directory));
if let Some(exit_code) = build_command.execute().unwrap() {
if exit_code == 0 {
console::log(
format!("{}", "Built successfully!".green()),
true,
);
Ok(())
} else {
Err(format!("Failed to build {}", directory))
}
} else {
Err(String::from("Build process interrupted"))
}
}
pub fn npm_install() -> Result<(), String> {
console::log(format!("{}", "Resolving NPM package configuration...".yellow()), true);
let mut npm_command = Command::new("npm");
npm_command.arg("install");
if let Some(exit_code) = npm_command.execute().unwrap() {
if exit_code == 0 {
console::log(
format!("{}", "All NPM packages installed.".green()),
true,
);
Ok(())
} else {
println!("{}", "Couldn\'t fetch NPM packages! Is Node.js installed?".red());
println!("For Arch/Manjaro: {}", "pacman -S nodejs npm".blue());
println!("For RHEL-Based Distros: {}", "dnf module install nodejs:latest".magenta());
println!("For Debian/Ubuntu: ------------------");
println!("{}", "curl -fsSL https://deb.nodesource.com/setup_15.x | sudo -E bash -".red());
println!("{}", "sudo apt-get install -y nodejs".red());
process::exit(0x0100);
}
} else {
Err(String::from("NPM fetch process interrupted"))
}
} |
// Derived from here:
//
// https://docs.rs/tantivy/0.11.3/tantivy/collector/struct.TopDocs.html#example
use tantivy::schema::Field;
use tantivy::SegmentReader;
use tantivy::collector::TopDocs;
use tantivy::query::QueryParser;
use tantivy::schema::*;
use tantivy::{doc, DocAddress, DocId, Index, Score};
fn create_schema() -> Schema {
let mut schema_builder = Schema::builder();
schema_builder.add_text_field("product_name", TEXT);
schema_builder.add_u64_field("popularity", FAST);
schema_builder.build()
}
fn create_index() -> tantivy::Result<Index> {
let schema = create_schema();
let index = Index::create_in_ram(schema);
let mut index_writer = index.writer_with_num_threads(1, 3_000_000)?;
let product_name = index.schema().get_field("product_name").unwrap();
let popularity: Field = index.schema().get_field("popularity").unwrap();
index_writer.add_document(doc!(product_name => "The Diary of Muadib", popularity => 1u64));
index_writer.add_document(doc!(product_name => "A Dairy Cow", popularity => 10u64));
index_writer
.add_document(doc!(product_name => "The Diary of a Young Girl", popularity => 15u64));
index_writer.commit()?;
Ok(index)
}
fn main() -> tantivy::Result<()> {
let index = create_index().unwrap();
let product_name = index.schema().get_field("product_name").unwrap();
let popularity: Field = index.schema().get_field("popularity").unwrap();
let user_query_str = "diary";
let query_parser = QueryParser::for_index(&index, vec![product_name]);
let query = query_parser.parse_query(user_query_str).unwrap();
// This is where we build our collector with our custom score.
let top_docs_by_custom_score =
TopDocs::with_limit(10).tweak_score(move |segment_reader: &SegmentReader| {
// The argument is a function that returns our scoring
// function.
//
// The point of this "mother" function is to gather all
// of the segment level information we need for scoring.
// Typically, fast_fields.
//
// In our case, we will get a reader for the popularity
// fast field.
let popularity_reader = segment_reader.fast_fields().u64(popularity).unwrap();
// We can now define our actual scoring function
move |doc: DocId, original_score: Score| {
let popularity: u64 = popularity_reader.get(doc);
// Well.. For the sake of the example we use a simple logarithm
// function.
let popularity_boost_score = ((2u64 + popularity) as f32).log2();
popularity_boost_score * original_score
}
});
let reader = index.reader().unwrap();
let searcher = reader.searcher();
// ... and here are our documents. Note this is a simple vec.
// The `Score` in the pair is our tweaked score.
let resulting_docs: Vec<(Score, DocAddress)> =
searcher.search(&query, &top_docs_by_custom_score).unwrap();
println!("{:?}", resulting_docs);
Ok(())
}
|
#![allow(unused_parens)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(dead_code)]
use std::env::current_dir;
use std::fs::File;
use std::io::BufReader;
mod parser;
use parser::parse;
const filename_input: &'static str = "fact.ng";
fn main ()
{
let filename_base = current_dir().unwrap();
let filename = filename_base.join(filename_input);
let file = File::open(filename).unwrap();
let input = BufReader::new(file);
let root = parse(input);
match root
{
Ok(tree) =>
{
println!("{:#?}", tree);
},
Err(error) =>
{
println!("{}", error);
}
}
}
|
// This file was generated
mod weak_private { pub trait Sealed<T: ?Sized> { } }
/// Extension for [`Weak`](std::rc::Weak)
pub trait IsntWeakExt<T: ?Sized>: weak_private::Sealed<T> {
/// The negation of [`ptr_eq`](std::rc::Weak::ptr_eq)
#[must_use]
fn not_ptr_eq(&self, other: &std::rc::Weak<T>) -> bool;
}
impl<T: ?Sized> weak_private::Sealed<T> for std::rc::Weak<T> { }
impl<T: ?Sized> IsntWeakExt<T> for std::rc::Weak<T> {
#[inline]
fn not_ptr_eq(&self, other: &std::rc::Weak<T>) -> bool {
!self.ptr_eq(other)
}
}
|
use crate::{
num::{real::consts::PI, Real},
source::{Source, SourceBuilder},
};
use std::time::Duration;
pub trait Wave: Source {
fn freq(&self) -> Real;
}
pub trait WaveBuilder
where
Self: SourceBuilder,
Self::Source: Wave,
{
fn freq(&mut self, freq: Real) -> &mut Self;
fn get_freq(&self) -> Real;
fn sample_rate(&mut self, rate: u32) -> &mut Self;
}
impl<'builder, B> WaveBuilder for &'builder mut B
where
B: WaveBuilder,
B::Source: Wave,
{
fn freq(&mut self, freq: Real) -> &mut Self {
(**self).freq(freq);
self
}
fn get_freq(&self) -> Real {
(**self).get_freq()
}
fn sample_rate(&mut self, rate: u32) -> &mut Self {
(**self).sample_rate(rate);
self
}
}
impl<B> WaveBuilder for Box<B>
where
B: WaveBuilder + ?Sized,
B::Source: Wave,
{
fn freq(&mut self, freq: Real) -> &mut Self {
(**self).freq(freq);
self
}
fn get_freq(&self) -> Real {
(**self).get_freq()
}
fn sample_rate(&mut self, rate: u32) -> &mut Self {
(**self).sample_rate(rate);
self
}
}
#[derive(Debug, Clone)]
pub struct SineWave {
freq: Real,
index: usize,
}
impl Iterator for SineWave {
type Item = Real;
fn next(&mut self) -> Option<Real> {
self.index = self.index.wrapping_add(1);
let index = self.index as Real;
let coeficient = PI * 2.0 * self.freq;
Some((coeficient * index / 48000.0).sin())
}
}
impl Source for SineWave {
fn duration(&self) -> Option<Duration> {
None
}
fn len(&self) -> Option<usize> {
None
}
fn channels(&self) -> u16 {
1
}
fn sample_rate(&self) -> u32 {
48000
}
}
impl Wave for SineWave {
fn freq(&self) -> Real {
self.freq
}
}
#[derive(Debug, Clone)]
pub struct SineWaveBuilder {
freq: Real,
sample_rate: u32,
}
impl Default for SineWaveBuilder {
fn default() -> Self {
Self { freq: 440.0, sample_rate: 48000 }
}
}
impl SourceBuilder for SineWaveBuilder {
type Source = SineWave;
fn get_channels(&self) -> u16 {
1
}
fn get_sample_rate(&self) -> u32 {
self.sample_rate
}
fn finish(&self) -> Self::Source {
SineWave { freq: self.freq, index: 0 }
}
}
impl WaveBuilder for SineWaveBuilder {
fn freq(&mut self, freq: Real) -> &mut Self {
self.freq = freq;
self
}
fn get_freq(&self) -> Real {
self.freq
}
fn sample_rate(&mut self, sample_rate: u32) -> &mut Self {
self.sample_rate = sample_rate;
self
}
}
#[derive(Debug, Clone)]
pub struct SawWave {
index: Real,
freq: Real,
}
impl Iterator for SawWave {
type Item = Real;
fn next(&mut self) -> Option<Real> {
let period = 48000.0 / self.freq;
if self.index > period {
self.index -= period;
} else {
self.index += 1.0;
}
let value = self.index / period * 2.0 - 1.0;
Some(value)
}
}
impl Source for SawWave {
fn len(&self) -> Option<usize> {
None
}
fn duration(&self) -> Option<Duration> {
None
}
fn channels(&self) -> u16 {
1
}
fn sample_rate(&self) -> u32 {
48000
}
}
impl Wave for SawWave {
fn freq(&self) -> Real {
self.freq
}
}
#[derive(Debug, Clone)]
pub struct SawWaveBuilder {
freq: Real,
sample_rate: u32,
}
impl Default for SawWaveBuilder {
fn default() -> Self {
Self { freq: 440.0, sample_rate: 48000 }
}
}
impl SourceBuilder for SawWaveBuilder {
type Source = SawWave;
fn get_channels(&self) -> u16 {
1
}
fn get_sample_rate(&self) -> u32 {
self.sample_rate
}
fn finish(&self) -> Self::Source {
SawWave { freq: self.freq, index: 0.0 }
}
}
impl WaveBuilder for SawWaveBuilder {
fn freq(&mut self, freq: Real) -> &mut Self {
self.freq = freq;
self
}
fn get_freq(&self) -> Real {
self.freq
}
fn sample_rate(&mut self, sample_rate: u32) -> &mut Self {
self.sample_rate = sample_rate;
self
}
}
#[derive(Debug, Clone)]
pub struct SquareWave {
index: Real,
freq: Real,
}
impl Iterator for SquareWave {
type Item = Real;
fn next(&mut self) -> Option<Real> {
let period = 48000.0 / self.freq;
if self.index > period {
self.index -= period;
} else {
self.index += 1.0;
}
let ratio = self.index / period;
let value = if ratio < 0.5 { 1.0 } else { -1.0 };
Some(value)
}
}
impl Source for SquareWave {
fn len(&self) -> Option<usize> {
None
}
fn duration(&self) -> Option<Duration> {
None
}
fn channels(&self) -> u16 {
1
}
fn sample_rate(&self) -> u32 {
48000
}
}
impl Wave for SquareWave {
fn freq(&self) -> Real {
self.freq
}
}
#[derive(Debug, Clone)]
pub struct SquareWaveBuilder {
freq: Real,
sample_rate: u32,
}
impl Default for SquareWaveBuilder {
fn default() -> Self {
Self { freq: 440.0, sample_rate: 48000 }
}
}
impl SourceBuilder for SquareWaveBuilder {
type Source = SquareWave;
fn get_channels(&self) -> u16 {
1
}
fn get_sample_rate(&self) -> u32 {
self.sample_rate
}
fn finish(&self) -> Self::Source {
SquareWave { freq: self.freq, index: 0.0 }
}
}
impl WaveBuilder for SquareWaveBuilder {
fn freq(&mut self, freq: Real) -> &mut Self {
self.freq = freq;
self
}
fn get_freq(&self) -> Real {
self.freq
}
fn sample_rate(&mut self, sample_rate: u32) -> &mut Self {
self.sample_rate = sample_rate;
self
}
}
#[derive(Debug, Clone)]
pub struct TriangleWave {
index: Real,
freq: Real,
}
impl Iterator for TriangleWave {
type Item = Real;
fn next(&mut self) -> Option<Real> {
let period = 48000.0 / self.freq;
if self.index > period {
self.index -= period;
} else {
self.index += 1.0;
}
let ratio = self.index / period * 4.0;
let value = if ratio < 1.0 {
ratio
} else if ratio < 3.0 {
2.0 - ratio
} else {
ratio - 4.0
};
Some(value)
}
}
impl Source for TriangleWave {
fn len(&self) -> Option<usize> {
None
}
fn duration(&self) -> Option<Duration> {
None
}
fn channels(&self) -> u16 {
1
}
fn sample_rate(&self) -> u32 {
48000
}
}
impl Wave for TriangleWave {
fn freq(&self) -> Real {
self.freq
}
}
#[derive(Debug, Clone)]
pub struct TriangleWaveBuilder {
freq: Real,
sample_rate: u32,
}
impl Default for TriangleWaveBuilder {
fn default() -> Self {
Self { freq: 440.0, sample_rate: 48000 }
}
}
impl SourceBuilder for TriangleWaveBuilder {
type Source = TriangleWave;
fn get_channels(&self) -> u16 {
1
}
fn get_sample_rate(&self) -> u32 {
self.sample_rate
}
fn finish(&self) -> Self::Source {
TriangleWave { freq: self.freq, index: 0.0 }
}
}
impl WaveBuilder for TriangleWaveBuilder {
fn freq(&mut self, freq: Real) -> &mut Self {
self.freq = freq;
self
}
fn get_freq(&self) -> Real {
self.freq
}
fn sample_rate(&mut self, sample_rate: u32) -> &mut Self {
self.sample_rate = sample_rate;
self
}
}
pub struct RichWave<W>
where
W: Wave,
{
wave: W,
helpers: Vec<W>,
dry: Real,
wet: Real,
}
impl<W> Iterator for RichWave<W>
where
W: Wave,
{
type Item = Real;
fn next(&mut self) -> Option<Real> {
let mut value = self.wave.next()? * self.dry;
for helper in &mut self.helpers {
value += helper.next()? * self.wet;
}
Some(value)
}
}
fn option_min<I, T>(init: Option<T>, iterable: I) -> Option<T>
where
I: IntoIterator<Item = Option<T>>,
T: Ord,
{
let mut ret = init;
for elem in iterable {
if let Some(curr) = ret {
if let Some(val) = elem.filter(|val| val < &curr) {
ret = Some(val);
} else {
ret = Some(curr);
}
} else {
ret = elem;
}
}
ret
}
impl<W> Source for RichWave<W>
where
W: Wave,
{
fn len(&self) -> Option<usize> {
option_min(
self.wave.len(),
self.helpers.iter().map(|helper| helper.len()),
)
}
fn duration(&self) -> Option<Duration> {
option_min(
self.wave.duration(),
self.helpers.iter().map(|helper| helper.duration()),
)
}
fn channels(&self) -> u16 {
self.wave.channels()
}
fn sample_rate(&self) -> u32 {
self.wave.sample_rate()
}
}
impl<W> Wave for RichWave<W>
where
W: Wave,
{
fn freq(&self) -> Real {
self.wave.freq()
}
}
#[derive(Debug, Clone)]
pub struct RichWaveBuilder<B>
where
B: WaveBuilder + Clone,
B::Source: Wave,
{
depth: usize,
dry: Real,
wet: Real,
min: Real,
max: Real,
inner: B,
}
impl<B> RichWaveBuilder<B>
where
B: WaveBuilder + Clone,
B::Source: Wave,
{
pub fn new(inner: B) -> Self {
Self { inner, depth: 0, min: 0.0, max: 20000.0, dry: 0.9, wet: 0.01 }
}
pub fn depth(&mut self, depth: usize) -> &mut Self {
self.depth = depth;
self
}
pub fn min(&mut self, min: Real) -> &mut Self {
self.min = min;
self
}
pub fn max(&mut self, max: Real) -> &mut Self {
self.max = max;
self
}
pub fn dry(&mut self, dry: Real) -> &mut Self {
self.dry = dry;
self
}
pub fn wet(&mut self, wet: Real) -> &mut Self {
self.wet = wet;
self
}
pub fn get_depth(&self) -> usize {
self.depth
}
pub fn get_min(&self) -> Real {
self.min
}
pub fn get_max(&self) -> Real {
self.max
}
pub fn get_dry(&self) -> Real {
self.dry
}
pub fn get_wet(&self) -> Real {
self.wet
}
}
impl<B> SourceBuilder for RichWaveBuilder<B>
where
B: WaveBuilder + Clone,
B::Source: Wave,
{
type Source = RichWave<B::Source>;
fn get_channels(&self) -> u16 {
self.inner.get_channels()
}
fn get_sample_rate(&self) -> u32 {
self.inner.get_sample_rate()
}
fn finish(&self) -> Self::Source {
let wave = self.inner.finish();
let mut helpers = Vec::with_capacity(self.depth);
let leap = (self.max - self.min) / self.depth as Real;
for i in 0 .. self.depth {
let freq = self.min + i as Real * leap;
helpers.push(self.inner.clone().freq(freq).finish());
}
RichWave { wave, helpers, dry: self.dry, wet: self.wet }
}
}
impl<B> WaveBuilder for RichWaveBuilder<B>
where
B: WaveBuilder + Clone,
B::Source: Wave,
{
fn freq(&mut self, freq: Real) -> &mut Self {
self.inner.freq(freq);
self
}
fn get_freq(&self) -> Real {
self.inner.get_freq()
}
fn sample_rate(&mut self, sample_rate: u32) -> &mut Self {
self.inner.sample_rate(sample_rate);
self
}
}
|
impl Solution {
pub fn generate_matrix(n: i32) -> Vec<Vec<i32>> {
fn gen(i: i32, n: i32) -> Vec<Vec<i32>> {
if n == 1 {
return vec![vec![i]];
}
if n == 2 {
return vec![vec![i, i+1], vec![i+3, i+2]];
}
let N = n as usize;
let inner = gen(i+4*n-4, n-2);
let mut spiral = vec![vec![0; N]; N];
for j in 1..N-1 {
spiral[j][0] = i+n*2-1+(n-2)*2 - (j as i32)+1;
spiral[j][N-1] = i+n+(j as i32)-1;
for k in 1..N-1 {
spiral[j][k] = inner[j-1][k-1];
}
}
spiral[0] = (i..i+n).collect();
spiral[N-1] = (i+2*n-2 .. i+3*n-2).rev().collect();
spiral
}
gen(1, n)
}
}
/*
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
*/
|
use clapme::ClapMe;
use display_as::{display, with_template, DisplayAs, HTML, URL, UTF8};
use serde::{Deserialize, Serialize};
use warp::reply::Reply;
use warp::{path, Filter};
mod atomicfile;
// mod sheets;
#[derive(Debug, ClapMe, Serialize)]
struct TlsFlags {
/// Contact email for domain.
email: String,
/// Domain to serve on using https
domain: String,
}
#[derive(Debug, ClapMe, Serialize)]
struct Flags {
/// Port to serve on, if not port 80.
port: Option<u16>,
/// Options for TLS configuration
_tls: Option<TlsFlags>,
}
fn percent_decode(x: &str) -> String {
percent_encoding::percent_decode(x.as_bytes())
.decode_utf8()
.unwrap()
.to_string()
}
#[tokio::main]
async fn main() {
let flags = Flags::from_args();
let style_css = path!("style.css").map(|| {
const STYLE: &'static str = include_str!("../style.css");
Ok(warp::http::Response::builder()
.status(200)
.header("content-length", STYLE.len())
.header("content-type", "text/css")
.body(STYLE)
.unwrap())
});
let edit = path!("edit-thing")
.and(warp::filters::body::form())
.map(|change: EditThing| {
println!("creating new thing {:?}", change);
change.edit();
"okay"
});
let new = path!("new-thing")
.and(warp::filters::body::form())
.map(|change: NewThing| {
println!("creating new thing {:?}", change);
change.save();
"okay"
});
let backup = path!("backup" / String).map(|code: String| {
let mut output = Vec::new();
{
let mut ar = tar::Builder::new(&mut output);
// Use the directory at one location, but insert it into the archive
// with a different name.
ar.append_dir_all("data", format!("data/{}", code)).unwrap();
ar.finish().unwrap();
}
Ok(warp::http::Response::builder()
.status(200)
.header("content-length", output.len())
.header("content-type", "application/tar")
.header("content-disposition", r#"attachment; filename="data.tar""#)
.body(output)
.unwrap())
});
let choose = path!("choose" / String / String / String).map(
|code: String, list: String, name: String| {
let change = ChooseThing {
code: percent_decode(&code),
name: percent_decode(&name),
list: percent_decode(&list),
};
println!("choosing thing {:?}", change);
display(HTML, &change.choose()).into_response()
},
);
let delay =
path!("pass" / String / String / String).map(|code: String, list: String, name: String| {
let change = ChooseThing {
code: percent_decode(&code),
name: percent_decode(&name),
list: percent_decode(&list),
};
println!("delay thing {:?}", change);
display(HTML, &change.delay()).into_response()
});
let index = (warp::path::end().or(path!("index.html"))).map(|_| {
println!("I am doing index.");
display(HTML, &Index {}).into_response()
});
let search = path!("search" / String / String / String).map(
|code: String, listname: String, pattern: String| {
let listname = percent_encoding::percent_decode(listname.as_bytes())
.decode_utf8()
.unwrap();
let code = percent_encoding::percent_decode(code.as_bytes())
.decode_utf8()
.unwrap();
let pattern = if pattern != "qqq" {
percent_encoding::percent_decode(pattern.as_bytes())
.decode_utf8()
.unwrap()
} else {
"".into()
};
let x = ThingsOnly(ThingList::read(&code, &listname).filter(&pattern));
display(HTML, &x).into_response()
},
);
let sort = path!("sort" / String / String).map(|code: String, listname: String| {
println!("I am sorting the list.");
let listname = percent_encoding::percent_decode(listname.as_bytes())
.decode_utf8()
.unwrap();
let code = percent_encoding::percent_decode(code.as_bytes())
.decode_utf8()
.unwrap();
let x = ThingsOnly(ThingList::read(&code, &listname).sorted());
println!("I am done sorting the list.");
display(HTML, &x).into_response()
});
let list = path!(String / String).map(|code: String, listname: String| {
let listname = percent_encoding::percent_decode(listname.as_bytes())
.decode_utf8()
.unwrap();
let code = percent_encoding::percent_decode(code.as_bytes())
.decode_utf8()
.unwrap();
let x = ThingList::read(&code, &listname);
display(HTML, &x).into_response()
});
let list_of_lists = path!(String).map(|code: String| {
println!("list of lists: {}", code);
let code = percent_encoding::percent_decode(code.as_bytes())
.decode_utf8()
.unwrap();
let x = ThingList::read(&code, "fixme");
display(HTML, &x).into_response()
});
// let sheets_filter = sheets::sheets();
if let Some(tls) = flags._tls {
lets_encrypt_warp::lets_encrypt(
style_css
// .or(sheets_filter)
.or(backup)
.or(edit)
.or(new)
.or(choose)
.or(delay)
.or(sort)
.or(search)
.or(list)
.or(list_of_lists)
.or(index),
&tls.email,
&tls.domain,
)
.await
.expect("Error connecting with TLS");
} else {
warp::serve(
style_css
// .or(sheets_filter)
.or(backup)
.or(edit)
.or(new)
.or(choose)
.or(delay)
.or(sort)
.or(search)
.or(list)
.or(list_of_lists)
.or(index),
)
.run(([0, 0, 0, 0], flags.port.unwrap_or(80)))
.await;
}
}
struct Index {}
#[with_template("[%" "%]" "index.html")]
impl DisplayAs<HTML> for Index {}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct NewThing {
code: String,
name: String,
list: String,
}
impl NewThing {
fn save(&self) {
let mut list = ThingList::read(&self.code, &self.list);
let now = list.now();
let newthing = Thing {
name: self.name.clone(),
link: None,
next: now,
first_chosen: now,
chosen: now,
created: now,
count: 0,
parent_code: self.code.clone(),
parent_name: self.list.clone(),
};
list.things.push(newthing);
list.save();
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ChooseThing {
code: String,
name: String,
list: String,
}
impl ChooseThing {
fn choose(&self) -> ThingsOnly {
let mut list = ThingList::read(&self.code, &self.list);
list.choose(&self.name);
list.save();
ThingsOnly(list)
}
fn delay(&self) -> ThingsOnly {
let mut list = ThingList::read(&self.code, &self.list);
list.delay(&self.name);
list.save();
ThingsOnly(list)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct EditThing {
code: String,
name: String,
list: String,
link: String,
newname: String,
}
impl EditThing {
fn edit(&self) {
let mut list = ThingList::read(&self.code, &self.list);
let th = list.edit(&self.name);
th.name = self.newname.clone();
if self.link.len() > 0 {
th.link = Some(self.link.clone());
}
list.save();
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct Thing {
name: String,
#[serde(default)]
link: Option<String>,
created: f64,
first_chosen: f64,
chosen: f64,
next: f64,
count: u64,
parent_code: String,
parent_name: String,
}
#[with_template("[%" "%]" "thing.html")]
impl DisplayAs<HTML> for Thing {}
impl Thing {
fn slug(&self) -> String {
self.name
.replace("'", "-")
.replace(" ", "-")
.replace("\"", "-")
.replace("\\", "-")
}
fn priority(&self) -> f64 {
self.next
}
fn mean_interval(&self) -> f64 {
if self.count < 2 {
1.0
} else {
(self.chosen - self.first_chosen) / (self.count as f64 - 1.0)
}
}
fn delay_time(&self, list: &ThingList) -> f64 {
if self.count > 1 {
geometric_mean(&[
list.now() - self.chosen,
self.mean_interval(),
list.mean_interval(),
])
} else if self.count == 1 {
geometric_mean(&[list.now() - self.chosen, list.mean_interval()])
} else {
list.mean_interval()
}
}
}
pub fn read_lists(code: &str) -> Vec<String> {
let dir: std::path::PathBuf = format!("data/{}", code).into();
match std::fs::read_dir(&dir) {
Ok(ddd) => {
let mut lists = Vec::new();
for entry in ddd {
if let Ok(entry) = entry {
if let Some(s) = entry
.path()
.to_str()
.iter()
.flat_map(|x| x.rsplit('/'))
.next()
{
lists.push(s.to_string());
}
}
}
lists
}
Err(_) => Vec::new(),
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ThingList {
code: String,
name: String,
things: Vec<Thing>,
}
#[with_template("[%" "%]" "things.html")]
impl DisplayAs<HTML> for ThingList {}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct ThingsOnly(ThingList);
#[with_template("[%" "%]" "things-only.html")]
impl DisplayAs<HTML> for ThingsOnly {}
impl ThingList {
fn read(code: &str, name: &str) -> Self {
if let Ok(f) = ::std::fs::File::open(format!("data/{}/{}", code, name)) {
if let Ok(mut s) = serde_yaml::from_reader::<_, Vec<Thing>>(&f) {
// Anything that has an empty name should just be deleted...
s.retain(|x| x.name.len() > 0);
// Do not retain any duplicate entries, since that can cause trouble and confusion!
let mut to_delete = Vec::new();
for (i, thing) in s.iter().enumerate() {
if s[i + 1..].contains(thing) {
to_delete.push(i);
}
}
for i in to_delete.into_iter().rev() {
s.remove(i);
}
return ThingList {
code: code.to_string(),
name: name.to_string(),
things: s,
};
}
}
ThingList {
code: code.to_string(),
name: name.to_string(),
things: Vec::new(),
}
}
fn filter(mut self, s: &str) -> Self {
self.things.retain(|x| x.name.contains(s));
self
}
fn sorted(mut self) -> Self {
self.things.sort_by_key(|x| x.chosen as i64);
self.things.sort_by_key(|x| x.count as i64);
let now = self.now();
for (i, x) in self.things.iter_mut().enumerate() {
x.next = now + i as f64;
}
self.save();
self
}
fn now(&self) -> f64 {
self.things.iter().map(|x| x.count as f64).sum()
}
fn mean_interval(&self) -> f64 {
self.things.len() as f64
}
fn save(&self) {
let f = atomicfile::AtomicFile::create(format!("data/{}/{}", self.code, self.name))
.expect("error creating save file");
serde_yaml::to_writer(&f, &self.things).expect("error writing yaml")
}
fn edit(&mut self, which: &str) -> &mut Thing {
let mut wh = self.things.len();
for (i, th) in self.things.iter().enumerate() {
if th.name == which {
wh = i;
break;
}
}
if wh == self.things.len() {
let now = self.now() + 1.0;
self.things.push(Thing {
name: which.to_string(),
link: None,
next: now,
first_chosen: now,
chosen: now,
created: now,
count: 0,
parent_name: self.name.clone(),
parent_code: self.code.clone(),
});
}
&mut self.things[wh]
}
fn choose(&mut self, which: &str) {
// print(
// 'choosing: ${prettyTime(chosen)} and ${prettyDuration(meanInterval)} and ${prettyDuration(meanIntervalList)}');
let now = self.now() + 1.0;
let mut which_num = 0;
let mut thing = Thing {
name: which.to_string(),
link: None,
next: now,
first_chosen: now,
chosen: now,
created: now,
count: 0,
parent_name: self.name.clone(),
parent_code: self.code.clone(),
};
for (i, th) in self.things.iter().enumerate() {
if th.name == which {
thing = th.clone();
which_num = i;
thing.next = now + thing.delay_time(self);
thing.chosen = now;
thing.count += 1;
if thing.count == 1 {
thing.first_chosen = now;
}
}
}
self.things.remove(which_num);
let mut place = 0;
for (i, th) in self.things.iter().enumerate() {
if th.next <= thing.next {
place = i + 1;
}
}
self.things.insert(place, thing);
}
fn delay(&mut self, which: &str) {
// print(
// 'choosing: ${prettyTime(chosen)} and ${prettyDuration(meanInterval)} and ${prettyDuration(meanIntervalList)}');
let now = self.now() + 1.0;
let mut which_num = 0;
let mut thing = Thing {
name: self.name.clone(),
link: None,
next: now,
first_chosen: now,
chosen: now,
created: now,
count: 0,
parent_name: self.name.clone(),
parent_code: self.code.clone(),
};
for (i, th) in self.things.iter_mut().enumerate() {
if th.name == which {
thing = th.clone();
which_num = i;
}
}
if which_num == self.things.len() - 1 {
// It is already last, no point delaying!
return;
}
while self.things[which_num].name == which {
// Checking that the thing was actually found and hasn't yet moved
self.things.remove(which_num);
thing.next += thing.delay_time(self) * (0.1 + 0.9 * rand::random::<f64>());
let mut place = 0;
for (i, th) in self.things.iter().enumerate() {
if th.next <= thing.next {
place = i + 1;
}
}
self.things.insert(place, thing.clone());
}
}
}
impl PartialOrd for Thing {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Thing {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
if self.priority() < other.priority() {
std::cmp::Ordering::Less
} else {
std::cmp::Ordering::Greater
}
}
}
impl PartialEq for Thing {
fn eq(&self, other: &Self) -> bool {
self.name == other.name
}
}
impl Eq for Thing {}
pub fn geometric_mean(data: &[f64]) -> f64 {
let mut product = 1.0;
for &d in data.iter() {
product *= d;
}
product.powf(1.0 / data.len() as f64)
}
|
/*
https://projecteuler.net
We shall say that an n-digit number is pandigital if it makes use of
all the digits 1 to n exactly once. For example, 2143 is a 4-digit
pandigital and is also prime.
What is the largest n-digit pandigital prime that exists?
NOTES:
Using the is_pandigital() trait (with a small tweak to find
pandigitals with fewer digits) for p0038 and the prime_to() function
from previous efforts, simply create the vector of primes to 987654321
and iterate backwards until the first pandigital is found.
I took 396 seconds to solve, that's probably longer than it took to write and compile!
*/
trait IsPandigital {
fn is_pandigital(&self) -> bool;
}
impl IsPandigital for u64 {
fn is_pandigital(&self) -> bool {
let mut v = [false; 10];
let mut n = *self;
let mut count = 0;
while n > 0 {
count += 1;
v[ (n%10) as usize ] = true;
n /= 10;
}
if count == 0 || count > 9 {
return false;
}
for i in 1..=count {
if !v[i] {
return false;
}
}
true
}
}
#[test]
fn test_pandigital() {
assert!(123456789_u64.is_pandigital());
assert!(!123456780_u64.is_pandigital());
assert!(!1234567891_u64.is_pandigital());
assert!(!23456789_u64.is_pandigital());
assert!(123456_u64.is_pandigital());
assert!(!123455_u64.is_pandigital());
assert!(!12346_u64.is_pandigital());
}
fn solve() -> u64 {
let v = sb::math::prime_to(987_654_321);
println!("Found {} primes", v.len());
for n in v.iter().rev() {
if n.is_pandigital() {
return *n;
}
}
panic!("no solution found!");
}
fn main() {
let start_time = std::time::Instant::now();
let sol = solve();
let elapsed = start_time.elapsed().as_micros();
println!("\nSolution: {}", sol);
let mut remain = elapsed;
let mut s = String::new();
if remain == 0 {
s.insert(0,'0');
}
while remain > 0 {
let temp = remain%1000;
remain /= 1000;
if remain > 0 {
s = format!(",{:03}",temp) + &s;
}
else {
s = format!("{}",temp) + &s;
}
}
println!("Elasped time: {} us", s);
}
|
struct Solution;
impl Solution {
pub fn longest_common_prefix(strs: Vec<String>) -> String {
match strs.len() {
0 => return String::new(),
1 => return strs[0].clone(),
_ => (),
};
let mut buf = String::new();
for (i, c) in strs[0].as_bytes().iter().enumerate() {
for j in 1..strs.len() {
if i >= strs[j].len() || strs[j].as_bytes()[i] != *c {
return buf;
}
}
buf.push(*c as char);
}
buf
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_longest_common_prefix() {
let strs = vec!["flower", "flow", "flight"]
.iter()
.map(|x| x.to_string())
.collect();
assert_eq!(Solution::longest_common_prefix(strs), "fl".to_owned());
let strs = vec!["dog", "racecar", "car"]
.iter()
.map(|x| x.to_string())
.collect();
assert_eq!(Solution::longest_common_prefix(strs), "".to_owned());
let strs = vec!["aa", "a"].iter().map(|x| x.to_string()).collect();
assert_eq!(Solution::longest_common_prefix(strs), "a".to_owned());
}
}
|
use actix_web::HttpResponse;
use super::super::response;
pub fn index() -> HttpResponse {
response::health::response()
} |
mod point_layout;
pub use self::point_layout::*;
mod point_type;
pub use self::point_type::*;
pub mod conversion;
//pub use self::conversion;
|
//! Core functionality: Uses strongly typed objects to represent input and
//! output. Public interfaces will wrap this code with common types for ease
//! of use.
use std::collections::HashMap;
use std::hash::Hash;
/// Represents the number of rows and columns occupied by a given table cell.
#[derive(Copy, Clone, PartialEq, Eq)]
pub(crate) struct Span {
rows: usize,
cols: usize,
}
impl Span {
/// Create a new Span with the specified dimensions.
///
/// # Panics:
///
/// This constructor panics if the value provided for rows or cols is zero.
pub(crate) fn new(rows: usize, cols: usize) -> Span {
if rows == 0 {
panic!("Error constructing Span. Zero value provided for Span.rows.")
} else if cols == 0 {
panic!("Error constructing Span. Zero value provided for Span.cols.")
}
Span { rows, cols }
}
}
impl Default for Span {
/// Construct a default Span.
///
/// A derived Default trait would construct a value of
/// `Span { rows: 0, cols: 0 }` so we have to implement this manually.
fn default() -> Span {
Span::new(1, 1)
}
}
/// Type alias for input table data, without span information.
pub(crate) type TableSpec<T> = Vec<Vec<T>>;
/// Type alias for output table layout with spanned cells rendered as `None`.
pub(crate) type TableLayout<T> = Vec<Vec<Option<T>>>;
/// [PRIVATE] Tracks which columns are currently occupied by active row
/// spans.
///
/// # Note:
///
/// * This object is completely unaware of multi-column spans. The caller
/// is responsible for tracking all columns of a multi-column span by
/// calling `RowSpanTracker::track(..)` on each column separately.
///
/// * This object does not track which rows or columns belong to which
/// spans, only that they are spanned by *some* cell.
///
/// * This version maintains state, and tracks row spans relative to the
/// current row. An alternative implementation that tracks all spans
/// statelessly might be more flexible, but would require the caller to
/// track information like current row.
struct RowSpanTracker(HashMap<usize, usize>);
impl RowSpanTracker {
/// Create an empty RowSpanTracker object
fn new() -> RowSpanTracker {
RowSpanTracker(HashMap::new())
}
/// Track a new rowspan for the given column. Caller should provide
/// the total number of spanned rows for the column.
fn track(&mut self, col_index: usize, row_count: usize) {
if row_count > 1 {
self.0.insert(col_index, row_count);
}
}
/// Decrement all the active spans. This should be called after each
/// row is fully processed.
fn dec(&mut self) {
let keys = self.0.keys().cloned().collect::<Vec<_>>();
for key in keys {
if let Some(value) = self.0.get_mut(&key) {
if *value > 1 {
*value -= 1;
} else {
self.0.remove(&key);
}
}
}
}
/// Report if the current column is part of an active rowspan.
fn spanned(&self, col_index: usize) -> bool {
self.0.get(&col_index).unwrap_or(&0) > &0
}
/// Report the highest column that is part of an active rowspan.
///
/// If there are no active rowspans, returns None.
///
fn max_spanned(&self) -> Option<usize> {
self.0.keys().max().cloned()
}
}
/// [PRIVATE] Given a candidate column, and the cell's column count, return
/// `true` if the cell can be fit into this location of the table.
fn cell_fits(col: usize, col_count: usize, active_row_spans: &RowSpanTracker) -> bool {
for peek in col..col + col_count {
if active_row_spans.spanned(peek) {
return false;
}
}
true
}
/// Determine the layout of table cells given the available spans and the
/// data for the table.
pub(crate) fn layout_table<T>(spaninfo: &HashMap<T, Span>, data: &TableSpec<T>) -> TableLayout<T>
where
T: Hash + Eq + Clone,
{
let mut table: TableLayout<T> = Vec::new();
let mut active_row_spans = RowSpanTracker::new();
for inrow in data {
let mut row = Vec::new();
for cell in inrow.iter() {
let span = spaninfo.get(&cell).cloned().unwrap_or_default();
while !cell_fits(row.len(), span.cols, &active_row_spans) {
row.push(None);
}
active_row_spans.track(row.len(), span.rows);
row.push(Some(cell.clone()));
for _ in 1..span.cols {
active_row_spans.track(row.len(), span.rows);
row.push(None);
}
}
table.push(row);
active_row_spans.dec();
}
// Handle trailing spanned rows.
while let Some(col) = active_row_spans.max_spanned() {
table.push(vec![None; col + 1]);
active_row_spans.dec();
}
table
}
#[cfg(test)]
mod tests {
use super::*;
/// If no span specifications are given,
/// return a simple table that matches the input
#[test]
fn basic_table_layout() {
let spanspec = HashMap::new();
let data = vec![
vec!["A", "B", "C"],
vec!["D", "E", "F"],
vec!["G", "H", "I"],
];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![Some("D"), Some("E"), Some("F")],
vec![Some("G"), Some("H"), Some("I")],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
#[test]
fn layout_with_colspan() {
let mut spanspec = HashMap::new();
spanspec.insert("D", Span::new(1, 2));
let data = vec![vec!["A", "B", "C"], vec!["D", "E"], vec!["G", "H", "I"]];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![Some("D"), None, Some("E")],
vec![Some("G"), Some("H"), Some("I")],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
#[test]
fn layout_with_rowspan() {
let mut spanspec = HashMap::new();
spanspec.insert("E", Span::new(2, 1));
let data = vec![
vec!["A", "B", "C"],
vec!["D", "E", "F"],
vec!["G", "H"],
vec!["J", "K", "L"],
];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![Some("D"), Some("E"), Some("F")],
vec![Some("G"), None, Some("H")],
vec![Some("J"), Some("K"), Some("L")],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
#[test]
fn test_block_span() {
let mut spanspec = HashMap::new();
spanspec.insert("D", Span::new(3, 2));
spanspec.insert("E", Span::new(1, 2));
let data = vec![
vec!["A", "B", "C"],
vec!["D", "E", "F"],
vec!["G", "H", "I"],
vec!["J", "K", "L"],
vec!["M", "N", "O"],
];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![Some("D"), None, Some("E"), None, Some("F")],
vec![None, None, Some("G"), Some("H"), Some("I")],
vec![None, None, Some("J"), Some("K"), Some("L")],
vec![Some("M"), Some("N"), Some("O")],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
#[test]
fn test_overlapping_row_spans() {
let mut spanspec = HashMap::new();
spanspec.insert("E", Span::new(2, 1));
spanspec.insert("H", Span::new(2, 1));
let data = vec![
vec!["A", "B", "C"],
vec!["D", "E", "F"],
vec!["G", "H", "I"],
vec!["J", "K", "L"],
vec!["M", "N", "O"],
];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![Some("D"), Some("E"), Some("F")],
vec![Some("G"), None, Some("H"), Some("I")],
vec![Some("J"), Some("K"), None, Some("L")],
vec![Some("M"), Some("N"), Some("O")],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
#[test]
fn rowspan_blocking_colspans() {
// If a rowspan blocks a colspan, push the colspan back past the end of the
// rowspanned object.
let mut spanspec = HashMap::new();
spanspec.insert("E", Span::new(2, 1));
spanspec.insert("G", Span::new(2, 2));
let data = vec![
vec!["A", "B", "C"],
vec!["D", "E", "F"],
vec!["G", "H", "I"],
vec!["J", "K", "L"],
vec!["M", "N", "O"],
];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![Some("D"), Some("E"), Some("F")],
vec![None, None, Some("G"), None, Some("H"), Some("I")],
vec![Some("J"), Some("K"), None, None, Some("L")],
vec![Some("M"), Some("N"), Some("O")],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
#[test]
fn test_trailing_rowspans() {
let mut spanspec = HashMap::new();
spanspec.insert("B", Span::new(3, 1));
spanspec.insert("C", Span::new(2, 1));
let data = vec![vec!["A", "B", "C"]];
let expected = vec![
vec![Some("A"), Some("B"), Some("C")],
vec![None, None, None],
vec![None, None],
];
let result = layout_table(&spanspec, &data);
assert_eq!(result, expected);
}
}
|
use crate::*;
use serde::{Deserialize, Serialize};
pub(crate) struct JsonService<'a, T: Transport> {
device: &'a Client<T>,
uri: http::Uri,
api_version: String,
}
impl<'a, T: Transport> JsonService<'a, T> {
pub fn new(device: &'a Client<T>, path_and_query: &str, api_version: String) -> Self {
Self {
device,
uri: device.uri_for(path_and_query).unwrap(),
api_version,
}
}
async fn inner<RQ, RS>(&self, method: &str, request: Option<RQ>) -> Result<RS>
where
RQ: serde::Serialize,
RS: serde::de::DeserializeOwned,
{
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Req<'a, RQ> {
api_version: &'a str,
method: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
params: Option<&'a RQ>,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Resp<RS> {
error: Option<crate::error::RawJsonApiError>,
data: Option<RS>,
}
let req = {
let json_request = Req {
api_version: &self.api_version,
method,
params: request.as_ref(),
};
let json_request = serde_json::to_vec(&json_request).unwrap();
http::Request::builder()
.method(http::method::Method::POST)
.uri(&self.uri)
.header(http::header::CONTENT_TYPE, "application/json")
.body(json_request)
.unwrap()
};
let (_resp, resp_body) = self.device.roundtrip(req, "application/json").await?;
let resp_body: Resp<RS> = serde_json::from_slice(resp_body.as_slice())?;
if let Some(e) = resp_body.error {
return Err(e.into());
}
if let Some(d) = resp_body.data {
Ok(d)
} else {
Err(Error::Other("response included neither `data` nor `error`"))
}
}
pub async fn call_method<RQ, RS>(&self, method: &str, params: RQ) -> Result<RS>
where
RQ: serde::Serialize,
RS: serde::de::DeserializeOwned,
{
self.inner(method, Some(params)).await
}
pub async fn call_method_bare<RS>(&self, method: &str) -> Result<RS>
where
RS: serde::de::DeserializeOwned,
{
let params: Option<()> = None;
self.inner(method, params).await
}
}
|
use kvfmt::kvfmt;
fn main() {
let dir = "/var/log";
let paths = vec!["dmesg", "syslog"];
assert_eq!(
"dir=/var/log paths=[\"dmesg\", \"syslog\"]",
kvfmt!(dir, ?paths)
);
}
|
use crate::parser_state::Type;
pub use crate::Span;
#[derive(Debug)]
pub enum ParseError {
ExtraTokens(Span),
ExtraPositional(Span),
UnexpectedEof(String, Span),
Unclosed(String, Span),
UnknownStatement(Span),
Mismatch(String, Span),
MultipleRestParams(Span),
VariableNotFound(Span),
UnknownCommand(Span),
NonUtf8(Span),
UnknownFlag(Span),
UnknownType(Span),
MissingFlagParam(Span),
ShortFlagBatchCantTakeArg(Span),
MissingPositional(String, Span),
MissingType(Span),
TypeMismatch(Type, Span),
MissingRequiredFlag(String, Span),
IncompleteMathExpression(Span),
UnknownState(String, Span),
}
|
use crate::common::{CurrentCell, LazyLoadCellOutput};
use crate::syscalls::{Source, ITEM_MISSING, LOAD_CELL_SYSCALL_NUMBER, SUCCESS};
use ckb_core::cell::CellMeta;
use ckb_protocol::CellOutput as FbsCellOutput;
use ckb_store::ChainStore;
use ckb_vm::{
Error as VMError, Memory, Register, SupportMachine, Syscalls, A0, A1, A2, A3, A4, A7,
};
use flatbuffers::FlatBufferBuilder;
use std::cmp;
use std::sync::Arc;
pub struct LoadCell<'a, CS> {
store: Arc<CS>,
outputs: &'a [CellMeta],
input_cells: &'a [&'a CellMeta],
current: CurrentCell,
dep_cells: &'a [&'a CellMeta],
}
impl<'a, CS: ChainStore + 'a> LoadCell<'a, CS> {
pub fn new(
store: Arc<CS>,
outputs: &'a [CellMeta],
input_cells: &'a [&'a CellMeta],
current: CurrentCell,
dep_cells: &'a [&'a CellMeta],
) -> LoadCell<'a, CS> {
LoadCell {
store,
outputs,
input_cells,
current,
dep_cells,
}
}
fn fetch_cell(&self, source: Source, index: usize) -> Option<&'a CellMeta> {
match source {
Source::Input => self.input_cells.get(index).cloned(),
Source::Output => self.outputs.get(index),
Source::Current => match self.current {
CurrentCell::Input(index) => self.input_cells.get(index).cloned(),
CurrentCell::Output(index) => self.outputs.get(index),
},
Source::Dep => self.dep_cells.get(index).cloned(),
}
}
}
impl<'a, Mac: SupportMachine, CS: ChainStore> Syscalls<Mac> for LoadCell<'a, CS> {
fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
Ok(())
}
fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
if machine.registers()[A7].to_u64() != LOAD_CELL_SYSCALL_NUMBER {
return Ok(false);
}
machine.add_cycles(100)?;
let addr = machine.registers()[A0].to_usize();
let size_addr = machine.registers()[A1].to_usize();
let size = machine
.memory_mut()
.load64(&Mac::REG::from_usize(size_addr))?
.to_usize();
let index = machine.registers()[A3].to_usize();
let source = Source::parse_from_u64(machine.registers()[A4].to_u64())?;
let cell = self.fetch_cell(source, index);
if cell.is_none() {
machine.set_register(A0, Mac::REG::from_u8(ITEM_MISSING));
return Ok(true);
}
let cell = cell.unwrap();
let output = self.store.lazy_load_cell_output(&cell);
// NOTE: this is a very expensive operation here since we need to copy
// everything in a cell to a flatbuffer object, serialize the object
// into a buffer, and then copy requested data to VM memory space. So
// we should charge cycles proportional to the full Cell size no matter
// how much data the actual script is requesting, the per-byte cycle charged
// here, should also be significantly higher than LOAD_CELL_BY_FIELD.
// Also, while this is debatable, I suggest we charge full cycles for
// subsequent calls even if we have cache implemented here.
// TODO: find a way to cache this without consuming too much memory
let mut builder = FlatBufferBuilder::new();
let offset = FbsCellOutput::build(&mut builder, &output);
builder.finish(offset, None);
let data = builder.finished_data();
let offset = machine.registers()[A2].to_usize();
let full_size = data.len() - offset;
let real_size = cmp::min(size, full_size);
machine.memory_mut().store64(
&Mac::REG::from_usize(size_addr),
&Mac::REG::from_usize(full_size),
)?;
machine
.memory_mut()
.store_bytes(addr, &data[offset..offset + real_size])?;
machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
machine.add_cycles(data.len() as u64 * 100)?;
Ok(true)
}
}
|
// Import hacspec and all needed definitions.
use hacspec_lib::*;
const BLOCK_SIZE: usize = 128;
const LEN_SIZE: usize = 16;
pub const K_SIZE: usize = 80;
pub const HASH_SIZE: usize = 512 / 8;
bytes!(Block, BLOCK_SIZE);
array!(OpTableType, 12, usize);
bytes!(Sha512Digest, HASH_SIZE);
array!(RoundConstantsTable, K_SIZE, U64);
array!(Hash, 8, U64);
fn ch(x: U64, y: U64, z: U64) -> U64 {
(x & y) ^ ((!x) & z)
}
fn maj(x: U64, y: U64, z: U64) -> U64 {
(x & y) ^ ((x & z) ^ (y & z))
}
const OP_TABLE: OpTableType = OpTableType([28, 34, 39, 14, 18, 41, 1, 8, 7, 19, 61, 6]);
#[rustfmt::skip]
const K_TABLE: RoundConstantsTable = RoundConstantsTable(secret_array!(
U64,
[
0x428a2f98d728ae22u64, 0x7137449123ef65cdu64, 0xb5c0fbcfec4d3b2fu64, 0xe9b5dba58189dbbcu64,
0x3956c25bf348b538u64, 0x59f111f1b605d019u64, 0x923f82a4af194f9bu64, 0xab1c5ed5da6d8118u64,
0xd807aa98a3030242u64, 0x12835b0145706fbeu64, 0x243185be4ee4b28cu64, 0x550c7dc3d5ffb4e2u64,
0x72be5d74f27b896fu64, 0x80deb1fe3b1696b1u64, 0x9bdc06a725c71235u64, 0xc19bf174cf692694u64,
0xe49b69c19ef14ad2u64, 0xefbe4786384f25e3u64, 0x0fc19dc68b8cd5b5u64, 0x240ca1cc77ac9c65u64,
0x2de92c6f592b0275u64, 0x4a7484aa6ea6e483u64, 0x5cb0a9dcbd41fbd4u64, 0x76f988da831153b5u64,
0x983e5152ee66dfabu64, 0xa831c66d2db43210u64, 0xb00327c898fb213fu64, 0xbf597fc7beef0ee4u64,
0xc6e00bf33da88fc2u64, 0xd5a79147930aa725u64, 0x06ca6351e003826fu64, 0x142929670a0e6e70u64,
0x27b70a8546d22ffcu64, 0x2e1b21385c26c926u64, 0x4d2c6dfc5ac42aedu64, 0x53380d139d95b3dfu64,
0x650a73548baf63deu64, 0x766a0abb3c77b2a8u64, 0x81c2c92e47edaee6u64, 0x92722c851482353bu64,
0xa2bfe8a14cf10364u64, 0xa81a664bbc423001u64, 0xc24b8b70d0f89791u64, 0xc76c51a30654be30u64,
0xd192e819d6ef5218u64, 0xd69906245565a910u64, 0xf40e35855771202au64, 0x106aa07032bbd1b8u64,
0x19a4c116b8d2d0c8u64, 0x1e376c085141ab53u64, 0x2748774cdf8eeb99u64, 0x34b0bcb5e19b48a8u64,
0x391c0cb3c5c95a63u64, 0x4ed8aa4ae3418acbu64, 0x5b9cca4f7763e373u64, 0x682e6ff3d6b2b8a3u64,
0x748f82ee5defb2fcu64, 0x78a5636f43172f60u64, 0x84c87814a1f0ab72u64, 0x8cc702081a6439ecu64,
0x90befffa23631e28u64, 0xa4506cebde82bde9u64, 0xbef9a3f7b2c67915u64, 0xc67178f2e372532bu64,
0xca273eceea26619cu64, 0xd186b8c721c0c207u64, 0xeada7dd6cde0eb1eu64, 0xf57d4f7fee6ed178u64,
0x06f067aa72176fbau64, 0x0a637dc5a2c898a6u64, 0x113f9804bef90daeu64, 0x1b710b35131c471bu64,
0x28db77f523047d84u64, 0x32caab7b40c72493u64, 0x3c9ebe0a15c9bebcu64, 0x431d67c49c100d4cu64,
0x4cc5d4becb3e42b6u64, 0x597f299cfc657e2au64, 0x5fcb6fab3ad6faecu64, 0x6c44198c4a475817u64
]
));
const HASH_INIT: Hash = Hash(secret_array!(
U64,
[
0x6a09e667f3bcc908u64,
0xbb67ae8584caa73bu64,
0x3c6ef372fe94f82bu64,
0xa54ff53a5f1d36f1u64,
0x510e527fade682d1u64,
0x9b05688c2b3e6c1fu64,
0x1f83d9abfb41bd6bu64,
0x5be0cd19137e2179u64
]
));
fn sigma(x: U64, i: usize, op: usize) -> U64 {
let mut tmp: U64 = x.rotate_right(OP_TABLE[3 * i + 2]);
if op == 0 {
tmp = x >> OP_TABLE[3 * i + 2]
}
x.rotate_right(OP_TABLE[3 * i]) ^ x.rotate_right(OP_TABLE[3 * i + 1]) ^ tmp
}
fn schedule(block: Block) -> RoundConstantsTable {
let b = block.to_be_U64s();
let mut s = RoundConstantsTable::new();
for i in 0..K_SIZE {
if i < 16 {
s[i] = b[i];
} else {
let t16 = s[i - 16];
let t15 = s[i - 15];
let t7 = s[i - 7];
let t2 = s[i - 2];
let s1 = sigma(t2, 3, 0);
let s0 = sigma(t15, 2, 0);
s[i] = s1 + t7 + s0 + t16;
}
}
s
}
fn shuffle(ws: RoundConstantsTable, hashi: Hash) -> Hash {
let mut h = hashi;
for i in 0..K_SIZE {
let a0 = h[0];
let b0 = h[1];
let c0 = h[2];
let d0 = h[3];
let e0 = h[4];
let f0 = h[5];
let g0 = h[6];
let h0: U64 = h[7];
let t1 = h0 + sigma(e0, 1, 1) + ch(e0, f0, g0) + K_TABLE[i] + ws[i];
let t2 = sigma(a0, 0, 1) + maj(a0, b0, c0);
h[0] = t1 + t2;
h[1] = a0;
h[2] = b0;
h[3] = c0;
h[4] = d0 + t1;
h[5] = e0;
h[6] = f0;
h[7] = g0;
}
h
}
fn compress(block: Block, h_in: Hash) -> Hash {
let s = schedule(block);
let mut h = shuffle(s, h_in);
for i in 0..8 {
h[i] = h[i] + h_in[i];
}
h
}
pub fn hash(msg: &ByteSeq) -> Sha512Digest {
let mut h = HASH_INIT;
// FIXME: #96 use exact_chunks
let mut last_block = Block::new();
let mut last_block_len = 0;
for i in 0..msg.num_chunks(BLOCK_SIZE) {
let (block_len, block) = msg.get_chunk(BLOCK_SIZE, i);
if block_len < BLOCK_SIZE {
last_block = Block::new().update_start(&block);
last_block_len = block_len;
} else {
let compress_input = Block::from_seq(&block);
h = compress(compress_input, h);
}
}
last_block[last_block_len] = U8(0x80u8);
let len_bist = U128((msg.len() * 8) as u128);
if last_block_len < BLOCK_SIZE - LEN_SIZE {
last_block = last_block.update(BLOCK_SIZE - LEN_SIZE, &U128_to_be_bytes(len_bist));
h = compress(last_block, h);
} else {
let mut pad_block = Block::new();
pad_block = pad_block.update(BLOCK_SIZE - LEN_SIZE, &U128_to_be_bytes(len_bist));
h = compress(last_block, h);
h = compress(pad_block, h);
}
Sha512Digest::from_seq(&h.to_be_bytes())
}
pub fn sha512(msg: &ByteSeq) -> Sha512Digest {
hash(msg)
}
|
use super::TextureFormat;
use util::bits::BitField;
#[derive(Copy, Clone)]
pub struct TextureParams(pub u32);
impl TextureParams {
pub fn offset(self) -> u32 { self.0.bits(0,16) << 3 }
pub fn repeat_s(self) -> bool { self.0.bits(16,17) != 0 }
pub fn repeat_t(self) -> bool { self.0.bits(17,18) != 0 }
pub fn mirror_s(self) -> bool { self.0.bits(18,19) != 0 }
pub fn mirror_t(self) -> bool { self.0.bits(19,20) != 0 }
pub fn width(self) -> u32 { 8 << self.0.bits(20,23) }
pub fn height(self) -> u32 { 8 << self.0.bits(23,26) }
pub fn dim(self) -> (u32, u32) { (self.width(), self.height()) }
pub fn format(self) -> TextureFormat { TextureFormat(self.0.bits(26,29) as u8) }
pub fn is_color0_transparent(self) -> bool { self.0.bits(29,30) != 0 }
pub fn texcoord_transform_mode(self) -> u8 { self.0.bits(30,32) as u8 }
}
impl std::fmt::Debug for TextureParams {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.debug_struct("TextureParams")
.field("dim", &(self.width(), self.height()))
.field("format", &self.format().0)
.field("offset", &self.offset())
.field("repeat", &(self.repeat_s(), self.repeat_t()))
.field("mirror", &(self.mirror_s(), self.mirror_t()))
.field("color0_transparent", &self.is_color0_transparent())
.field("texcoord_transform_mode", &self.texcoord_transform_mode())
.finish()
}
}
|
// Copyright 2018-2019 Mozilla
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
use std::{
fmt::{Debug, Display},
path::{Path, PathBuf},
};
use crate::{
backend::common::{DatabaseFlags, EnvironmentFlags, WriteFlags},
error::StoreError,
};
pub trait BackendError: Debug + Display + Into<StoreError> {}
pub trait BackendDatabase: Debug + Eq + PartialEq + Copy + Clone {}
pub trait BackendFlags: Debug + Eq + PartialEq + Copy + Clone + Default {
fn empty() -> Self;
}
pub trait BackendEnvironmentFlags: BackendFlags {
fn set(&mut self, flag: EnvironmentFlags, value: bool);
}
pub trait BackendDatabaseFlags: BackendFlags {
fn set(&mut self, flag: DatabaseFlags, value: bool);
}
pub trait BackendWriteFlags: BackendFlags {
fn set(&mut self, flag: WriteFlags, value: bool);
}
pub trait BackendStat {
fn page_size(&self) -> usize;
fn depth(&self) -> usize;
fn branch_pages(&self) -> usize;
fn leaf_pages(&self) -> usize;
fn overflow_pages(&self) -> usize;
fn entries(&self) -> usize;
}
pub trait BackendInfo {
fn map_size(&self) -> usize;
fn last_pgno(&self) -> usize;
fn last_txnid(&self) -> usize;
fn max_readers(&self) -> usize;
fn num_readers(&self) -> usize;
}
pub trait BackendEnvironmentBuilder<'b>: Debug + Eq + PartialEq + Copy + Clone {
type Error: BackendError;
type Environment: BackendEnvironment<'b>;
type Flags: BackendEnvironmentFlags;
fn new() -> Self;
fn set_flags<T>(&mut self, flags: T) -> &mut Self
where
T: Into<Self::Flags>;
fn set_max_dbs(&mut self, max_dbs: u32) -> &mut Self;
fn set_max_readers(&mut self, max_readers: u32) -> &mut Self;
fn set_map_size(&mut self, size: usize) -> &mut Self;
fn set_make_dir_if_needed(&mut self, make_dir_if_needed: bool) -> &mut Self;
fn set_discard_if_corrupted(&mut self, discard_if_corrupted: bool) -> &mut Self;
fn open(&self, path: &Path) -> Result<Self::Environment, Self::Error>;
}
pub trait BackendEnvironment<'e>: Debug {
type Error: BackendError;
type Database: BackendDatabase;
type Flags: BackendDatabaseFlags;
type Stat: BackendStat;
type Info: BackendInfo;
type RoTransaction: BackendRoCursorTransaction<'e, Database = Self::Database>;
type RwTransaction: BackendRwCursorTransaction<'e, Database = Self::Database>;
fn get_dbs(&self) -> Result<Vec<Option<String>>, Self::Error>;
fn open_db(&self, name: Option<&str>) -> Result<Self::Database, Self::Error>;
fn create_db(
&self,
name: Option<&str>,
flags: Self::Flags,
) -> Result<Self::Database, Self::Error>;
fn begin_ro_txn(&'e self) -> Result<Self::RoTransaction, Self::Error>;
fn begin_rw_txn(&'e self) -> Result<Self::RwTransaction, Self::Error>;
fn sync(&self, force: bool) -> Result<(), Self::Error>;
fn stat(&self) -> Result<Self::Stat, Self::Error>;
fn info(&self) -> Result<Self::Info, Self::Error>;
fn freelist(&self) -> Result<usize, Self::Error>;
fn load_ratio(&self) -> Result<Option<f32>, Self::Error>;
fn set_map_size(&self, size: usize) -> Result<(), Self::Error>;
fn get_files_on_disk(&self) -> Vec<PathBuf>;
}
pub trait BackendRoTransaction: Debug {
type Error: BackendError;
type Database: BackendDatabase;
fn get(&self, db: &Self::Database, key: &[u8]) -> Result<&[u8], Self::Error>;
fn abort(self);
}
pub trait BackendRwTransaction: Debug {
type Error: BackendError;
type Database: BackendDatabase;
type Flags: BackendWriteFlags;
fn get(&self, db: &Self::Database, key: &[u8]) -> Result<&[u8], Self::Error>;
fn put(
&mut self,
db: &Self::Database,
key: &[u8],
value: &[u8],
flags: Self::Flags,
) -> Result<(), Self::Error>;
#[cfg(not(feature = "db-dup-sort"))]
fn del(&mut self, db: &Self::Database, key: &[u8]) -> Result<(), Self::Error>;
#[cfg(feature = "db-dup-sort")]
fn del(
&mut self,
db: &Self::Database,
key: &[u8],
value: Option<&[u8]>,
) -> Result<(), Self::Error>;
fn clear_db(&mut self, db: &Self::Database) -> Result<(), Self::Error>;
fn commit(self) -> Result<(), Self::Error>;
fn abort(self);
}
pub trait BackendRoCursorTransaction<'t>: BackendRoTransaction {
type RoCursor: BackendRoCursor<'t>;
fn open_ro_cursor(&'t self, db: &Self::Database) -> Result<Self::RoCursor, Self::Error>;
}
pub trait BackendRwCursorTransaction<'t>: BackendRwTransaction {
type RoCursor: BackendRoCursor<'t>;
fn open_ro_cursor(&'t self, db: &Self::Database) -> Result<Self::RoCursor, Self::Error>;
}
pub trait BackendRoCursor<'c>: Debug {
type Iter: BackendIter<'c>;
fn into_iter(self) -> Self::Iter;
fn into_iter_from<K>(self, key: K) -> Self::Iter
where
K: AsRef<[u8]> + 'c;
fn into_iter_dup_of<K>(self, key: K) -> Self::Iter
where
K: AsRef<[u8]> + 'c;
}
pub trait BackendIter<'i> {
type Error: BackendError;
#[allow(clippy::type_complexity)]
fn next(&mut self) -> Option<Result<(&'i [u8], &'i [u8]), Self::Error>>;
}
|
static FILENAME: &str = "input/data";
#[derive(Debug, Clone, PartialEq)]
enum Operation {
Add,
Multiply,
Number(usize),
Parenthesis(bool),
}
fn main() {
let data = std::fs::read_to_string(FILENAME).expect("could not read file");
let ops = parse(&data);
println!("part one: {}", part_one(&ops));
}
fn part_one(ops: &Vec<Vec<Operation>>) -> usize {
let mut sum = 0;
for op in ops {
let res = calc(0, op);
sum += res.1;
}
sum
}
fn calc(ix: usize, ops: &Vec<Operation>) -> (usize, usize) {
let mut sum = 0;
let mut op = Operation::Add;
let mut skip = 0;
let mut count = 0;
for x in ix..ops.len() {
match ops.get(x + skip) {
Some(v) => match v {
Operation::Add => op = Operation::Add,
Operation::Multiply => op = Operation::Multiply,
Operation::Number(n) => match op {
Operation::Add => {
sum += n;
}
Operation::Multiply => {
sum *= n;
}
_ => {}
},
Operation::Parenthesis(first) => {
if *first {
match op {
Operation::Add => {
let res = calc(x + skip + 1, ops);
skip += res.0;
sum += res.1;
}
Operation::Multiply => {
let res = calc(x + skip + 1, ops);
skip += res.0;
sum *= res.1;
}
_ => {}
}
} else {
return (count + skip + 1, sum);
}
}
},
None => {}
}
count += 1;
}
(0, sum)
}
fn parse(data: &str) -> Vec<Vec<Operation>> {
let mut matrix = Vec::new();
for line in data.lines() {
let mut ops = Vec::new();
let mut current_val = 0;
for c in line.chars() {
match c {
'(' => ops.push(Operation::Parenthesis(true)),
')' => {
if current_val > 0 {
ops.push(Operation::Number(current_val));
current_val = 0;
}
ops.push(Operation::Parenthesis(false));
}
'*' => ops.push(Operation::Multiply),
'+' => ops.push(Operation::Add),
'\n' | ' ' => {
if current_val > 0 {
ops.push(Operation::Number(current_val));
current_val = 0;
}
}
_ => {
current_val = if current_val > 0 {
current_val * 10 + (c.to_digit(10).unwrap() as usize)
} else {
c.to_digit(10).unwrap() as usize
};
}
}
}
if current_val > 0 {
ops.push(Operation::Number(current_val));
}
matrix.push(ops);
}
matrix
}
mod tests {
#[test]
fn test_part_one() {
let data = std::fs::read_to_string(super::FILENAME).expect("could not read file");
let ops = super::parse(&data);
assert_eq!(464478013511, super::part_one(&ops));
}
}
|
use std::collections::{HashMap, HashSet};
use irc::conn::Conn;
#[deriving(Clone, PartialEq)]
pub enum ChannelType {
Moderate, // we mod this channel
Control // we are controlled here
}
#[deriving(Clone)]
pub struct IRCChannel {
name: String,
chantype: ChannelType,
nicks: HashSet<String>,
joined: bool,
stopword: Option<String>
}
/// keeps track of all the channels we're in,
/// as well as nicks in them.
pub struct ChannelManager {
channels: HashMap<String, IRCChannel>
}
impl ChannelManager {
pub fn new_blank() -> ChannelManager {
ChannelManager { channels: HashMap::new() }
}
pub fn new() -> ChannelManager {
let mut mgr = ChannelManager::new_blank();
mgr.add_channel("#r/globaloffensive", Moderate);
mgr.add_channel("#gobotmods", Control);
mgr
}
/// Adds a channel to the list.
pub fn add_channel(&mut self, name: &str, chantype: ChannelType) {
self.channels.insert(name.to_string(), IRCChannel::new(name, chantype));
}
/// Joins any channels we are not already in.
/// Note this does not mark the channels as joined,
/// as we need confirmation from the server.
pub fn join_channels(&self, conn: &mut Conn) {
for (name, _) in self.channels.iter().filter(|&(_, c)| !c.joined) {
conn.join(name.as_slice().as_bytes(), [])
}
}
pub fn find<'a>(&'a self, name: &str) -> Option<&'a IRCChannel> {
self.channels.find_equiv(&name)
}
pub fn find_mut<'a>(&'a mut self, name: &str) -> Option<&'a mut IRCChannel> {
self.channels.mut_iter().find(|&(ref k, _)| k.as_slice() == name).map(|(_, v)| v)
}
pub fn log_to_control_channels(&self, conn: &mut Conn, msg: &str) {
self.log_to_control_channels_bytes(conn, msg.as_bytes());
}
/// Prints a raw slice of bytes to all control channels.
pub fn log_to_control_channels_bytes(&self, conn: &mut Conn, msg: &[u8]) {
for (name, _) in self.channels.iter().filter(|&(_, s)| s.chantype == Control) {
conn.privmsg(name.as_slice().as_bytes(), msg);
}
}
/// Is a given nick in any control channels? (etc. a mod)
pub fn nick_is_mod(&self, nick: &str) -> bool {
for (_, chan) in self.channels.iter().filter(|&(_, s)| s.chantype == Control) {
if chan.contains_nick(nick) {
return true;
}
}
false
}
}
impl IRCChannel {
fn new(name: &str, chantype: ChannelType) -> IRCChannel {
IRCChannel {
name: name.to_string(),
chantype: chantype,
nicks: HashSet::new(),
joined: false,
stopword: None
}
}
/// We have successfully joined a channel! Hooray!
pub fn join_ok(&mut self) {
self.joined = true
}
/// Handles somebody else (NOT us) joining a channel.
pub fn handle_join(&mut self, nick: &str) {
self.nicks.insert(nick.to_string());
}
/// Handles somebody else (NOT us) leaving a channel.
pub fn handle_part(&mut self, nick: &str) {
match self.nicks.remove(&nick.to_string()) {
true => (),
false => error!("{} parted from {}, but was never in nicks!", self.name, nick)
}
}
pub fn contains_nick(&self, nick: &str) -> bool {
self.nicks.contains_equiv(&nick)
}
pub fn get_stopword<'a>(&'a self) -> Option<&'a str> {
match self.stopword {
Some(ref sw) => Some(sw.as_slice()),
None => None
}
}
pub fn set_stopword<'a>(&mut self, stopword: Option<String>) {
self.stopword = stopword;
}
}
#[cfg(test)]
mod test {
use super::{IRCChannel, Moderate};
#[test]
fn nick_tracking() {
let test_nick = "fredbloggs";
let mut chan = IRCChannel::new("#test", Moderate);
assert!(!chan.contains_nick(test_nick));
chan.handle_join(test_nick);
assert!(chan.contains_nick(test_nick));
chan.handle_part(test_nick);
assert!(!chan.contains_nick(test_nick));
}
/// Multiple joins should not stack
#[test]
fn duplicate_nicks() {
let test_nick = "fredbloggs";
let mut chan = IRCChannel::new("#test", Moderate);
for _ in range(0u, 10) {
chan.handle_join(test_nick);
}
assert!(chan.contains_nick(test_nick));
chan.handle_part(test_nick);
assert!(!chan.contains_nick(test_nick));
}
}
|
use handlegraph::packedgraph::{iter::EdgeListHandleIter, nodes::IndexMapIter};
use rhai::plugin::*;
use handlegraph::{
handle::{Direction, Handle, NodeId},
handlegraph::*,
pathhandlegraph::*,
};
use handlegraph::packedgraph::{paths::StepPtr, PackedGraph};
use std::sync::Arc;
#[derive(Clone)]
pub struct HandlesIter {
graph: Arc<PackedGraph>,
iter: NodeIdHandles<IndexMapIter<'static>>,
}
impl HandlesIter {
pub fn new(graph: Arc<PackedGraph>) -> Self {
let iter: NodeIdHandles<IndexMapIter<'_>> = graph.handles();
let ridiculous = unsafe {
std::mem::transmute::<
NodeIdHandles<IndexMapIter<'_>>,
NodeIdHandles<IndexMapIter<'static>>,
>(iter)
};
Self {
graph,
iter: ridiculous,
}
}
}
impl Iterator for HandlesIter {
type Item = Handle;
#[inline]
fn next(&mut self) -> Option<Handle> {
self.iter.next()
}
}
use handlegraph::packedgraph::occurrences::OccurrencesIter;
#[derive(Clone)]
pub struct OccursIter {
graph: Arc<PackedGraph>,
iter: OccurrencesIter<'static>,
}
impl OccursIter {
pub fn new(graph: Arc<PackedGraph>, handle: Handle) -> Option<Self> {
let iter_ = graph.steps_on_handle(handle)?;
let iter = unsafe {
std::mem::transmute::<OccurrencesIter<'_>, OccurrencesIter<'static>>(
iter_,
)
};
Some(Self { graph, iter })
}
}
impl Iterator for OccursIter {
type Item = (PathId, StepPtr);
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
#[derive(Clone)]
pub struct NeighborsIter {
graph: Arc<PackedGraph>,
iter: EdgeListHandleIter<'static>,
}
impl NeighborsIter {
pub fn new(
graph: Arc<PackedGraph>,
handle: Handle,
dir: Direction,
) -> Self {
let iter_ = graph.neighbors(handle, dir);
let iter = unsafe {
std::mem::transmute::<
EdgeListHandleIter<'_>,
EdgeListHandleIter<'static>,
>(iter_)
};
Self { graph, iter }
}
}
impl Iterator for NeighborsIter {
type Item = Handle;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
#[export_module]
pub mod handle_plugin {
#[rhai_fn(name = "handle")]
pub fn handle_from_i64(id: i64, reverse: bool) -> Handle {
Handle::pack(id as u64, reverse)
}
#[rhai_fn(name = "handle")]
pub fn handle_from_node_id(id: NodeId, reverse: bool) -> Handle {
Handle::pack(id.0, reverse)
}
#[rhai_fn(pure, get = "id")]
pub fn id(handle: &mut Handle) -> NodeId {
handle.id()
}
#[rhai_fn(pure, get = "is_reverse")]
pub fn is_reverse(handle: &mut Handle) -> bool {
handle.is_reverse()
}
#[rhai_fn(pure)]
pub fn flip(handle: &mut Handle) -> Handle {
handle.flip()
}
#[rhai_fn(pure)]
pub fn forward(handle: &mut Handle) -> Handle {
handle.forward()
}
}
pub type Step = (PathId, StepPtr);
#[export_module]
pub mod graph_iters {
#[rhai_fn(pure)]
pub fn handles(graph: &mut Arc<PackedGraph>) -> HandlesIter {
let graph_arc: Arc<PackedGraph> = graph.clone();
HandlesIter::new(graph_arc)
}
#[rhai_fn(pure)]
pub fn steps_on_handle(
graph: &mut Arc<PackedGraph>,
handle: Handle,
) -> OccursIter {
let graph_arc: Arc<PackedGraph> = graph.clone();
OccursIter::new(graph_arc, handle).unwrap()
}
#[rhai_fn(pure)]
pub fn neighbors_forward(
graph: &mut Arc<PackedGraph>,
handle: Handle,
) -> NeighborsIter {
let graph_arc: Arc<PackedGraph> = graph.clone();
NeighborsIter::new(graph_arc, handle, Direction::Right)
}
#[rhai_fn(pure)]
pub fn neighbors_backward(
graph: &mut Arc<PackedGraph>,
handle: Handle,
) -> NeighborsIter {
let graph_arc: Arc<PackedGraph> = graph.clone();
NeighborsIter::new(graph_arc, handle, Direction::Left)
}
#[rhai_fn(pure, get = "path_id")]
pub fn occur_path_id(occur: &mut Step) -> PathId {
let path = occur.0;
path
}
#[rhai_fn(pure, get = "step_ix")]
pub fn occur_step_ix(occur: &mut Step) -> StepPtr {
occur.1
}
pub fn unwrap_path_id(path: PathId) -> i64 {
path.0 as i64
}
}
#[export_module]
pub mod paths_plugin {
#[rhai_fn(pure, name = "path_len")]
pub fn path_len(graph: &mut Arc<PackedGraph>, path: PathId) -> usize {
graph.path_len(path).unwrap_or(0)
}
#[rhai_fn(pure, name = "path_len")]
pub fn path_len_i32(graph: &mut Arc<PackedGraph>, path: i32) -> usize {
path_len(graph, PathId(path as u64))
}
#[rhai_fn(pure, name = "path_len")]
pub fn path_len_i64(graph: &mut Arc<PackedGraph>, path: i64) -> usize {
path_len(graph, PathId(path as u64))
}
#[rhai_fn(pure, return_raw)]
pub fn path_first_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
) -> std::result::Result<StepPtr, Box<EvalAltResult>> {
graph.path_first_step(path).ok_or("Path not found".into())
}
#[rhai_fn(pure, return_raw)]
pub fn path_last_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
) -> std::result::Result<StepPtr, Box<EvalAltResult>> {
graph.path_last_step(path).ok_or("Path not found".into())
}
#[rhai_fn(pure, return_raw)]
pub fn path_handle_at_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
step: StepPtr,
) -> std::result::Result<Handle, Box<EvalAltResult>> {
graph
.path_handle_at_step(path, step)
.ok_or("Path or step not found".into())
}
#[rhai_fn(pure)]
pub fn has_next_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
step: StepPtr,
) -> bool {
graph.path_next_step(path, step).is_some()
}
#[rhai_fn(pure)]
pub fn has_prev_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
step: StepPtr,
) -> bool {
graph.path_prev_step(path, step).is_some()
}
#[rhai_fn(pure, return_raw)]
pub fn next_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
step: StepPtr,
) -> std::result::Result<StepPtr, Box<EvalAltResult>> {
graph
.path_next_step(path, step)
.ok_or("Step not found".into())
}
#[rhai_fn(pure, return_raw)]
pub fn prev_step(
graph: &mut Arc<PackedGraph>,
path: PathId,
step: StepPtr,
) -> std::result::Result<StepPtr, Box<EvalAltResult>> {
graph
.path_prev_step(path, step)
.ok_or("Step not found".into())
}
}
#[export_module]
pub mod graph_plugin {
#[rhai_fn(pure)]
pub fn node_count(graph: &mut Arc<PackedGraph>) -> usize {
graph.node_count()
}
#[rhai_fn(pure)]
pub fn edge_count(graph: &mut Arc<PackedGraph>) -> usize {
graph.edge_count()
}
#[rhai_fn(pure)]
pub fn path_count(graph: &mut Arc<PackedGraph>) -> usize {
graph.path_count()
}
#[rhai_fn(pure)]
pub fn total_length(graph: &mut Arc<PackedGraph>) -> usize {
graph.total_length()
}
#[rhai_fn(pure)]
pub fn min_node_id(graph: &mut Arc<PackedGraph>) -> NodeId {
graph.min_node_id()
}
#[rhai_fn(pure)]
pub fn max_node_id(graph: &mut Arc<PackedGraph>) -> NodeId {
graph.max_node_id()
}
#[rhai_fn(pure)]
pub fn sequence(graph: &mut Arc<PackedGraph>, handle: Handle) -> Vec<u8> {
graph.sequence_vec(handle)
}
// `PathId` can't (and shouldn't be able to) be created in
// isolation by the console, meaning all instances of `path` here
// must be valid path identifiers in a graph, and because we only
// have one graph, they must always refer to valid paths in the
// provided graph
#[rhai_fn(pure)]
pub fn get_path_name(graph: &mut Arc<PackedGraph>, path: PathId) -> String {
use bstr::ByteSlice;
let name_vec = graph.get_path_name_vec(path).unwrap();
format!("{}", name_vec.as_bstr())
}
#[rhai_fn(pure, return_raw)]
pub fn get_path_id(
graph: &mut Arc<PackedGraph>,
path_name: &str,
) -> std::result::Result<PathId, Box<EvalAltResult>> {
graph
.get_path_id(path_name.as_bytes())
.ok_or("Path not found".into())
}
#[rhai_fn(pure)]
pub fn get_path_ids_by_prefix(
graph: &mut Arc<PackedGraph>,
path_name_prefix: &str,
) -> Vec<rhai::Dynamic> {
use bstr::ByteSlice;
let graph: &PackedGraph = graph.as_ref();
let mut result: Vec<rhai::Dynamic> = Vec::new();
let path_name_prefix = path_name_prefix.as_bytes();
let mut path_name_buf: Vec<u8> = Vec::new();
for path_id in graph.path_ids() {
if let Some(path_name) = graph.get_path_name(path_id) {
path_name_buf.clear();
path_name_buf.extend(path_name);
if path_name_buf.starts_with(path_name_prefix) {
result.push(rhai::Dynamic::from(path_id));
}
}
}
result
}
#[rhai_fn(pure)]
pub fn get_path_names_by_prefix(
graph: &mut Arc<PackedGraph>,
path_name_prefix: &str,
) -> Vec<rhai::Dynamic> {
use bstr::ByteSlice;
let graph: &PackedGraph = graph.as_ref();
let mut result: Vec<rhai::Dynamic> = Vec::new();
let path_name_prefix = path_name_prefix.as_bytes();
let mut path_name_buf: Vec<u8> = Vec::new();
for path_id in graph.path_ids() {
if let Some(path_name) = graph.get_path_name(path_id) {
path_name_buf.clear();
path_name_buf.extend(path_name);
if path_name_buf.starts_with(path_name_prefix) {
result.push(rhai::Dynamic::from(format!(
"{}",
path_name_buf.as_bstr()
)));
}
}
}
result
}
}
#[export_module]
pub mod colors {
#[rhai_fn(pure)]
pub fn hash_bytes(bytes: &mut Vec<u8>) -> u64 {
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
let mut hasher = DefaultHasher::default();
bytes.hash(&mut hasher);
let hash = hasher.finish();
bytemuck::cast(hash)
}
pub fn hash_color(hash: u64) -> rgb::RGBA<f32> {
let r_u16 = ((hash >> 32) & 0xFFFFFFFF) as u16;
let g_u16 = ((hash >> 16) & 0xFFFFFFFF) as u16;
let b_u16 = (hash & 0xFFFFFFFF) as u16;
let max = r_u16.max(g_u16).max(b_u16) as f32;
let r = (r_u16 as f32) / max;
let g = (g_u16 as f32) / max;
let b = (b_u16 as f32) / max;
rgb::RGBA::new(r, g, b, 1.0)
}
pub fn rgba(r: f32, g: f32, b: f32, a: f32) -> rgb::RGBA<f32> {
rgb::RGBA::new(r, g, b, a)
}
#[rhai_fn(pure, get = "r")]
pub fn rgba_r(color: &mut rgb::RGBA<f32>) -> f32 {
color.r
}
#[rhai_fn(pure, get = "g")]
pub fn rgba_g(color: &mut rgb::RGBA<f32>) -> f32 {
color.g
}
#[rhai_fn(pure, get = "b")]
pub fn rgba_b(color: &mut rgb::RGBA<f32>) -> f32 {
color.b
}
#[rhai_fn(pure, get = "a")]
pub fn rgba_a(color: &mut rgb::RGBA<f32>) -> f32 {
color.a
}
#[rhai_fn(set = "r")]
pub fn rgba_r_set(color: &mut rgb::RGBA<f32>, v: f32) {
color.r = v;
}
#[rhai_fn(set = "g")]
pub fn rgba_g_set(color: &mut rgb::RGBA<f32>, v: f32) {
color.g = v;
}
#[rhai_fn(set = "b")]
pub fn rgba_b_set(color: &mut rgb::RGBA<f32>, v: f32) {
color.b = v;
}
#[rhai_fn(set = "a")]
pub fn rgba_a_set(color: &mut rgb::RGBA<f32>, v: f32) {
color.a = v;
}
pub fn rgba_as_tuple(color: &mut rgb::RGBA<f32>) -> (f32, f32, f32, f32) {
(color.r, color.g, color.b, color.a)
}
pub fn rgb(r: f32, g: f32, b: f32) -> rgb::RGB<f32> {
rgb::RGB::new(r, g, b)
}
#[rhai_fn(pure, get = "r")]
pub fn rgb_r(color: &mut rgb::RGB<f32>) -> f32 {
color.r
}
#[rhai_fn(pure, get = "g")]
pub fn rgb_g(color: &mut rgb::RGB<f32>) -> f32 {
color.g
}
#[rhai_fn(pure, get = "b")]
pub fn rgb_b(color: &mut rgb::RGB<f32>) -> f32 {
color.b
}
#[rhai_fn(set = "r")]
pub fn rgb_r_set(color: &mut rgb::RGB<f32>, v: f32) {
color.r = v;
}
#[rhai_fn(set = "g")]
pub fn rgb_g_set(color: &mut rgb::RGB<f32>, v: f32) {
color.g = v;
}
#[rhai_fn(set = "b")]
pub fn rgb_b_set(color: &mut rgb::RGB<f32>, v: f32) {
color.b = v;
}
pub fn rgb_as_tuple(color: &mut rgb::RGB<f32>) -> (f32, f32, f32) {
(color.r, color.g, color.b)
}
}
#[export_module]
pub mod selection {
use crate::app::selection::NodeSelection;
#[rhai_fn(pure)]
pub fn union(
first: &mut NodeSelection,
other: NodeSelection,
) -> NodeSelection {
first.union(&other)
}
#[rhai_fn(pure)]
pub fn intersection(
first: &mut NodeSelection,
other: NodeSelection,
) -> NodeSelection {
first.intersection(&other)
}
#[rhai_fn(pure)]
pub fn difference(
first: &mut NodeSelection,
other: NodeSelection,
) -> NodeSelection {
first.difference(&other)
}
pub fn add_one(sel: &mut NodeSelection, node: NodeId) {
sel.add_one(false, node);
}
pub fn add_array(sel: &mut NodeSelection, nodes: Vec<NodeId>) {
sel.add_slice(false, &nodes);
}
#[rhai_fn(pure)]
pub fn len(sel: &mut NodeSelection) -> i64 {
sel.nodes.len() as i64
}
}
|
use std::sync::Arc;
use crate::libcore::material::Material;
use crate::math::Point3;
use crate::math::Ray;
use crate::math::Vec3;
pub struct HitRecord<'a> {
pub p: Point3<f64>,
pub normal: Vec3<f64>,
pub t: f64,
pub front_face: bool,
pub material: &'a dyn Material,
}
pub trait Hittable {
fn hit(&self, ray: &Ray, tmin: f64, tmax: f64) -> Option<HitRecord>;
}
impl<'a> HitRecord<'a> {
// pub fn set_face_normal(self, r: &Ray, outward_normal: &Vec3<f64>) -> Self {
// match self {
// HitRecord::Hit {
// front_face, normal, ..
// } => {
// front_face = r.direction.dot(outward_normal) < 0.0;
// normal = if front_face {
// *outward_normal
// } else {
// -(*outward_normal)
// }
// }
// _ => panic!("Cannot set face normal to a ray miss"),
// };
// self
// }
pub fn new_hit(
p: Point3<f64>,
t: f64,
r: &Ray,
outward_normal: &Vec3<f64>,
material: &'a dyn Material,
) -> HitRecord<'a> {
let front_face = r.direction.dot(outward_normal) < 0.0;
let normal = if front_face {
*outward_normal
} else {
-(*outward_normal)
};
HitRecord {
p,
t,
normal,
front_face,
material,
}
}
}
|
pub mod comment;
pub mod post;
pub mod requests;
pub mod rights;
pub mod user;
pub use comment::*;
pub use post::*;
pub use requests::*;
pub use rights::*;
pub use user::*;
|
use num_traits::PrimInt;
/// 1ใใnใพใงใฎ็ทๅใ็ฎๅบใใ
pub fn sum_one_to_n<T: PrimInt>(n: T) -> i32 {
let n: i32 = n.to_i32().unwrap();
if n <= 0 {
panic!("n is not natural number.");
}
if n == 1 {
1
} else {
n + sum_one_to_n(n - 1)
}
}
/// ๆๅฐๅ
ฌ็ดๆฐ
pub fn lcm(a: i32, b: i32) -> i32 {
if a < 1 || b < 1 {
panic!("a or b is not natural number.");
}
(a * b) / gcd(a, b)
}
/// ๆๅคงๅ
ฌ็ดๆฐ
pub fn gcd(a: i32, b: i32) -> i32 {
if a < 1 || b < 1 {
panic!("a or b is not natural number.");
}
gcd_recrusive(max(a, b), min(a, b))
}
/// ใฆใผใฏใชใใใฎไบ้คๆณ
fn gcd_recrusive(a: i32, b: i32) -> i32 {
let c = a % b;
if c == 0 {
b
} else {
gcd_recrusive(min(a, b), c)
}
}
/// ๅฐใใๆนใ่ฟใ
pub fn min(a: i32, b: i32) -> i32 {
if a < b {
a
} else {
b
}
}
/// ๅคงใใๆนใ่ฟใ
pub fn max(a: i32, b: i32) -> i32 {
if a > b {
a
} else {
b
}
}
/// ็ตถๅฏพๅคใ่ฟใ
pub fn abs(x: i32) -> i32 {
if x < 0 {
-x
} else {
x
}
}
// n!ใ่ฟใ
pub fn factorial(n: i32) -> i32 {
if n < 0 {
panic!("n is not integer.");
}
if n == 0 {
return 1;
}
let mut result = n;
for i in 1..n {
result *= i;
}
result
}
// x^yใ่ฟใ
pub fn pow(x: i32, y: u32) -> i32 {
if y == 0 {
return 1;
}
let mut dst = 1;
for _ in 0..y {
dst *= x;
}
dst
} |
//! Improving Our I/O Project with [Iterator]
//!
//! [iterator]: https://doc.rust-lang.org/book/ch13-03-improving-our-io-project.html
use std::env;
use std::fs;
use std::process;
use the_book::ch13::sec03::{search, Config};
fn main() {
// parse the command line.
let c = Config::new(env::args()).unwrap_or_else(|err| {
eprintln!("{}", err);
process::exit(1);
});
// read the contents from the file.
let contents = fs::read_to_string(c.filename()).unwrap_or_else(|err| {
eprintln!("{}: {}", c.filename(), err);
process::exit(1);
});
// search for the query string.
for line in search(c.query(), &contents) {
println!("{}", line);
}
}
|
fn is_valid(num: i64, previous: &[i64]) -> bool {
previous.iter()
.flat_map(|i| previous.iter().map(move |j| (i,j)))
.find_map(|(i,j)| {
if (i != j) && (i + j == num) {
Some(true)
} else {
None
}
})
.unwrap_or(false)
}
fn first_invalid(sequence: &[i64], trailing: usize) -> Option<i64> {
for i in trailing..sequence.len() {
let previous = &sequence[i-trailing..i];
if !is_valid(sequence[i], previous) {
return Some(sequence[i])
}
}
None
}
fn find_cont_sum<'a>(target: i64, sequence: &'a [i64]) -> &'a [i64] {
for i in 0..sequence.len() {
let mut j = i;
let mut total = 0;
while total < target {
total += sequence[j];
if total == target {
return &sequence[i..j];
}
j += 1;
}
}
return &sequence[0..0];
}
fn find_weakness(sequence: &[i64], trailing: usize) -> i64 {
let invalid = first_invalid(sequence, trailing).expect("no invalid");
let cont_seq = find_cont_sum(invalid, sequence);
let min = cont_seq.iter().min().expect("some sequence");
let max = cont_seq.iter().max().expect("some sequence");
min + max
}
fn parse_input(input: &str) -> Vec<i64> {
input.lines()
.map(|s| s.trim().parse::<i64>().expect("int input"))
.collect()
}
fn main() {
let test_input = "\
35
20
15
25
47
40
62
55
65
95
102
117
150
182
127
219
299
277
309
576";
println!("is valid {:?}", is_valid(10, &[1,2,6,3,4,5]));
let test_input = parse_input(&test_input);
println!("first invalid in test: {}", first_invalid(&test_input, 5).expect("no invalid"));
let real_input = parse_input(&include_str!("day9.txt"));
println!("first invalid in real: {}", first_invalid(&real_input, 25).expect("no invalid"));
println!("weakness in test: {}", find_weakness(&test_input, 5));
println!("weakness in real: {}", find_weakness(&real_input, 25));
} |
mod args;
mod stream;
pub use args::Args;
pub use stream::Stream;
|
use std::collections::HashMap;
// TODO: Needs Improvement
struct LRUCache {
map: HashMap<i32, i32>,
key_age: Vec<(i32, usize)>,
capacity: usize,
timestamp: usize,
}
impl LRUCache {
fn new(capacity: i32) -> Self {
Self {
map: HashMap::new(),
key_age: Vec::new(),
capacity: capacity as usize,
timestamp: 0,
}
}
fn get(&mut self, key: i32) -> i32 {
match self.map.get(&key) {
Some(v) => {
for i in 0..self.key_age.len() {
if self.key_age[i].0 == key {
self.key_age[i].1 = self.timestamp;
break
}
}
self.timestamp += 1;
self.key_age.sort_by_key(|&(_, age)| age);
*v
},
None => -1,
}
}
fn put(&mut self, key: i32, value: i32) {
if let Some(v) = self.map.get_mut(&key) {
*v = value;
for i in 0..self.key_age.len() {
if self.key_age[i].0 == key {
self.key_age[i].1 = self.timestamp;
break
}
}
self.timestamp += 1;
self.key_age.sort_by_key(|&(_, age)| age);
} else {
if self.key_age.len() >= self.capacity {
let (k, _) = self.key_age.remove(0);
self.map.remove(&k);
}
self.key_age.push((key, self.timestamp));
self.map.insert(key, value);
self.timestamp += 1;
}
}
} |
mod event;
mod reader;
mod writer;
pub use event::HttpEvent;
pub use reader::{ReaderError, Reader as EventReader};
pub use writer::{WriterError, Writer as EventWriter};
pub const CE_ID_HEADER: &str = "ce-id";
pub const CE_TYPE_HEADER: &str = "ce-type";
pub const CE_SOURCE_HEADER: &str = "ce-source";
pub const CE_SPECVERSION_HEADER: &str = "ce-specversion";
pub const CE_SUBJECT_HEADER: &str = "ce-subject";
pub const CE_TIME_HEADER: &str = "ce-time";
pub const CE_JSON_CONTENT_TYPE: &str = "application/cloudevents+json";
pub const CE_BATCH_JSON_CONTENT_TYPE: &str = "application/cloudevents-batch+json";
|
// 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::{
errors::{utils::check_slice_size, InternalPakeError, PakeError, ProtocolError},
keypair::{Key, KeyPair, SizedBytes},
};
use generic_array::GenericArray;
use hkdf::Hkdf;
use hmac::{Hmac, Mac};
use rand_core::{CryptoRng, RngCore};
use sha2::{Digest, Sha256};
use std::convert::TryFrom;
/// This module is a somewhat minimalistic implementation of a key Exchange
/// protocol based on 3DH. It assumes a pre-exchange has allowed client and
/// server to learn each other's static public key.
///
/// This private module may undergo significant changes in the near term.
const KEY_LEN: usize = 32;
pub(crate) const NONCE_LEN: usize = 32;
pub(crate) const KE1_STATE_LEN: usize = KEY_LEN + KEY_LEN + NONCE_LEN;
pub(crate) const KE2_MESSAGE_LEN: usize = NONCE_LEN + 2 * KEY_LEN;
static STR_3DH: &[u8] = b"3DH keys";
pub(crate) struct KE1State {
client_e_sk: Key,
client_nonce: Vec<u8>,
hashed_l1: Vec<u8>,
}
pub(crate) struct KE1Message {
pub(crate) client_nonce: Vec<u8>,
pub(crate) client_e_pk: Key,
}
impl TryFrom<&[u8]> for KE1State {
type Error = ProtocolError;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
let checked_bytes = check_slice_size(bytes, KE1_STATE_LEN, "ke1_state")?;
Ok(Self {
client_e_sk: Key::from_bytes(&checked_bytes[..KEY_LEN])?,
client_nonce: checked_bytes[KEY_LEN..KEY_LEN + NONCE_LEN].to_vec(),
hashed_l1: checked_bytes[KEY_LEN + NONCE_LEN..].to_vec(),
})
}
}
impl KE1State {
pub fn to_bytes(&self) -> Vec<u8> {
let output: Vec<u8> = [
&self.client_e_sk.to_arr(),
&self.client_nonce[..],
&self.hashed_l1[..],
]
.concat();
output
}
}
impl KE1Message {
pub fn to_bytes(&self) -> Vec<u8> {
[&self.client_nonce[..], &self.client_e_pk.to_arr()].concat()
}
}
impl TryFrom<&[u8]> for KE1Message {
type Error = ProtocolError;
fn try_from(ke1_message_bytes: &[u8]) -> Result<Self, Self::Error> {
let checked_bytes =
check_slice_size(ke1_message_bytes, NONCE_LEN + KEY_LEN, "ke1_message")?;
Ok(Self {
client_nonce: checked_bytes[..NONCE_LEN].to_vec(),
client_e_pk: Key::from_bytes(&checked_bytes[NONCE_LEN..])?,
})
}
}
pub(crate) fn generate_ke1<R: RngCore + CryptoRng, KeyFormat: KeyPair<Repr = Key>>(
l1_component: Vec<u8>,
rng: &mut R,
) -> Result<(KE1State, KE1Message), ProtocolError> {
let client_e_kp = KeyFormat::generate_random(rng)?;
let mut client_nonce = [0u8; NONCE_LEN];
rng.fill_bytes(&mut client_nonce);
let ke1_message = KE1Message {
client_nonce: client_nonce.to_vec(),
client_e_pk: client_e_kp.public().clone(),
};
let l1_data: Vec<u8> = [&l1_component[..], &ke1_message.to_bytes()].concat();
let mut hasher = Sha256::new();
hasher.input(&l1_data);
let hashed_l1 = hasher.result();
Ok((
KE1State {
client_e_sk: client_e_kp.private().clone(),
client_nonce: client_nonce.to_vec(),
hashed_l1: hashed_l1.to_vec(),
},
ke1_message,
))
}
pub(crate) struct KE2State {
km3: Vec<u8>,
hashed_transcript: Vec<u8>,
shared_secret: Vec<u8>,
}
pub(crate) struct KE2Message {
server_nonce: Vec<u8>,
server_e_pk: Key,
mac: Vec<u8>,
}
impl KE2State {
pub fn to_bytes(&self) -> Vec<u8> {
let output: Vec<u8> = [
&self.km3[..],
&self.hashed_transcript[..],
&self.shared_secret[..],
]
.concat();
output
}
}
impl TryFrom<&[u8]> for KE2State {
type Error = ProtocolError;
fn try_from(ke1_message_bytes: &[u8]) -> Result<Self, Self::Error> {
let checked_bytes = check_slice_size(ke1_message_bytes, 3 * KEY_LEN, "ke2_state")?;
Ok(Self {
km3: checked_bytes[..KEY_LEN].to_vec(),
hashed_transcript: checked_bytes[KEY_LEN..2 * KEY_LEN].to_vec(),
shared_secret: checked_bytes[2 * KEY_LEN..].to_vec(),
})
}
}
impl KE2Message {
pub fn to_bytes(&self) -> Vec<u8> {
let output: Vec<u8> = [
&self.server_nonce[..],
&self.server_e_pk.to_arr(),
&self.mac[..],
]
.concat();
output
}
}
impl TryFrom<&[u8]> for KE2Message {
type Error = ProtocolError;
fn try_from(ke1_message_bytes: &[u8]) -> Result<Self, Self::Error> {
let checked_bytes = check_slice_size(ke1_message_bytes, KE2_MESSAGE_LEN, "ke2_message")?;
Ok(Self {
server_nonce: checked_bytes[..NONCE_LEN].to_vec(),
server_e_pk: Key::from_bytes(&checked_bytes[NONCE_LEN..NONCE_LEN + KEY_LEN])?,
mac: checked_bytes[NONCE_LEN + KEY_LEN..].to_vec(),
})
}
}
// The triple of public and private components used in the 3DH computation
struct TripleDHComponents {
pk1: Key,
sk1: Key,
pk2: Key,
sk2: Key,
pk3: Key,
sk3: Key,
}
// Consists of a shared secret, followed by two mac keys
type TripleDHDerivationResult = (
GenericArray<u8, <Sha256 as Digest>::OutputSize>,
GenericArray<u8, <Sha256 as Digest>::OutputSize>,
GenericArray<u8, <Sha256 as Digest>::OutputSize>,
);
// Internal function which takes the public and private components of the client and server keypairs, along
// with some auxiliary metadata, to produce the shared secret and two MAC keys
fn derive_3dh_keys<KeyFormat: KeyPair<Repr = Key>>(
dh: TripleDHComponents,
client_nonce: &[u8],
server_nonce: &[u8],
client_s_pk: KeyFormat::Repr,
server_s_pk: KeyFormat::Repr,
) -> Result<TripleDHDerivationResult, ProtocolError> {
let ikm: Vec<u8> = [
&KeyFormat::diffie_hellman(dh.pk1, dh.sk1)[..],
&KeyFormat::diffie_hellman(dh.pk2, dh.sk2)[..],
&KeyFormat::diffie_hellman(dh.pk3, dh.sk3)[..],
]
.concat();
let info: Vec<u8> = [
STR_3DH,
&client_nonce,
&server_nonce,
&client_s_pk.to_arr(),
&server_s_pk.to_arr(),
]
.concat();
const OUTPUT_SIZE: usize = 32;
let mut okm = [0u8; 3 * OUTPUT_SIZE];
let h = Hkdf::<Sha256>::new(None, &ikm);
h.expand(&info, &mut okm)
.map_err(|_| InternalPakeError::HkdfError)?;
Ok((
*GenericArray::from_slice(&okm[..OUTPUT_SIZE]),
*GenericArray::from_slice(&okm[OUTPUT_SIZE..2 * OUTPUT_SIZE]),
*GenericArray::from_slice(&okm[2 * OUTPUT_SIZE..]),
))
}
pub(crate) fn generate_ke2<R: RngCore + CryptoRng, KeyFormat: KeyPair<Repr = Key>>(
rng: &mut R,
l1_bytes: Vec<u8>,
l2_bytes: Vec<u8>,
client_e_pk: KeyFormat::Repr,
client_s_pk: KeyFormat::Repr,
server_s_sk: KeyFormat::Repr,
client_nonce: Vec<u8>,
) -> Result<(KE2State, KE2Message), ProtocolError> {
let server_e_kp = KeyFormat::generate_random(rng)?;
let mut server_nonce = [0u8; NONCE_LEN];
rng.fill_bytes(&mut server_nonce);
let (shared_secret, km2, km3) = derive_3dh_keys::<KeyFormat>(
TripleDHComponents {
pk1: client_e_pk.clone(),
sk1: server_e_kp.private().clone(),
pk2: client_e_pk,
sk2: server_s_sk.clone(),
pk3: client_s_pk.clone(),
sk3: server_e_kp.private().clone(),
},
&client_nonce,
&server_nonce,
client_s_pk,
KeyFormat::public_from_private(&server_s_sk),
)?;
let mut hasher = Sha256::new();
hasher.input(&l1_bytes);
let hashed_l1 = hasher.result();
let transcript2: Vec<u8> = [
&hashed_l1[..],
&l2_bytes[..],
&server_nonce[..],
&server_e_kp.public().to_arr(),
]
.concat();
let mut hasher2 = Sha256::new();
hasher2.input(&transcript2);
let hashed_transcript = hasher2.result();
let mut mac = Hmac::<Sha256>::new_varkey(&km2).map_err(|_| InternalPakeError::HmacError)?;
mac.input(&hashed_transcript);
Ok((
KE2State {
km3: km3.to_vec(),
hashed_transcript: hashed_transcript.to_vec(),
shared_secret: shared_secret.to_vec(),
},
KE2Message {
server_nonce: server_nonce.to_vec(),
server_e_pk: server_e_kp.public().clone(),
mac: mac.result().code().to_vec(),
},
))
}
pub(crate) struct KE3State {
pub(crate) shared_secret: Vec<u8>,
}
pub(crate) struct KE3Message {
mac: Vec<u8>,
}
impl TryFrom<&[u8]> for KE3State {
type Error = ProtocolError;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
let checked_bytes = check_slice_size(bytes, KEY_LEN, "ke3_state")?;
Ok(Self {
shared_secret: checked_bytes.to_vec(),
})
}
}
impl KE3Message {
pub fn to_bytes(&self) -> Vec<u8> {
self.mac.clone()
}
}
impl TryFrom<&[u8]> for KE3Message {
type Error = ProtocolError;
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
let checked_bytes = check_slice_size(bytes, KEY_LEN, "ke3_message")?;
Ok(Self {
mac: checked_bytes.to_vec(),
})
}
}
pub(crate) fn generate_ke3<KeyFormat: KeyPair<Repr = Key>>(
l2_component: Vec<u8>,
ke2_message: KE2Message,
ke1_state: &KE1State,
server_s_pk: KeyFormat::Repr,
client_s_sk: KeyFormat::Repr,
) -> Result<(KE3State, KE3Message), ProtocolError> {
let (shared_secret, km2, km3) = derive_3dh_keys::<KeyFormat>(
TripleDHComponents {
pk1: ke2_message.server_e_pk.clone(),
sk1: ke1_state.client_e_sk.clone(),
pk2: server_s_pk.clone(),
sk2: ke1_state.client_e_sk.clone(),
pk3: ke2_message.server_e_pk.clone(),
sk3: client_s_sk.clone(),
},
&ke1_state.client_nonce,
&ke2_message.server_nonce,
KeyFormat::public_from_private(&client_s_sk),
server_s_pk,
)?;
let transcript: Vec<u8> = [
&ke1_state.hashed_l1[..],
&l2_component[..],
&ke2_message.server_nonce[..],
&ke2_message.server_e_pk[..],
]
.concat();
let mut hasher = Sha256::new();
hasher.input(&transcript);
let hashed_transcript = hasher.result();
let mut server_mac =
Hmac::<Sha256>::new_varkey(&km2).map_err(|_| InternalPakeError::HmacError)?;
server_mac.input(&hashed_transcript);
if ke2_message.mac != server_mac.result().code().to_vec() {
return Err(ProtocolError::VerificationError(
PakeError::KeyExchangeMacValidationError,
));
}
let mut client_mac =
Hmac::<Sha256>::new_varkey(&km3).map_err(|_| InternalPakeError::HmacError)?;
client_mac.input(&hashed_transcript);
Ok((
KE3State {
shared_secret: shared_secret.to_vec(),
},
KE3Message {
mac: client_mac.result().code().to_vec(),
},
))
}
// Outputs a shared secret
pub(crate) fn finish_ke(
ke3_message: KE3Message,
ke2_state: &KE2State,
) -> Result<Vec<u8>, ProtocolError> {
let mut client_mac =
Hmac::<Sha256>::new_varkey(&ke2_state.km3).map_err(|_| InternalPakeError::HmacError)?;
client_mac.input(&ke2_state.hashed_transcript);
if ke3_message.mac != client_mac.result().code().to_vec() {
return Err(ProtocolError::VerificationError(
PakeError::KeyExchangeMacValidationError,
));
}
Ok(ke2_state.shared_secret.to_vec())
}
|
fn main() {
let proto_root = "../../protobuffers";
println!("cargo:rerun-if-changed={}", proto_root);
protoc_grpcio::compile_grpc_protos(
&["../../protobuffers/buff.proto"],
&[proto_root],
&"src/protobuffers",
None,
)
.expect("Failed to compile gRPC definitions!");
}
|
struct TextDocumentContentChangeEvent {
range: Option<Range>,
rangeLength: Option<i32>,
text: String,
}
struct DidChangeTextDocumentParams {
textDocument: VersionedTextDocumentIdentifier,
contentChanges: Vec<TextDocumentContentChangeEvent>,
}
impl Notification for DidChangeTextDocumentParams {
method = "textDocument/didChange";
}
|
//! Due to limitations in open-gl every image and font is stored in a texture atlas crated upon
//! running the application.
use super::*;
use math::*;
use glium::Rect;
pub fn crate_atlas<D>(
display: &glium::Display,
images: &mut Vec<glium::texture::RawImage2d<D>>,
dimensions: &Vec<Vec2<u32>>
) -> (glium::texture::SrgbTexture2d, Vec<Vec2<f32>>, Vec2<f32>)
where D: Clone + glium::texture::PixelValue
{
const STARTING_DIMENSIONS: Vec2<u32> = Vec2 { x: 256, y: 256 };
let mut atlas_dimensions = STARTING_DIMENSIONS;
// make the dimensions vec hold the indecies of their respective images
let mut dimensions: Vec<(Vec2<u32>, usize)> = dimensions.iter().enumerate().map(|(i, x)| (*x + Vec2::new(5, 5), i)).collect();
dimensions.sort_by(|a, b| b.0.x.min(b.0.y).partial_cmp(&a.0.x.min(a.0.y)).unwrap());
// first calulation
let mut image_rects = calculate_rects(atlas_dimensions, &dimensions);
// if the first calculation failed, try again with a larger atlas size
while image_rects.is_none() {
atlas_dimensions *= 2;
image_rects = calculate_rects(atlas_dimensions, &dimensions);
}
// we know that out atlas calculation went well, so unwrap is fine
let mut image_rects = image_rects.expect("wut");
image_rects.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
// create texture
let texture = glium::texture::SrgbTexture2d::empty(display, atlas_dimensions.x, atlas_dimensions.y).unwrap();
let atlas_dimensions = Vec2::new(atlas_dimensions.x as f32, atlas_dimensions.y as f32);
let image_positions = image_rects.iter().map(|(rect, _)| {
Vec2::new(
rect.left as f32,
rect.bottom as f32
) / atlas_dimensions
}).collect();
// draw the images onto the atlas
for _ in 0..image_rects.len() {
let (mut rect, _) = image_rects.pop().unwrap();
rect.height -= 5;
rect.width -= 5;
texture.write(rect, images.pop().unwrap());
}
(texture, image_positions, atlas_dimensions)
}
fn calculate_rects(
atlas_dimensions: Vec2<u32>,
dimensions: &Vec<(Vec2<u32>, usize)>,
) -> Option<Vec<(Rect, usize)>> {
let mut empty_spaces = vec![Rect { bottom: 0, left: 0, height: atlas_dimensions.y, width: atlas_dimensions.x}];
let mut image_rects = Vec::new();
for (dimensions, image_index) in dimensions {
let space = empty_spaces.iter().enumerate().rev().find(|(_, space)| {
dimensions.x <= space.width && dimensions.y <= space.height
});
if space == None {
return None;
}
let (index, space) = space.unwrap();
image_rects.push(
(
Rect {
left: space.left,
bottom: space.bottom,
width: dimensions.x,
height: dimensions.y,
},
*image_index
)
);
let dw = space.width - dimensions.x;
let dh = space.height - dimensions.y;
if dw == 0 && dh == 0 {
empty_spaces.swap_remove(index);
continue;
}
if dw > 0 && dh == 0 {
let mut r = space.clone();
r.left += dimensions.x;
r.width -= dimensions.x;
empty_spaces.swap_remove(index);
empty_spaces.push(r);
continue;
}
if dw == 0 && dh > 0 {
let mut r = space.clone();
r.bottom += dimensions.y;
r.height -= dimensions.y;
empty_spaces.swap_remove(index);
empty_spaces.push(r);
continue;
}
let (bigger, smaller) = if dw > dh {
(
Rect {
left: space.left + dimensions.x,
bottom: space.bottom,
width: dw,
height: space.height,
},
Rect {
left: space.left,
bottom: space.bottom + dimensions.y,
width: dimensions.x,
height: dh,
}
)
} else {
(
Rect {
left: space.left,
bottom: space.bottom + dimensions.y,
width: space.width,
height: dh,
},
Rect {
left: space.left + dimensions.x,
bottom: space.bottom,
width: dw,
height: dimensions.y,
}
)
};
empty_spaces.swap_remove(index);
empty_spaces.push(bigger);
empty_spaces.push(smaller);
}
return Some(image_rects);
}
|
use anyhow::Error;
use git::{init, Rev};
fn main() -> Result<(), Error> {
let version = git::version();
println!("git version: {}", version);
let git = init().unwrap();
dbg!(&git);
let mut revs = Rev::new(&git);
revs.add_head_to_pending();
dbg!(&revs.rev_info.total);
Ok(())
}
|
#[doc = "Register `MPCBB1_VCTR47` reader"]
pub type R = crate::R<MPCBB1_VCTR47_SPEC>;
#[doc = "Register `MPCBB1_VCTR47` writer"]
pub type W = crate::W<MPCBB1_VCTR47_SPEC>;
#[doc = "Field `B1504` reader - B1504"]
pub type B1504_R = crate::BitReader;
#[doc = "Field `B1504` writer - B1504"]
pub type B1504_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1505` reader - B1505"]
pub type B1505_R = crate::BitReader;
#[doc = "Field `B1505` writer - B1505"]
pub type B1505_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1506` reader - B1506"]
pub type B1506_R = crate::BitReader;
#[doc = "Field `B1506` writer - B1506"]
pub type B1506_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1507` reader - B1507"]
pub type B1507_R = crate::BitReader;
#[doc = "Field `B1507` writer - B1507"]
pub type B1507_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1508` reader - B1508"]
pub type B1508_R = crate::BitReader;
#[doc = "Field `B1508` writer - B1508"]
pub type B1508_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1509` reader - B1509"]
pub type B1509_R = crate::BitReader;
#[doc = "Field `B1509` writer - B1509"]
pub type B1509_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1510` reader - B1510"]
pub type B1510_R = crate::BitReader;
#[doc = "Field `B1510` writer - B1510"]
pub type B1510_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1511` reader - B1511"]
pub type B1511_R = crate::BitReader;
#[doc = "Field `B1511` writer - B1511"]
pub type B1511_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1512` reader - B1512"]
pub type B1512_R = crate::BitReader;
#[doc = "Field `B1512` writer - B1512"]
pub type B1512_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1513` reader - B1513"]
pub type B1513_R = crate::BitReader;
#[doc = "Field `B1513` writer - B1513"]
pub type B1513_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1514` reader - B1514"]
pub type B1514_R = crate::BitReader;
#[doc = "Field `B1514` writer - B1514"]
pub type B1514_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1515` reader - B1515"]
pub type B1515_R = crate::BitReader;
#[doc = "Field `B1515` writer - B1515"]
pub type B1515_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1516` reader - B1516"]
pub type B1516_R = crate::BitReader;
#[doc = "Field `B1516` writer - B1516"]
pub type B1516_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1517` reader - B1517"]
pub type B1517_R = crate::BitReader;
#[doc = "Field `B1517` writer - B1517"]
pub type B1517_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1518` reader - B1518"]
pub type B1518_R = crate::BitReader;
#[doc = "Field `B1518` writer - B1518"]
pub type B1518_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1519` reader - B1519"]
pub type B1519_R = crate::BitReader;
#[doc = "Field `B1519` writer - B1519"]
pub type B1519_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1520` reader - B1520"]
pub type B1520_R = crate::BitReader;
#[doc = "Field `B1520` writer - B1520"]
pub type B1520_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1521` reader - B1521"]
pub type B1521_R = crate::BitReader;
#[doc = "Field `B1521` writer - B1521"]
pub type B1521_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1522` reader - B1522"]
pub type B1522_R = crate::BitReader;
#[doc = "Field `B1522` writer - B1522"]
pub type B1522_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1523` reader - B1523"]
pub type B1523_R = crate::BitReader;
#[doc = "Field `B1523` writer - B1523"]
pub type B1523_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1524` reader - B1524"]
pub type B1524_R = crate::BitReader;
#[doc = "Field `B1524` writer - B1524"]
pub type B1524_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1525` reader - B1525"]
pub type B1525_R = crate::BitReader;
#[doc = "Field `B1525` writer - B1525"]
pub type B1525_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1526` reader - B1526"]
pub type B1526_R = crate::BitReader;
#[doc = "Field `B1526` writer - B1526"]
pub type B1526_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1527` reader - B1527"]
pub type B1527_R = crate::BitReader;
#[doc = "Field `B1527` writer - B1527"]
pub type B1527_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1528` reader - B1528"]
pub type B1528_R = crate::BitReader;
#[doc = "Field `B1528` writer - B1528"]
pub type B1528_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1529` reader - B1529"]
pub type B1529_R = crate::BitReader;
#[doc = "Field `B1529` writer - B1529"]
pub type B1529_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1530` reader - B1530"]
pub type B1530_R = crate::BitReader;
#[doc = "Field `B1530` writer - B1530"]
pub type B1530_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1531` reader - B1531"]
pub type B1531_R = crate::BitReader;
#[doc = "Field `B1531` writer - B1531"]
pub type B1531_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1532` reader - B1532"]
pub type B1532_R = crate::BitReader;
#[doc = "Field `B1532` writer - B1532"]
pub type B1532_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1533` reader - B1533"]
pub type B1533_R = crate::BitReader;
#[doc = "Field `B1533` writer - B1533"]
pub type B1533_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1534` reader - B1534"]
pub type B1534_R = crate::BitReader;
#[doc = "Field `B1534` writer - B1534"]
pub type B1534_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `B1535` reader - B1535"]
pub type B1535_R = crate::BitReader;
#[doc = "Field `B1535` writer - B1535"]
pub type B1535_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bit 0 - B1504"]
#[inline(always)]
pub fn b1504(&self) -> B1504_R {
B1504_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - B1505"]
#[inline(always)]
pub fn b1505(&self) -> B1505_R {
B1505_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - B1506"]
#[inline(always)]
pub fn b1506(&self) -> B1506_R {
B1506_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - B1507"]
#[inline(always)]
pub fn b1507(&self) -> B1507_R {
B1507_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - B1508"]
#[inline(always)]
pub fn b1508(&self) -> B1508_R {
B1508_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - B1509"]
#[inline(always)]
pub fn b1509(&self) -> B1509_R {
B1509_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - B1510"]
#[inline(always)]
pub fn b1510(&self) -> B1510_R {
B1510_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - B1511"]
#[inline(always)]
pub fn b1511(&self) -> B1511_R {
B1511_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - B1512"]
#[inline(always)]
pub fn b1512(&self) -> B1512_R {
B1512_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - B1513"]
#[inline(always)]
pub fn b1513(&self) -> B1513_R {
B1513_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - B1514"]
#[inline(always)]
pub fn b1514(&self) -> B1514_R {
B1514_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - B1515"]
#[inline(always)]
pub fn b1515(&self) -> B1515_R {
B1515_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - B1516"]
#[inline(always)]
pub fn b1516(&self) -> B1516_R {
B1516_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - B1517"]
#[inline(always)]
pub fn b1517(&self) -> B1517_R {
B1517_R::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - B1518"]
#[inline(always)]
pub fn b1518(&self) -> B1518_R {
B1518_R::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - B1519"]
#[inline(always)]
pub fn b1519(&self) -> B1519_R {
B1519_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - B1520"]
#[inline(always)]
pub fn b1520(&self) -> B1520_R {
B1520_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - B1521"]
#[inline(always)]
pub fn b1521(&self) -> B1521_R {
B1521_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - B1522"]
#[inline(always)]
pub fn b1522(&self) -> B1522_R {
B1522_R::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - B1523"]
#[inline(always)]
pub fn b1523(&self) -> B1523_R {
B1523_R::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bit 20 - B1524"]
#[inline(always)]
pub fn b1524(&self) -> B1524_R {
B1524_R::new(((self.bits >> 20) & 1) != 0)
}
#[doc = "Bit 21 - B1525"]
#[inline(always)]
pub fn b1525(&self) -> B1525_R {
B1525_R::new(((self.bits >> 21) & 1) != 0)
}
#[doc = "Bit 22 - B1526"]
#[inline(always)]
pub fn b1526(&self) -> B1526_R {
B1526_R::new(((self.bits >> 22) & 1) != 0)
}
#[doc = "Bit 23 - B1527"]
#[inline(always)]
pub fn b1527(&self) -> B1527_R {
B1527_R::new(((self.bits >> 23) & 1) != 0)
}
#[doc = "Bit 24 - B1528"]
#[inline(always)]
pub fn b1528(&self) -> B1528_R {
B1528_R::new(((self.bits >> 24) & 1) != 0)
}
#[doc = "Bit 25 - B1529"]
#[inline(always)]
pub fn b1529(&self) -> B1529_R {
B1529_R::new(((self.bits >> 25) & 1) != 0)
}
#[doc = "Bit 26 - B1530"]
#[inline(always)]
pub fn b1530(&self) -> B1530_R {
B1530_R::new(((self.bits >> 26) & 1) != 0)
}
#[doc = "Bit 27 - B1531"]
#[inline(always)]
pub fn b1531(&self) -> B1531_R {
B1531_R::new(((self.bits >> 27) & 1) != 0)
}
#[doc = "Bit 28 - B1532"]
#[inline(always)]
pub fn b1532(&self) -> B1532_R {
B1532_R::new(((self.bits >> 28) & 1) != 0)
}
#[doc = "Bit 29 - B1533"]
#[inline(always)]
pub fn b1533(&self) -> B1533_R {
B1533_R::new(((self.bits >> 29) & 1) != 0)
}
#[doc = "Bit 30 - B1534"]
#[inline(always)]
pub fn b1534(&self) -> B1534_R {
B1534_R::new(((self.bits >> 30) & 1) != 0)
}
#[doc = "Bit 31 - B1535"]
#[inline(always)]
pub fn b1535(&self) -> B1535_R {
B1535_R::new(((self.bits >> 31) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - B1504"]
#[inline(always)]
#[must_use]
pub fn b1504(&mut self) -> B1504_W<MPCBB1_VCTR47_SPEC, 0> {
B1504_W::new(self)
}
#[doc = "Bit 1 - B1505"]
#[inline(always)]
#[must_use]
pub fn b1505(&mut self) -> B1505_W<MPCBB1_VCTR47_SPEC, 1> {
B1505_W::new(self)
}
#[doc = "Bit 2 - B1506"]
#[inline(always)]
#[must_use]
pub fn b1506(&mut self) -> B1506_W<MPCBB1_VCTR47_SPEC, 2> {
B1506_W::new(self)
}
#[doc = "Bit 3 - B1507"]
#[inline(always)]
#[must_use]
pub fn b1507(&mut self) -> B1507_W<MPCBB1_VCTR47_SPEC, 3> {
B1507_W::new(self)
}
#[doc = "Bit 4 - B1508"]
#[inline(always)]
#[must_use]
pub fn b1508(&mut self) -> B1508_W<MPCBB1_VCTR47_SPEC, 4> {
B1508_W::new(self)
}
#[doc = "Bit 5 - B1509"]
#[inline(always)]
#[must_use]
pub fn b1509(&mut self) -> B1509_W<MPCBB1_VCTR47_SPEC, 5> {
B1509_W::new(self)
}
#[doc = "Bit 6 - B1510"]
#[inline(always)]
#[must_use]
pub fn b1510(&mut self) -> B1510_W<MPCBB1_VCTR47_SPEC, 6> {
B1510_W::new(self)
}
#[doc = "Bit 7 - B1511"]
#[inline(always)]
#[must_use]
pub fn b1511(&mut self) -> B1511_W<MPCBB1_VCTR47_SPEC, 7> {
B1511_W::new(self)
}
#[doc = "Bit 8 - B1512"]
#[inline(always)]
#[must_use]
pub fn b1512(&mut self) -> B1512_W<MPCBB1_VCTR47_SPEC, 8> {
B1512_W::new(self)
}
#[doc = "Bit 9 - B1513"]
#[inline(always)]
#[must_use]
pub fn b1513(&mut self) -> B1513_W<MPCBB1_VCTR47_SPEC, 9> {
B1513_W::new(self)
}
#[doc = "Bit 10 - B1514"]
#[inline(always)]
#[must_use]
pub fn b1514(&mut self) -> B1514_W<MPCBB1_VCTR47_SPEC, 10> {
B1514_W::new(self)
}
#[doc = "Bit 11 - B1515"]
#[inline(always)]
#[must_use]
pub fn b1515(&mut self) -> B1515_W<MPCBB1_VCTR47_SPEC, 11> {
B1515_W::new(self)
}
#[doc = "Bit 12 - B1516"]
#[inline(always)]
#[must_use]
pub fn b1516(&mut self) -> B1516_W<MPCBB1_VCTR47_SPEC, 12> {
B1516_W::new(self)
}
#[doc = "Bit 13 - B1517"]
#[inline(always)]
#[must_use]
pub fn b1517(&mut self) -> B1517_W<MPCBB1_VCTR47_SPEC, 13> {
B1517_W::new(self)
}
#[doc = "Bit 14 - B1518"]
#[inline(always)]
#[must_use]
pub fn b1518(&mut self) -> B1518_W<MPCBB1_VCTR47_SPEC, 14> {
B1518_W::new(self)
}
#[doc = "Bit 15 - B1519"]
#[inline(always)]
#[must_use]
pub fn b1519(&mut self) -> B1519_W<MPCBB1_VCTR47_SPEC, 15> {
B1519_W::new(self)
}
#[doc = "Bit 16 - B1520"]
#[inline(always)]
#[must_use]
pub fn b1520(&mut self) -> B1520_W<MPCBB1_VCTR47_SPEC, 16> {
B1520_W::new(self)
}
#[doc = "Bit 17 - B1521"]
#[inline(always)]
#[must_use]
pub fn b1521(&mut self) -> B1521_W<MPCBB1_VCTR47_SPEC, 17> {
B1521_W::new(self)
}
#[doc = "Bit 18 - B1522"]
#[inline(always)]
#[must_use]
pub fn b1522(&mut self) -> B1522_W<MPCBB1_VCTR47_SPEC, 18> {
B1522_W::new(self)
}
#[doc = "Bit 19 - B1523"]
#[inline(always)]
#[must_use]
pub fn b1523(&mut self) -> B1523_W<MPCBB1_VCTR47_SPEC, 19> {
B1523_W::new(self)
}
#[doc = "Bit 20 - B1524"]
#[inline(always)]
#[must_use]
pub fn b1524(&mut self) -> B1524_W<MPCBB1_VCTR47_SPEC, 20> {
B1524_W::new(self)
}
#[doc = "Bit 21 - B1525"]
#[inline(always)]
#[must_use]
pub fn b1525(&mut self) -> B1525_W<MPCBB1_VCTR47_SPEC, 21> {
B1525_W::new(self)
}
#[doc = "Bit 22 - B1526"]
#[inline(always)]
#[must_use]
pub fn b1526(&mut self) -> B1526_W<MPCBB1_VCTR47_SPEC, 22> {
B1526_W::new(self)
}
#[doc = "Bit 23 - B1527"]
#[inline(always)]
#[must_use]
pub fn b1527(&mut self) -> B1527_W<MPCBB1_VCTR47_SPEC, 23> {
B1527_W::new(self)
}
#[doc = "Bit 24 - B1528"]
#[inline(always)]
#[must_use]
pub fn b1528(&mut self) -> B1528_W<MPCBB1_VCTR47_SPEC, 24> {
B1528_W::new(self)
}
#[doc = "Bit 25 - B1529"]
#[inline(always)]
#[must_use]
pub fn b1529(&mut self) -> B1529_W<MPCBB1_VCTR47_SPEC, 25> {
B1529_W::new(self)
}
#[doc = "Bit 26 - B1530"]
#[inline(always)]
#[must_use]
pub fn b1530(&mut self) -> B1530_W<MPCBB1_VCTR47_SPEC, 26> {
B1530_W::new(self)
}
#[doc = "Bit 27 - B1531"]
#[inline(always)]
#[must_use]
pub fn b1531(&mut self) -> B1531_W<MPCBB1_VCTR47_SPEC, 27> {
B1531_W::new(self)
}
#[doc = "Bit 28 - B1532"]
#[inline(always)]
#[must_use]
pub fn b1532(&mut self) -> B1532_W<MPCBB1_VCTR47_SPEC, 28> {
B1532_W::new(self)
}
#[doc = "Bit 29 - B1533"]
#[inline(always)]
#[must_use]
pub fn b1533(&mut self) -> B1533_W<MPCBB1_VCTR47_SPEC, 29> {
B1533_W::new(self)
}
#[doc = "Bit 30 - B1534"]
#[inline(always)]
#[must_use]
pub fn b1534(&mut self) -> B1534_W<MPCBB1_VCTR47_SPEC, 30> {
B1534_W::new(self)
}
#[doc = "Bit 31 - B1535"]
#[inline(always)]
#[must_use]
pub fn b1535(&mut self) -> B1535_W<MPCBB1_VCTR47_SPEC, 31> {
B1535_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 = "MPCBBx vector register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`mpcbb1_vctr47::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 [`mpcbb1_vctr47::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct MPCBB1_VCTR47_SPEC;
impl crate::RegisterSpec for MPCBB1_VCTR47_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`mpcbb1_vctr47::R`](R) reader structure"]
impl crate::Readable for MPCBB1_VCTR47_SPEC {}
#[doc = "`write(|w| ..)` method takes [`mpcbb1_vctr47::W`](W) writer structure"]
impl crate::Writable for MPCBB1_VCTR47_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets MPCBB1_VCTR47 to value 0"]
impl crate::Resettable for MPCBB1_VCTR47_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use std::error::Error as StdError;
use std::fmt;
use rand::{distributions::Alphanumeric, thread_rng, Rng};
use svc_agent::error::Error as AgentError;
////////////////////////////////////////////////////////////////////////////////
#[derive(Debug)]
pub enum ClientError {
Agent(AgentError),
Payload(String),
Timeout,
Http(String),
}
impl From<AgentError> for ClientError {
fn from(e: AgentError) -> Self {
Self::Agent(e)
}
}
impl fmt::Display for ClientError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ClientError::Agent(ae) => write!(f, "Agent inner error: {}", ae),
ClientError::Payload(s) => write!(f, "Payload error: {}", s),
ClientError::Timeout => write!(f, "Timeout"),
ClientError::Http(s) => write!(f, "Http error: {}", s),
}
}
}
impl StdError for ClientError {
fn source(&self) -> Option<&(dyn StdError + 'static)> {
None
}
}
////////////////////////////////////////////////////////////////////////////////
const CORRELATION_DATA_LENGTH: usize = 16;
fn generate_correlation_data() -> String {
thread_rng()
.sample_iter(&Alphanumeric)
.map(char::from)
.take(CORRELATION_DATA_LENGTH)
.collect()
}
////////////////////////////////////////////////////////////////////////////////
pub mod conference;
pub mod event;
pub mod tq;
|
#[doc = "Reader of register RCC_AHB6RSTCLRR"]
pub type R = crate::R<u32, super::RCC_AHB6RSTCLRR>;
#[doc = "Writer for register RCC_AHB6RSTCLRR"]
pub type W = crate::W<u32, super::RCC_AHB6RSTCLRR>;
#[doc = "Register RCC_AHB6RSTCLRR `reset()`'s with value 0"]
impl crate::ResetValue for super::RCC_AHB6RSTCLRR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "ETHMACRST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ETHMACRST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<ETHMACRST_A> for bool {
#[inline(always)]
fn from(variant: ETHMACRST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `ETHMACRST`"]
pub type ETHMACRST_R = crate::R<bool, ETHMACRST_A>;
impl ETHMACRST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ETHMACRST_A {
match self.bits {
false => ETHMACRST_A::B_0X0,
true => ETHMACRST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == ETHMACRST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == ETHMACRST_A::B_0X1
}
}
#[doc = "Write proxy for field `ETHMACRST`"]
pub struct ETHMACRST_W<'a> {
w: &'a mut W,
}
impl<'a> ETHMACRST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: ETHMACRST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(ETHMACRST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(ETHMACRST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "FMCRST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FMCRST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<FMCRST_A> for bool {
#[inline(always)]
fn from(variant: FMCRST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `FMCRST`"]
pub type FMCRST_R = crate::R<bool, FMCRST_A>;
impl FMCRST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FMCRST_A {
match self.bits {
false => FMCRST_A::B_0X0,
true => FMCRST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == FMCRST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == FMCRST_A::B_0X1
}
}
#[doc = "Write proxy for field `FMCRST`"]
pub struct FMCRST_W<'a> {
w: &'a mut W,
}
impl<'a> FMCRST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FMCRST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(FMCRST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(FMCRST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "QSPIRST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum QSPIRST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<QSPIRST_A> for bool {
#[inline(always)]
fn from(variant: QSPIRST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `QSPIRST`"]
pub type QSPIRST_R = crate::R<bool, QSPIRST_A>;
impl QSPIRST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> QSPIRST_A {
match self.bits {
false => QSPIRST_A::B_0X0,
true => QSPIRST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == QSPIRST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == QSPIRST_A::B_0X1
}
}
#[doc = "Write proxy for field `QSPIRST`"]
pub struct QSPIRST_W<'a> {
w: &'a mut W,
}
impl<'a> QSPIRST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: QSPIRST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(QSPIRST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(QSPIRST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
self.w
}
}
#[doc = "SDMMC1RST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SDMMC1RST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<SDMMC1RST_A> for bool {
#[inline(always)]
fn from(variant: SDMMC1RST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `SDMMC1RST`"]
pub type SDMMC1RST_R = crate::R<bool, SDMMC1RST_A>;
impl SDMMC1RST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SDMMC1RST_A {
match self.bits {
false => SDMMC1RST_A::B_0X0,
true => SDMMC1RST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == SDMMC1RST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == SDMMC1RST_A::B_0X1
}
}
#[doc = "Write proxy for field `SDMMC1RST`"]
pub struct SDMMC1RST_W<'a> {
w: &'a mut W,
}
impl<'a> SDMMC1RST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SDMMC1RST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(SDMMC1RST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(SDMMC1RST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "SDMMC2RST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SDMMC2RST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<SDMMC2RST_A> for bool {
#[inline(always)]
fn from(variant: SDMMC2RST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `SDMMC2RST`"]
pub type SDMMC2RST_R = crate::R<bool, SDMMC2RST_A>;
impl SDMMC2RST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SDMMC2RST_A {
match self.bits {
false => SDMMC2RST_A::B_0X0,
true => SDMMC2RST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == SDMMC2RST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == SDMMC2RST_A::B_0X1
}
}
#[doc = "Write proxy for field `SDMMC2RST`"]
pub struct SDMMC2RST_W<'a> {
w: &'a mut W,
}
impl<'a> SDMMC2RST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: SDMMC2RST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(SDMMC2RST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(SDMMC2RST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "CRC1RST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CRC1RST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<CRC1RST_A> for bool {
#[inline(always)]
fn from(variant: CRC1RST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `CRC1RST`"]
pub type CRC1RST_R = crate::R<bool, CRC1RST_A>;
impl CRC1RST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CRC1RST_A {
match self.bits {
false => CRC1RST_A::B_0X0,
true => CRC1RST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == CRC1RST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == CRC1RST_A::B_0X1
}
}
#[doc = "Write proxy for field `CRC1RST`"]
pub struct CRC1RST_W<'a> {
w: &'a mut W,
}
impl<'a> CRC1RST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CRC1RST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(CRC1RST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(CRC1RST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "USBHRST\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum USBHRST_A {
#[doc = "0: Writing has no effect, reading means\r\n that the block reset is released"]
B_0X0 = 0,
#[doc = "1: Writing releases the block reset,\r\n reading means that the block reset is\r\n asserted"]
B_0X1 = 1,
}
impl From<USBHRST_A> for bool {
#[inline(always)]
fn from(variant: USBHRST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `USBHRST`"]
pub type USBHRST_R = crate::R<bool, USBHRST_A>;
impl USBHRST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> USBHRST_A {
match self.bits {
false => USBHRST_A::B_0X0,
true => USBHRST_A::B_0X1,
}
}
#[doc = "Checks if the value of the field is `B_0X0`"]
#[inline(always)]
pub fn is_b_0x0(&self) -> bool {
*self == USBHRST_A::B_0X0
}
#[doc = "Checks if the value of the field is `B_0X1`"]
#[inline(always)]
pub fn is_b_0x1(&self) -> bool {
*self == USBHRST_A::B_0X1
}
}
#[doc = "Write proxy for field `USBHRST`"]
pub struct USBHRST_W<'a> {
w: &'a mut W,
}
impl<'a> USBHRST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: USBHRST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Writing has no effect, reading means that the block reset is released"]
#[inline(always)]
pub fn b_0x0(self) -> &'a mut W {
self.variant(USBHRST_A::B_0X0)
}
#[doc = "Writing releases the block reset, reading means that the block reset is asserted"]
#[inline(always)]
pub fn b_0x1(self) -> &'a mut W {
self.variant(USBHRST_A::B_0X1)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
impl R {
#[doc = "Bit 10 - ETHMACRST"]
#[inline(always)]
pub fn ethmacrst(&self) -> ETHMACRST_R {
ETHMACRST_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 12 - FMCRST"]
#[inline(always)]
pub fn fmcrst(&self) -> FMCRST_R {
FMCRST_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 14 - QSPIRST"]
#[inline(always)]
pub fn qspirst(&self) -> QSPIRST_R {
QSPIRST_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 16 - SDMMC1RST"]
#[inline(always)]
pub fn sdmmc1rst(&self) -> SDMMC1RST_R {
SDMMC1RST_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - SDMMC2RST"]
#[inline(always)]
pub fn sdmmc2rst(&self) -> SDMMC2RST_R {
SDMMC2RST_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 20 - CRC1RST"]
#[inline(always)]
pub fn crc1rst(&self) -> CRC1RST_R {
CRC1RST_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 24 - USBHRST"]
#[inline(always)]
pub fn usbhrst(&self) -> USBHRST_R {
USBHRST_R::new(((self.bits >> 24) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 10 - ETHMACRST"]
#[inline(always)]
pub fn ethmacrst(&mut self) -> ETHMACRST_W {
ETHMACRST_W { w: self }
}
#[doc = "Bit 12 - FMCRST"]
#[inline(always)]
pub fn fmcrst(&mut self) -> FMCRST_W {
FMCRST_W { w: self }
}
#[doc = "Bit 14 - QSPIRST"]
#[inline(always)]
pub fn qspirst(&mut self) -> QSPIRST_W {
QSPIRST_W { w: self }
}
#[doc = "Bit 16 - SDMMC1RST"]
#[inline(always)]
pub fn sdmmc1rst(&mut self) -> SDMMC1RST_W {
SDMMC1RST_W { w: self }
}
#[doc = "Bit 17 - SDMMC2RST"]
#[inline(always)]
pub fn sdmmc2rst(&mut self) -> SDMMC2RST_W {
SDMMC2RST_W { w: self }
}
#[doc = "Bit 20 - CRC1RST"]
#[inline(always)]
pub fn crc1rst(&mut self) -> CRC1RST_W {
CRC1RST_W { w: self }
}
#[doc = "Bit 24 - USBHRST"]
#[inline(always)]
pub fn usbhrst(&mut self) -> USBHRST_W {
USBHRST_W { w: self }
}
}
|
use super::*;
use arbitrary::Arbitrary;
use std::fs::File;
use std::io::prelude::*;
use std::fs::remove_file;
#[derive(Arbitrary, Debug)]
pub struct FromCsvHarnessParams {
edge_reader: EdgeFileReaderParams,
nodes_reader: Option<NodeFileReaderParams>,
directed: bool,
}
#[derive(Arbitrary, Debug)]
pub struct CSVFileReaderParams {
pub verbose: Option<bool>,
pub separator: Option<String>,
pub header: Option<bool>,
pub rows_to_skip: Option<usize>,
pub ignore_duplicates: Option<bool>,
}
#[derive(Arbitrary, Debug)]
pub struct NodeFileReaderParams {
pub file: String,
pub reader: CSVFileReaderParams,
pub default_node_type: Option<String>,
pub nodes_column_number: Option<usize>,
pub nodes_column: Option<String>,
pub node_types_column_number: Option<usize>,
pub node_types_column: Option<String>,
}
#[derive(Arbitrary, Debug)]
pub struct EdgeFileReaderParams {
pub file: String,
pub reader: CSVFileReaderParams,
pub sources_column_number: Option<usize>,
pub sources_column: Option<String>,
pub destinations_column_number: Option<usize>,
pub destinations_column: Option<String>,
pub edge_types_column_number: Option<usize>,
pub edge_types_column: Option<String>,
pub weights_column_number: Option<usize>,
pub weights_column: Option<String>,
pub default_weight: Option<WeightT>,
pub default_edge_type: Option<String>,
pub skip_self_loops: Option<bool>,
}
pub fn from_csv_harness(data: FromCsvHarnessParams) -> Result<(), String> {
// generate random paths
let edges_path = graph::test_utilities::random_path();
let nodes_path = graph::test_utilities::random_path();
// run the harness
let result = internal_harness(&edges_path, &nodes_path, data);
// cleanup
let _ = remove_file(&edges_path);
let _ = remove_file(&nodes_path);
result
}
fn internal_harness(edges_path: &str, nodes_path: &str, data: FromCsvHarnessParams) -> Result<(), String> {
// create the edge file
let mut edges_file = File::create(edges_path).unwrap();
edges_file.write_all(&data.edge_reader.file.as_bytes()).unwrap();
// create the reader
let edges_reader = EdgeFileReader::new(edges_path.to_string())?
.set_verbose(Some(false))
.set_ignore_duplicates(data.edge_reader.reader.ignore_duplicates)
.set_separator(data.edge_reader.reader.separator)?
.set_header(data.edge_reader.reader.header)
.set_rows_to_skip(data.edge_reader.reader.rows_to_skip)
.set_sources_column_number(data.edge_reader.sources_column_number)?
.set_sources_column(data.edge_reader.sources_column)?
.set_destinations_column_number(data.edge_reader.destinations_column_number)?
.set_destinations_column(data.edge_reader.destinations_column)?
.set_weights_column_number(data.edge_reader.weights_column_number)?
.set_weights_column(data.edge_reader.weights_column)?
.set_edge_types_column_number(data.edge_reader.edge_types_column_number)?
.set_edge_types_column(data.edge_reader.edge_types_column)?
.set_default_edge_type(data.edge_reader.default_edge_type)
.set_default_weight(data.edge_reader.default_weight)
.set_skip_self_loops(data.edge_reader.skip_self_loops);
let nodes_reader = match data.nodes_reader {
None => None,
Some(nr) => {
// create the node file
let mut nodes_file = File::create(&nodes_path).unwrap();
nodes_file.write_all(&nr.file.as_bytes()).unwrap();
// return the reader
Some(
NodeFileReader::new(nodes_path.to_string())?
.set_verbose(Some(false))
.set_separator(nr.reader.separator)?
.set_node_types_column_number(nr.node_types_column_number)?
.set_nodes_column_number(nr.node_types_column_number)?
.set_node_types_column(nr.node_types_column)?
.set_default_node_type(nr.default_node_type)
.set_nodes_column(nr.nodes_column)?
.set_ignore_duplicates(nr.reader.ignore_duplicates)
.set_header(nr.reader.header)
.set_rows_to_skip(nr.reader.rows_to_skip)
)
}
};
let mut g = Graph::from_unsorted_csv(edges_reader, nodes_reader, data.directed, false, "Graph".to_owned())?;
let _ = graph::test_utilities::default_test_suite(&mut g, false);
Ok(())
}
|
use std::io::{self, BufRead};
fn main() {
let stdin = io::stdin();
let mut iter = stdin.lock().lines();
let _ = iter.next();
let line = iter.next().unwrap().unwrap();
let mut vs: Vec<i32> = line.split_whitespace()
.map(|num| num.parse().unwrap())
.collect();
vs.sort();
/*
let vs: Vec<_> = vs.iter()
.map(|v| v.to_string())
.collect();
*/
// println!("{}", vs.join(" "));
let mut iter = vs.into_iter();
let mut prev = iter.next().unwrap();
let mut len = 1;
let mut res = prev.to_string();
loop {
match iter.next() {
Some(v) => {
if v == prev + 1 {
len += 1
} else {
if len == 2 {
res.push_str(" ");
res.push_str(&prev.to_string());
} else if len > 2 {
res.push_str("-");
res.push_str(&prev.to_string());
}
len = 1;
res.push_str(" ");
res.push_str(&v.to_string());
}
prev = v;
},
_ => {
if len == 2 {
res.push_str(" ");
res.push_str(&prev.to_string());
} else if len > 2 {
res.push_str("-");
res.push_str(&prev.to_string());
}
break;
},
}
}
println!("{}", res);
}
|
//! Azure service bus crate for the unofficial Microsoft Azure SDK for Rust. This crate is part of a collection of crates: for more information please refer to [https://github.com/azure/azure-sdk-for-rust](https://github.com/azure/azure-sdk-for-rust).
#![recursion_limit = "128"]
// #[macro_use]
// extern crate log;
// // TODO update service_bus to use HttpClient https://github.com/Azure/azure-sdk-for-rust/issues/255
// pub mod event_hub;
// pub mod prelude;
|
use crate::GRID_SIDE;
use crate::agent::Id;
use crate::rand::Rng;
use std::cmp;
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub struct Position {
pub x: usize,
pub y: usize,
}
impl Position {
pub fn random() -> Position {
let mut rng = rand::thread_rng();
Position {
x: rng.gen_range(0, GRID_SIDE),
y: rng.gen_range(0, GRID_SIDE),
}
}
}
#[derive(Copy, Clone)]
pub struct PositionChange {
pub id: Id,
pub before: Position,
pub after: Position,
}
/// Provides 2D grid and subgrid agent detection
pub struct Grid {
pub val: Vec<Vec<Id>>,
}
impl Grid {
pub fn set(&mut self, position: Position, id: Id) {
self.val[position.x][position.y] = id;
}
pub fn update(&mut self, changes: Vec<PositionChange>) {
for change in &changes {
self.set(change.before, 0);
self.set(change.after, change.id);
}
}
pub fn is_subgrid_free(
&self,
position: Position,
subgrid_size_x: usize,
subgrid_size_y: usize,
excluded_ids: Vec<Id>,
maybe_excluded_fn: Option<&dyn Fn(Id) -> bool>,
) -> bool {
let subgrid_center: Position = self.get_subgrid_center(subgrid_size_x, subgrid_size_y);
let mut occupier_iter: SubgridSearch = SubgridSearch::new(
position,
subgrid_center,
subgrid_size_x,
subgrid_size_y,
excluded_ids,
&self.val,
);
if let Some(excluded_fn) = maybe_excluded_fn {
while let Some(occupier) = occupier_iter.next() {
if !excluded_fn(occupier) {
return false;
}
}
return true;
} else {
return occupier_iter.next().is_none();
}
}
pub fn is_subgrid_occupied(
&self,
position: Position,
subgrid_size_x: usize,
subgrid_size_y: usize,
excluded_ids: Vec<Id>,
maybe_excluded_fn: Option<&dyn Fn(Id) -> bool>,
) -> bool {
let subgrid_center: Position = self.get_subgrid_center(subgrid_size_x, subgrid_size_y);
let mut occupier_iter: SubgridSearch = SubgridSearch::new(
position,
subgrid_center,
subgrid_size_x,
subgrid_size_y,
excluded_ids,
&self.val,
);
if let Some(excluded_fn) = maybe_excluded_fn {
while let Some(occupier) = occupier_iter.next() {
if !excluded_fn(occupier) {
return true;
}
}
return false;
} else {
occupier_iter.next().is_some()
}
}
pub fn get_subgrid_occupiers(
&self,
position: Position,
subgrid_size_x: usize,
subgrid_size_y: usize,
excluded_ids: Vec<Id>,
maybe_excluded_fn: Option<&dyn Fn(Id) -> bool>,
) -> Vec<Id> {
let subgrid_center: Position = self.get_subgrid_center(subgrid_size_x, subgrid_size_y);
let mut occupier_iter: SubgridSearch = SubgridSearch::new(
position,
subgrid_center,
subgrid_size_x,
subgrid_size_y,
excluded_ids,
&self.val,
);
if let Some(excluded_fn) = maybe_excluded_fn {
let mut v: Vec<Id> = vec![];
while let Some(occupier) = occupier_iter.next() {
if !excluded_fn(occupier) {
v.push(occupier);
}
}
v
} else {
occupier_iter.collect()
}
}
fn get_subgrid_center(&self, subgrid_size_x: usize, subgrid_size_y: usize) -> Position {
Position {
x: ((subgrid_size_x - 1) as f32 / 2.0).round() as usize,
y: ((subgrid_size_y - 1) as f32 / 2.0).round() as usize,
}
}
}
struct SubgridSearch<'a> {
x_start: usize,
y_start: usize,
y_start_: usize,
x_end: usize,
y_end: usize,
ignore: Vec<Id>,
val: &'a Vec<Vec<Id>>,
}
impl<'a> SubgridSearch<'a> {
fn new(
position: Position,
subgrid_center: Position,
subgrid_size_x: usize,
subgrid_size_y: usize,
ignore: Vec<Id>,
val: &Vec<Vec<Id>>,
) -> SubgridSearch {
let x = position.x as i64 - subgrid_center.x as i64;
let y = position.y as i64 - subgrid_center.y as i64;
let x_start = cmp::max(x, 0) as usize;
let y_start = cmp::max(y, 0) as usize;
let y_start_ = y_start;
let x_end = cmp::min(subgrid_size_x as i64 + x, GRID_SIDE as i64) as usize;
let y_end = cmp::min(subgrid_size_y as i64 + y, GRID_SIDE as i64) as usize;
SubgridSearch {
x_start,
y_start,
y_start_,
x_end,
y_end,
ignore,
val,
}
}
}
impl<'a> Iterator for SubgridSearch<'a> {
type Item = Id;
fn next(&mut self) -> Option<Self::Item> {
if self.x_start >= self.x_end {
None
} else {
if self.y_start != self.y_start_ {
let x = self.x_start;
for y in self.y_start_..self.y_end {
let val: Id = self.val[x][y];
if val > 0 && !self.ignore.contains(&val) {
self.x_start = if y == self.y_end - 1 { x + 1 } else { x };
self.y_start_ = if y < self.y_end - 1 {
y + 1
} else {
self.y_start
};
return Some(val);
}
}
self.x_start += 1;
self.y_start_ = self.y_start;
}
for x in self.x_start..self.x_end {
for y in self.y_start..self.y_end {
let val: Id = self.val[x][y];
if val > 0 && !self.ignore.contains(&val) {
self.x_start = if y == self.y_end - 1 { x + 1 } else { x };
self.y_start_ = if y < self.y_end - 1 {
y + 1
} else {
self.y_start
};
return Some(val);
}
}
}
self.x_start = self.x_end;
None
}
}
}
|
use cgmath::{ElementWise, Matrix2, Vector2};
use math::{Aabb, Rot};
use graphics::quad_types::QUAD_VERTICES;
#[derive(Copy, Clone)]
pub struct Transform {
pub pos: Vector2<f32>,
pub rot: Rot,
pub scale: f32,
pub size: Vector2<f32>,
}
impl Default for Transform {
fn default() -> Self {
Transform::new()
}
}
impl Transform {
pub fn new() -> Self {
Transform {
pos: Vector2 { x: 0.0, y: 0.0 },
rot: Rot::new(0.0),
scale: 1.0,
size: Vector2 { x: 1.0, y: 1.0 },
}
}
pub fn transform_point(&self, point: Vector2<f32>) -> Vector2<f32> {
let (sin, cos) = (self.rot.sin, self.rot.cos);
let rot = Matrix2::new(cos, sin, -sin, cos);
rot * (point * self.scale).mul_element_wise(self.size) + self.pos
}
pub fn sprite_aabb(&self, center: Vector2<f32>) -> Aabb {
let mut aabb = Aabb::empty();
for vertex in &QUAD_VERTICES {
let world_pt = self.transform_point(Vector2 {
x: vertex.pos[0] - center.x,
y: vertex.pos[1] + center.y,
});
aabb.expand_point(world_pt);
}
aabb
}
}
|
#[macro_use]
extern crate impl_ops;
use minifb::{Scale, Window, WindowOptions};
use scoped_threadpool::Pool;
use framebuffer::Framebuffer;
use renderer::Program;
use vector::Vector3;
use crate::matrix::Matrix4;
use crate::renderer::RenderRegion;
use crate::vector::Vector4;
mod framebuffer;
mod texture;
mod utils;
mod vector;
mod matrix;
mod renderer;
const WIDTH: usize = 175 * 2;
const HEIGHT: usize = 100 * 2;
fn sierpinski(v: Vector3, _: f64, t: &f64) -> Vector3 {
let x = (WIDTH as f64 * (v.x + *t)) as usize;
let y = (HEIGHT as f64 * v.y) as usize;
Vector3::new((x & y) as f64, (x & 15) as f64 / 15.0, (y & 15) as f64 / 15.0)
}
fn ojascki(v: Vector3, _: f64, t: &f64) -> Vector3 {
let mut x = v.x - 0.5;
let mut y = (v.y - 0.5) * 9.0 / 16.0;
let mut a = t + (t * 0.5).sin() * 0.25;
let sina = a.sin();
let cosa = a.cos();
x = x * cosa - y * sina;
y = x * sina + y * cosa;
let mut length = (x * x + y * y).sqrt();
let factor = (length * (6.0 + (a * 0.4).sin() * 3.0)).powi(2);
x /= factor;
y /= factor;
let col = Vector3::zero();
length = (x * x + y * y).sqrt();
let x1 = x;
x = x.atan2(y);
y = length * 20.0;
x += (y - x).floor() + 1.0;
y = (y - x1).fract();
x = (x * x * 4.0 - (0.25 - y * y).sqrt()) * 3.0;
Vector3::new(x, y, 0.0)
}
// โโโโ โโโโ โโโโโโ โโโโโโโโโโโโ โโโ
// โโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโ โโโ
// โโโโโโโโโโโโโโโโโโโ โโโ โโโโโโโโ
// โโโโโโโโโโโโโโโโโโโ โโโ โโโโโโโโ
// โโโ โโโ โโโโโโ โโโ โโโ โโโ โโโ
// โโโ โโโโโโ โโโ โโโ โโโ โโโ
fn rotate_x(v: Vector3, angle: f64) -> Vector3 {
let cosa = angle.cos();
let sina = angle.sin();
Vector3::new(v.x, v.y * cosa - v.z * sina, v.y * sina + v.z * cosa)
}
fn rotate_y(v: Vector3, angle: f64) -> Vector3 {
let cosa = angle.cos();
let sina = angle.sin();
Vector3::new(v.x * cosa - v.z * sina, v.y, v.x * sina + v.z * cosa)
}
fn scale(v: Vector3, factor: f64) -> Vector3 {
v * factor
}
fn perspective(v: Vector3, near: f64, far: f64) -> Vector3 {
let w = far * near / (far - near) * v.z;
Vector3::new(v.x, v.y, far / (far - near)) * (1.0 / w)
}
fn basic_perspective(v: Vector3, t: &(f64, Vector3)) -> (Vector3, f64) {
(perspective(rotate_x(rotate_y(v, t.0), std::f64::consts::PI / 4.0) + Vector3::new(0.0, 0.0, 50.0), 0.1, 100.0) * 0.5 + Vector3::new(0.5, 0.5, 0.0), 0.1)
}
fn lighting(v: Vector3, _: f64, (t, n): &(f64, Vector3)) -> Vector3 {
let normal = rotate_x(rotate_y(*n, *t), -std::f64::consts::PI / 4.0);
let light_dir = Vector3::new(0.0, 0.0, -1.0);
let view_dir = v * (1.0 / (v * v).sqrt());
let reflect_dir = view_dir - normal * (2.0 * (view_dir * normal));
let ambient = 0.3;
let diff = 0.7 * (normal * light_dir).max(0.0);
let spec = (view_dir * reflect_dir).max(0.0).powi(32);
Vector3::new(0.4, 0.5, 0.0) * (ambient + diff + 0.5 * spec)
}
fn main() {
let mut window = Window::new(
"CPU Renderer",
WIDTH,
HEIGHT,
WindowOptions { borderless: true, title: true, resize: false, scale: Scale::X4 },
).unwrap();
let mut buffer = Framebuffer::new(WIDTH, HEIGHT);
let mut pool = Pool::new(48);
let mut program = Program::new(
basic_perspective,
lighting,
(0.0, Vector3::new(0.0, 0.0, 0.0)),
WIDTH,
HEIGHT,
30,
30,
);
let m0 = Matrix4 {
m00: 2.0,
m11: 2.0,
m22: 2.0,
m33: 1.0,
..Matrix4::default()
};
let m1 = Matrix4 {
m00: 1.0,
m11: 1.0,
m22: 1.0,
m33: 1.0,
m30: 1.0,
m31: 1.0,
m32: 1.0,
..Matrix4::default()
};
println!("{:?} {:?}", m0 * m1 * Vector4::new(0.0, 0.0, 1.0, 1.0), m1 * m0 * Vector4::new(0.0, 0.0, 1.0, 1.0));
//println!("{:?}", program.regions);
program.enqueue_triangle(Vector3::new(0.0, 0.0, 0.0), Vector3::new(0.0, 1.0, 0.0), Vector3::new(1.0, 0.0, 0.0));
//program.enqueue_triangle(Vector3::new(0.0, 0.0, 1.0),Vector3::new(0.0, 0.5, 0.0), Vector3::new(1.0, 0.0, 0.0));
//println!("{:?}", program.regions);
let mut clock = std::time::Instant::now();
while window.is_open() {
buffer.clear(Vector3::zero());
program.reset();
program.uniform.0 += 1.0 / 90.0;
program.uniform.1 = Vector3::new(0.0, 0.0, -1.0);
// roller
let n = 200.0;
let theta = std::f64::consts::PI / (n / 2.0);
for i in 0..=(n as usize) {
let edge0 = rotate_y(Vector3::new(0.0, 0.0, 1.0), (i as f64) * theta);
let edge1 = rotate_y(Vector3::new(0.0, 0.0, 1.0), (i as f64 + 1.0) * theta);
program.uniform.1 = rotate_y(Vector3::new(0.0, 0.0, 1.0), (i as f64 + 0.5) * theta) * (-1.0);
program.enqueue_triangle(Vector3::new(edge0.x, -1.0, edge0.z), Vector3::new(edge1.x, -1.0, edge1.z), Vector3::new(edge1.x, 1.0, edge1.z));
program.enqueue_triangle(Vector3::new(edge0.x, 1.0, edge0.z), Vector3::new(edge0.x, -1.0, edge0.z), Vector3::new(edge1.x, 1.0, edge1.z));
}
// program.uniform.1 = Vector3::new(0.0, 0.0, 1.0);
// program.enqueue_triangle(Vector3::new(-1.0, -1.0, -1.0),Vector3::new(-1.0, 1.0, -1.0), Vector3::new(1.0, -1.0, -1.0));
// program.enqueue_triangle(Vector3::new(1.0, 1.0, -1.0),Vector3::new(-1.0, 1.0, -1.0), Vector3::new(1.0, -1.0, -1.0));
// program.uniform.1 = Vector3::new(0.0, 0.0, -1.0);
// program.enqueue_triangle(Vector3::new(-1.0, -1.0, 1.0),Vector3::new(-1.0, 1.0, 1.0), Vector3::new(1.0, -1.0, 1.0));
// program.enqueue_triangle(Vector3::new(1.0, 1.0, 1.0),Vector3::new(-1.0, 1.0, 1.0), Vector3::new(1.0, -1.0, 1.0));
// program.uniform.1 = Vector3::new(-1.0, 0.0, 0.0);
// program.enqueue_triangle(Vector3::new(1.0, -1.0, -1.0),Vector3::new(1.0, 1.0, -1.0), Vector3::new(1.0, -1.0, 1.0));
// program.enqueue_triangle(Vector3::new(1.0, 1.0, 1.0),Vector3::new(1.0, 1.0, -1.0), Vector3::new(1.0, -1.0, 1.0));
// program.uniform.1 = Vector3::new(1.0, 0.0, 0.0);
// program.enqueue_triangle(Vector3::new(-1.0, -1.0, -1.0),Vector3::new(-1.0, 1.0, -1.0), Vector3::new(-1.0, -1.0, 1.0));
// program.enqueue_triangle(Vector3::new(-1.0, 1.0, 1.0),Vector3::new(-1.0, 1.0, -1.0), Vector3::new(-1.0, -1.0, 1.0));
let mut i = 13;
let mut renderers = &program.regions;
let mut regions = buffer.regions(30, 30);
let count_y = renderers.len();
let count_x = renderers[0].len();
pool.scoped(|scoped| {
for y in 0..count_y {
for x in 0..count_x {
let renderer = &renderers[y][x];
unsafe {
let mut region = &mut *((&mut regions).get_unchecked_mut(y).get_unchecked_mut(x) as *mut _);
scoped.execute(move || renderer.render_region(&mut region));
}
}
}
});
//break;
//break;
window.set_title(&(1000.0 / clock.elapsed().as_millis() as f64).to_string());
buffer.finish_rendering();
window.update_with_buffer(&buffer.colors()).unwrap();
clock = std::time::Instant::now();
}
println!("Hello, world!");
}
|
use std::convert::Infallible;
use warp::{self, Filter};
use crate::db::Db;
use crate::handlers;
use crate::models::Customer;
/// All customer routes
pub fn customer_routes(
db: Db,
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
get_customer(db.clone())
.or(update_customer(db.clone()))
.or(delete_customer(db.clone()))
.or(create_customer(db.clone()))
.or(customers_list(db))
}
/// GET /customers
fn customers_list(
db: Db,
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
warp::path("customers")
.and(warp::get())
.and(with_db(db))
.and_then(handlers::list_customers)
}
/// POST /customers
fn create_customer(
db: Db,
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
warp::path("customers")
.and(warp::post())
.and(json_body())
.and(with_db(db))
.and_then(handlers::create_customer)
}
/// GET /customers/{guid}
fn get_customer(
db: Db,
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
warp::path!("customers" / String)
.and(warp::get())
.and(with_db(db))
.and_then(handlers::get_customer)
}
/// PUT /customers/{guid}
fn update_customer(
db: Db,
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
warp::path!("customers" / String)
.and(warp::put())
.and(json_body())
.and(with_db(db))
.and_then(handlers::update_customer)
}
/// DELETE /customers/{guid}
fn delete_customer(
db: Db
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
warp::path!("customers" / String)
.and(warp::delete())
.and(with_db(db))
.and_then(handlers::delete_customer)
}
fn with_db(db: Db) -> impl Filter<Extract = (Db,), Error = Infallible> + Clone {
warp::any().map(move || db.clone())
}
fn json_body() -> impl Filter<Extract = (Customer,), Error = warp::Rejection> + Clone {
warp::body::content_length_limit(1024 * 16).and(warp::body::json())
}
|
use std::collections::HashSet;
use anyhow::*;
use nom::{
branch::alt,
bytes::complete::tag,
character::complete::char,
character::complete::digit1,
combinator::{map, map_res},
sequence::tuple,
Finish, IResult,
};
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum Op {
Acc,
Jmp,
Nop,
}
impl std::fmt::Display for Op {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", match *self {
Self::Acc => "acc",
Self::Jmp => "jmp",
Self::Nop => "nop",
})
}
}
#[derive(Debug, Clone, Copy)]
pub struct Inst {
op: Op,
offset: i32,
}
impl std::fmt::Display for Inst {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{} {:+}", self.op, self.offset)
}
}
fn parse_inst(input: &str) -> IResult<&str, Inst> {
map(
tuple((
alt((tag("acc"), tag("jmp"), tag("nop"))),
tag(" "),
alt((char('-'), char('+'))),
map_res(digit1, |s: &str| s.parse::<i32>()),
)),
|(op, _, sign, mut offset)| {
if sign == '-' {
offset *= -1;
}
let op = match op {
"acc" => Op::Acc,
"jmp" => Op::Jmp,
"nop" => Op::Nop,
_ => unreachable!(),
};
Inst { op, offset }
},
)(input)
}
fn check_prg_termination(prg: &[Inst]) -> Option<i32> {
let mut acc = 0i32;
let mut addr = 0i32;
let mut visited_addr = HashSet::new();
loop {
if visited_addr.contains(&addr) {
// infinite loop
break None;
} else if addr == prg.len() as i32 {
break Some(acc);
} else {
visited_addr.insert(addr);
}
let i = &prg[addr as usize];
match i.op {
Op::Acc => {
acc += i.offset;
addr += 1;
}
Op::Jmp => addr += i.offset,
Op::Nop => addr += 1,
}
}
}
fn mutate_prg<F>(prg: &[Inst], addr: i32, mutation: F) -> Vec<Inst>
where
F: Fn(&mut Inst)
{
let mut new_prg = prg.to_vec();
if let Some(i) = new_prg.get_mut(addr as usize) {
mutation(i);
}
new_prg
}
fn parse_program(input: &str) -> Result<Vec<Inst>> {
input
.lines()
.map(|line| {
parse_inst(line)
.finish()
.map(|v| v.1)
.map_err(|e| format_err!("Failed to parse instruction: {}", e.to_string()))
})
.collect::<Result<Vec<_>>>()
}
fn part2(prg: &[Inst]) -> Option<i32> {
let nop_addrs: Vec<_> = prg
.iter()
.enumerate()
.filter_map(|(addr, i)| if i.op == Op::Nop { Some(addr) } else { None })
.collect();
let jmp_addrs: Vec<_> = prg
.iter()
.enumerate()
.filter_map(|(addr, i)| if i.op == Op::Jmp { Some(addr) } else { None })
.collect();
nop_addrs
.iter()
.find_map(|addr| check_prg_termination(&mutate_prg(&prg, *addr as i32, |mut i| i.op = Op::Jmp)))
.or_else(|| {
jmp_addrs
.iter()
.find_map(|addr| check_prg_termination(&mutate_prg(&prg, *addr as i32, |mut i| i.op = Op::Nop)))
})
}
fn main() -> Result<()> {
let input = advent20::input_string()?;
let prg = parse_program(&input)?;
// dbg!(instructions);
let mut acc = 0i32;
let mut addr = 0i32;
let mut visited_addr = HashSet::new();
loop {
if visited_addr.contains(&addr) {
break;
} else {
visited_addr.insert(addr);
}
let i = &prg[addr as usize];
match i.op {
Op::Acc => {
acc += i.offset;
addr += 1;
}
Op::Jmp => addr += i.offset,
Op::Nop => addr += 1,
}
}
println!("part 1: {}", acc);
let res = part2(&prg).unwrap();
println!("part 2: {}", res);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test() {
let input = r"nop +0
acc +1
jmp +4
acc +3
jmp -3
acc -99
acc +1
jmp -4
acc +6";
let prg = parse_program(input).unwrap();
println!("prg:");
prg.iter().for_each(|i| println!("{}", i));
println!("prg2:");
let prg2 = mutate_prg(&prg, 2, |mut i| i.op = Op::Nop);
prg2.iter().for_each(|i| println!("{}", i));
assert_eq!(Some(8), part2(&prg));
}
}
|
#[doc = "Register `IER` reader"]
pub type R = crate::R<IER_SPEC>;
#[doc = "Register `IER` writer"]
pub type W = crate::W<IER_SPEC>;
#[doc = "Field `ADRDYIE` reader - ADC ready interrupt enable This bit is set and cleared by software to enable/disable the ADC Ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type ADRDYIE_R = crate::BitReader<ADRDYIE_A>;
#[doc = "ADC ready interrupt enable This bit is set and cleared by software to enable/disable the ADC Ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ADRDYIE_A {
#[doc = "0: ADRDY interrupt disabled"]
Disabled = 0,
#[doc = "1: ADRDY interrupt enabled. An interrupt is generated when the ADRDY bit is set."]
Enabled = 1,
}
impl From<ADRDYIE_A> for bool {
#[inline(always)]
fn from(variant: ADRDYIE_A) -> Self {
variant as u8 != 0
}
}
impl ADRDYIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> ADRDYIE_A {
match self.bits {
false => ADRDYIE_A::Disabled,
true => ADRDYIE_A::Enabled,
}
}
#[doc = "ADRDY interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == ADRDYIE_A::Disabled
}
#[doc = "ADRDY interrupt enabled. An interrupt is generated when the ADRDY bit is set."]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == ADRDYIE_A::Enabled
}
}
#[doc = "Field `ADRDYIE` writer - ADC ready interrupt enable This bit is set and cleared by software to enable/disable the ADC Ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type ADRDYIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, ADRDYIE_A>;
impl<'a, REG, const O: u8> ADRDYIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "ADRDY interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(ADRDYIE_A::Disabled)
}
#[doc = "ADRDY interrupt enabled. An interrupt is generated when the ADRDY bit is set."]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(ADRDYIE_A::Enabled)
}
}
#[doc = "Field `EOSMPIE` reader - End of sampling flag interrupt enable This bit is set and cleared by software to enable/disable the end of the sampling phase interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOSMPIE_R = crate::BitReader<EOSMPIE_A>;
#[doc = "End of sampling flag interrupt enable This bit is set and cleared by software to enable/disable the end of the sampling phase interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EOSMPIE_A {
#[doc = "0: EOSMP interrupt disabled"]
Disabled = 0,
#[doc = "1: EOSMP interrupt enabled. An interrupt is generated when the EOSMP bit is set."]
Enabled = 1,
}
impl From<EOSMPIE_A> for bool {
#[inline(always)]
fn from(variant: EOSMPIE_A) -> Self {
variant as u8 != 0
}
}
impl EOSMPIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOSMPIE_A {
match self.bits {
false => EOSMPIE_A::Disabled,
true => EOSMPIE_A::Enabled,
}
}
#[doc = "EOSMP interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EOSMPIE_A::Disabled
}
#[doc = "EOSMP interrupt enabled. An interrupt is generated when the EOSMP bit is set."]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EOSMPIE_A::Enabled
}
}
#[doc = "Field `EOSMPIE` writer - End of sampling flag interrupt enable This bit is set and cleared by software to enable/disable the end of the sampling phase interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOSMPIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, EOSMPIE_A>;
impl<'a, REG, const O: u8> EOSMPIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "EOSMP interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(EOSMPIE_A::Disabled)
}
#[doc = "EOSMP interrupt enabled. An interrupt is generated when the EOSMP bit is set."]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(EOSMPIE_A::Enabled)
}
}
#[doc = "Field `EOCIE` reader - End of conversion interrupt enable This bit is set and cleared by software to enable/disable the end of conversion interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOCIE_R = crate::BitReader<EOCIE_A>;
#[doc = "End of conversion interrupt enable This bit is set and cleared by software to enable/disable the end of conversion interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EOCIE_A {
#[doc = "0: EOC interrupt disabled"]
Disabled = 0,
#[doc = "1: EOC interrupt enabled. An interrupt is generated when the EOC bit is set."]
Enabled = 1,
}
impl From<EOCIE_A> for bool {
#[inline(always)]
fn from(variant: EOCIE_A) -> Self {
variant as u8 != 0
}
}
impl EOCIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOCIE_A {
match self.bits {
false => EOCIE_A::Disabled,
true => EOCIE_A::Enabled,
}
}
#[doc = "EOC interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EOCIE_A::Disabled
}
#[doc = "EOC interrupt enabled. An interrupt is generated when the EOC bit is set."]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EOCIE_A::Enabled
}
}
#[doc = "Field `EOCIE` writer - End of conversion interrupt enable This bit is set and cleared by software to enable/disable the end of conversion interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOCIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, EOCIE_A>;
impl<'a, REG, const O: u8> EOCIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "EOC interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(EOCIE_A::Disabled)
}
#[doc = "EOC interrupt enabled. An interrupt is generated when the EOC bit is set."]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(EOCIE_A::Enabled)
}
}
#[doc = "Field `EOSIE` reader - End of conversion sequence interrupt enable This bit is set and cleared by software to enable/disable the end of sequence of conversions interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOSIE_R = crate::BitReader<EOSIE_A>;
#[doc = "End of conversion sequence interrupt enable This bit is set and cleared by software to enable/disable the end of sequence of conversions interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EOSIE_A {
#[doc = "0: EOS interrupt disabled"]
Disabled = 0,
#[doc = "1: EOS interrupt enabled. An interrupt is generated when the EOS bit is set."]
Enabled = 1,
}
impl From<EOSIE_A> for bool {
#[inline(always)]
fn from(variant: EOSIE_A) -> Self {
variant as u8 != 0
}
}
impl EOSIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOSIE_A {
match self.bits {
false => EOSIE_A::Disabled,
true => EOSIE_A::Enabled,
}
}
#[doc = "EOS interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EOSIE_A::Disabled
}
#[doc = "EOS interrupt enabled. An interrupt is generated when the EOS bit is set."]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EOSIE_A::Enabled
}
}
#[doc = "Field `EOSIE` writer - End of conversion sequence interrupt enable This bit is set and cleared by software to enable/disable the end of sequence of conversions interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOSIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, EOSIE_A>;
impl<'a, REG, const O: u8> EOSIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "EOS interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(EOSIE_A::Disabled)
}
#[doc = "EOS interrupt enabled. An interrupt is generated when the EOS bit is set."]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(EOSIE_A::Enabled)
}
}
#[doc = "Field `OVRIE` reader - Overrun interrupt enable This bit is set and cleared by software to enable/disable the overrun interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type OVRIE_R = crate::BitReader<OVRIE_A>;
#[doc = "Overrun interrupt enable This bit is set and cleared by software to enable/disable the overrun interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum OVRIE_A {
#[doc = "0: Overrun interrupt disabled"]
Disabled = 0,
#[doc = "1: Overrun interrupt enabled. An interrupt is generated when the OVR bit is set."]
Enabled = 1,
}
impl From<OVRIE_A> for bool {
#[inline(always)]
fn from(variant: OVRIE_A) -> Self {
variant as u8 != 0
}
}
impl OVRIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OVRIE_A {
match self.bits {
false => OVRIE_A::Disabled,
true => OVRIE_A::Enabled,
}
}
#[doc = "Overrun interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == OVRIE_A::Disabled
}
#[doc = "Overrun interrupt enabled. An interrupt is generated when the OVR bit is set."]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == OVRIE_A::Enabled
}
}
#[doc = "Field `OVRIE` writer - Overrun interrupt enable This bit is set and cleared by software to enable/disable the overrun interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type OVRIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, OVRIE_A>;
impl<'a, REG, const O: u8> OVRIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Overrun interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(OVRIE_A::Disabled)
}
#[doc = "Overrun interrupt enabled. An interrupt is generated when the OVR bit is set."]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(OVRIE_A::Enabled)
}
}
#[doc = "Field `AWD1IE` reader - Analog watchdog 1 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type AWD1IE_R = crate::BitReader<AWD1IE_A>;
#[doc = "Analog watchdog 1 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AWD1IE_A {
#[doc = "0: Analog watchdog interrupt disabled"]
Disabled = 0,
#[doc = "1: Analog watchdog interrupt enabled"]
Enabled = 1,
}
impl From<AWD1IE_A> for bool {
#[inline(always)]
fn from(variant: AWD1IE_A) -> Self {
variant as u8 != 0
}
}
impl AWD1IE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> AWD1IE_A {
match self.bits {
false => AWD1IE_A::Disabled,
true => AWD1IE_A::Enabled,
}
}
#[doc = "Analog watchdog interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == AWD1IE_A::Disabled
}
#[doc = "Analog watchdog interrupt enabled"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == AWD1IE_A::Enabled
}
}
#[doc = "Field `AWD1IE` writer - Analog watchdog 1 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type AWD1IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, AWD1IE_A>;
impl<'a, REG, const O: u8> AWD1IE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Analog watchdog interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(AWD1IE_A::Disabled)
}
#[doc = "Analog watchdog interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(AWD1IE_A::Enabled)
}
}
#[doc = "Field `AWD2IE` reader - Analog watchdog 2 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub use AWD1IE_R as AWD2IE_R;
#[doc = "Field `AWD3IE` reader - Analog watchdog 3 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub use AWD1IE_R as AWD3IE_R;
#[doc = "Field `AWD2IE` writer - Analog watchdog 2 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub use AWD1IE_W as AWD2IE_W;
#[doc = "Field `AWD3IE` writer - Analog watchdog 3 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub use AWD1IE_W as AWD3IE_W;
#[doc = "Field `EOCALIE` reader - End of calibration interrupt enable This bit is set and cleared by software to enable/disable the end of calibration interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOCALIE_R = crate::BitReader<EOCALIE_A>;
#[doc = "End of calibration interrupt enable This bit is set and cleared by software to enable/disable the end of calibration interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EOCALIE_A {
#[doc = "0: End of calibration interrupt disabled"]
Disabled = 0,
#[doc = "1: End of calibration interrupt enabled"]
Enabled = 1,
}
impl From<EOCALIE_A> for bool {
#[inline(always)]
fn from(variant: EOCALIE_A) -> Self {
variant as u8 != 0
}
}
impl EOCALIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EOCALIE_A {
match self.bits {
false => EOCALIE_A::Disabled,
true => EOCALIE_A::Enabled,
}
}
#[doc = "End of calibration interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == EOCALIE_A::Disabled
}
#[doc = "End of calibration interrupt enabled"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == EOCALIE_A::Enabled
}
}
#[doc = "Field `EOCALIE` writer - End of calibration interrupt enable This bit is set and cleared by software to enable/disable the end of calibration interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type EOCALIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, EOCALIE_A>;
impl<'a, REG, const O: u8> EOCALIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "End of calibration interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(EOCALIE_A::Disabled)
}
#[doc = "End of calibration interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(EOCALIE_A::Enabled)
}
}
#[doc = "Field `CCRDYIE` reader - Channel Configuration Ready Interrupt enable This bit is set and cleared by software to enable/disable the channel configuration ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type CCRDYIE_R = crate::BitReader<CCRDYIE_A>;
#[doc = "Channel Configuration Ready Interrupt enable This bit is set and cleared by software to enable/disable the channel configuration ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CCRDYIE_A {
#[doc = "0: Channel configuration ready interrupt disabled"]
Disabled = 0,
#[doc = "1: Channel configuration ready interrupt enabled"]
Enabled = 1,
}
impl From<CCRDYIE_A> for bool {
#[inline(always)]
fn from(variant: CCRDYIE_A) -> Self {
variant as u8 != 0
}
}
impl CCRDYIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> CCRDYIE_A {
match self.bits {
false => CCRDYIE_A::Disabled,
true => CCRDYIE_A::Enabled,
}
}
#[doc = "Channel configuration ready interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == CCRDYIE_A::Disabled
}
#[doc = "Channel configuration ready interrupt enabled"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == CCRDYIE_A::Enabled
}
}
#[doc = "Field `CCRDYIE` writer - Channel Configuration Ready Interrupt enable This bit is set and cleared by software to enable/disable the channel configuration ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
pub type CCRDYIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, CCRDYIE_A>;
impl<'a, REG, const O: u8> CCRDYIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Channel configuration ready interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(CCRDYIE_A::Disabled)
}
#[doc = "Channel configuration ready interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(CCRDYIE_A::Enabled)
}
}
impl R {
#[doc = "Bit 0 - ADC ready interrupt enable This bit is set and cleared by software to enable/disable the ADC Ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn adrdyie(&self) -> ADRDYIE_R {
ADRDYIE_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - End of sampling flag interrupt enable This bit is set and cleared by software to enable/disable the end of the sampling phase interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn eosmpie(&self) -> EOSMPIE_R {
EOSMPIE_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - End of conversion interrupt enable This bit is set and cleared by software to enable/disable the end of conversion interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn eocie(&self) -> EOCIE_R {
EOCIE_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - End of conversion sequence interrupt enable This bit is set and cleared by software to enable/disable the end of sequence of conversions interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn eosie(&self) -> EOSIE_R {
EOSIE_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Overrun interrupt enable This bit is set and cleared by software to enable/disable the overrun interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn ovrie(&self) -> OVRIE_R {
OVRIE_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 7 - Analog watchdog 1 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn awd1ie(&self) -> AWD1IE_R {
AWD1IE_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - Analog watchdog 2 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn awd2ie(&self) -> AWD2IE_R {
AWD2IE_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Analog watchdog 3 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn awd3ie(&self) -> AWD3IE_R {
AWD3IE_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 11 - End of calibration interrupt enable This bit is set and cleared by software to enable/disable the end of calibration interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn eocalie(&self) -> EOCALIE_R {
EOCALIE_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 13 - Channel Configuration Ready Interrupt enable This bit is set and cleared by software to enable/disable the channel configuration ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
pub fn ccrdyie(&self) -> CCRDYIE_R {
CCRDYIE_R::new(((self.bits >> 13) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - ADC ready interrupt enable This bit is set and cleared by software to enable/disable the ADC Ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn adrdyie(&mut self) -> ADRDYIE_W<IER_SPEC, 0> {
ADRDYIE_W::new(self)
}
#[doc = "Bit 1 - End of sampling flag interrupt enable This bit is set and cleared by software to enable/disable the end of the sampling phase interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn eosmpie(&mut self) -> EOSMPIE_W<IER_SPEC, 1> {
EOSMPIE_W::new(self)
}
#[doc = "Bit 2 - End of conversion interrupt enable This bit is set and cleared by software to enable/disable the end of conversion interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn eocie(&mut self) -> EOCIE_W<IER_SPEC, 2> {
EOCIE_W::new(self)
}
#[doc = "Bit 3 - End of conversion sequence interrupt enable This bit is set and cleared by software to enable/disable the end of sequence of conversions interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn eosie(&mut self) -> EOSIE_W<IER_SPEC, 3> {
EOSIE_W::new(self)
}
#[doc = "Bit 4 - Overrun interrupt enable This bit is set and cleared by software to enable/disable the overrun interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn ovrie(&mut self) -> OVRIE_W<IER_SPEC, 4> {
OVRIE_W::new(self)
}
#[doc = "Bit 7 - Analog watchdog 1 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn awd1ie(&mut self) -> AWD1IE_W<IER_SPEC, 7> {
AWD1IE_W::new(self)
}
#[doc = "Bit 8 - Analog watchdog 2 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn awd2ie(&mut self) -> AWD2IE_W<IER_SPEC, 8> {
AWD2IE_W::new(self)
}
#[doc = "Bit 9 - Analog watchdog 3 interrupt enable This bit is set and cleared by software to enable/disable the analog watchdog interrupt. Note: The Software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn awd3ie(&mut self) -> AWD3IE_W<IER_SPEC, 9> {
AWD3IE_W::new(self)
}
#[doc = "Bit 11 - End of calibration interrupt enable This bit is set and cleared by software to enable/disable the end of calibration interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn eocalie(&mut self) -> EOCALIE_W<IER_SPEC, 11> {
EOCALIE_W::new(self)
}
#[doc = "Bit 13 - Channel Configuration Ready Interrupt enable This bit is set and cleared by software to enable/disable the channel configuration ready interrupt. Note: The software is allowed to write this bit only when ADSTART bit is cleared to 0 (this ensures that no conversion is ongoing)."]
#[inline(always)]
#[must_use]
pub fn ccrdyie(&mut self) -> CCRDYIE_W<IER_SPEC, 13> {
CCRDYIE_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 = "ADC interrupt enable register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`ier::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 [`ier::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct IER_SPEC;
impl crate::RegisterSpec for IER_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`ier::R`](R) reader structure"]
impl crate::Readable for IER_SPEC {}
#[doc = "`write(|w| ..)` method takes [`ier::W`](W) writer structure"]
impl crate::Writable for IER_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets IER to value 0"]
impl crate::Resettable for IER_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use core::cmp;
use cast::u32;
use stm32::{FLASH, RCC};
use time::Hertz;
/// Extension trait that constrains the `RCC` peripheral
pub trait RccExt {
/// Constrains the `RCC` peripheral so it plays nicely with the other abstractions
fn constrain(self) -> Rcc;
}
impl RccExt for RCC {
fn constrain(self) -> Rcc {
Rcc {
cfgr: CFGR {
hclk: None,
pclk: None,
sysclk: None,
},
}
}
}
/// Constrained RCC peripheral
pub struct Rcc {
pub cfgr: CFGR,
}
const HSI: u32 = 8_000_000; // Hz
pub struct CFGR {
hclk: Option<u32>,
pclk: Option<u32>,
sysclk: Option<u32>,
}
impl CFGR {
pub fn hclk<F>(mut self, freq: F) -> Self
where
F: Into<Hertz>,
{
self.hclk = Some(freq.into().0);
self
}
pub fn pclk<F>(mut self, freq: F) -> Self
where
F: Into<Hertz>,
{
self.pclk = Some(freq.into().0);
self
}
pub fn sysclk<F>(mut self, freq: F) -> Self
where
F: Into<Hertz>,
{
self.sysclk = Some(freq.into().0);
self
}
pub fn freeze(self) -> Clocks {
let pllmul = (4 * self.sysclk.unwrap_or(HSI) + HSI) / HSI / 2;
let pllmul = cmp::min(cmp::max(pllmul, 2), 16);
let sysclk = pllmul * HSI / 2;
let pllmul_bits = if pllmul == 2 {
None
} else {
Some(pllmul as u8 - 2)
};
let hpre_bits = self
.hclk
.map(|hclk| match sysclk / hclk {
0 => unreachable!(),
1 => 0b0111,
2 => 0b1000,
3...5 => 0b1001,
6...11 => 0b1010,
12...39 => 0b1011,
40...95 => 0b1100,
96...191 => 0b1101,
192...383 => 0b1110,
_ => 0b1111,
})
.unwrap_or(0b0111);
let hclk = sysclk / (1 << (hpre_bits - 0b0111));
let ppre_bits = self
.pclk
.map(|pclk| match hclk / pclk {
0 => unreachable!(),
1 => 0b011,
2 => 0b100,
3...5 => 0b101,
6...11 => 0b110,
_ => 0b111,
})
.unwrap_or(0b011);
let ppre: u8 = 1 << (ppre_bits - 0b011);
let pclk = hclk / u32(ppre);
// adjust flash wait states
unsafe {
let flash = &*FLASH::ptr();
flash.acr.write(|w| {
w.latency().bits(if sysclk <= 24_000_000 {
0b000
} else if sysclk <= 48_000_000 {
0b001
} else {
0b010
})
})
}
let rcc = unsafe { &*RCC::ptr() };
if let Some(pllmul_bits) = pllmul_bits {
// use PLL as source
rcc.cfgr.write(|w| unsafe { w.pllmul().bits(pllmul_bits) });
rcc.cr.write(|w| w.pllon().set_bit());
while rcc.cr.read().pllrdy().bit_is_clear() {}
rcc.cfgr.modify(|_, w| unsafe {
w.ppre().bits(ppre_bits).hpre().bits(hpre_bits).sw().bits(2)
});
} else {
// use HSI as source
rcc.cfgr
.write(|w| unsafe { w.ppre().bits(ppre_bits).hpre().bits(hpre_bits).sw().bits(0) });
}
Clocks {
hclk: Hertz(hclk),
pclk: Hertz(pclk),
sysclk: Hertz(sysclk),
}
}
}
/// Frozen clock frequencies
///
/// The existence of this value indicates that the clock configuration can no longer be changed
#[derive(Clone, Copy)]
pub struct Clocks {
hclk: Hertz,
pclk: Hertz,
sysclk: Hertz,
}
impl Clocks {
/// Returns the frequency of the AHB
pub fn hclk(&self) -> Hertz {
self.hclk
}
/// Returns the frequency of the APB
pub fn pclk(&self) -> Hertz {
self.pclk
}
/// Returns the system (core) frequency
pub fn sysclk(&self) -> Hertz {
self.sysclk
}
}
|
pub use self::ai::AiSystem;
pub use self::camera::PanningSystem;
pub use self::collision::{CollisionSystem, DestroySystemDesc};
pub use self::contract::{AcceptContractSystemDesc, ExpireContractSystem, FulfillContractSystem};
pub use self::move_ships::{
ChaseSystem, DockingSystem, MoveShipsSystem, PatrolSystem, PlotCourseSystem,
};
pub use self::select::{SelectPortSystem, SelectShipSystem, SelectSystem};
pub use self::time::{ExpirationSystem, UpdateTimeSystem};
pub use self::ui::{
ContractPanelSystemDesc, GameSpeedSystemDesc, NotificationSystem, PlayerStatusSystemDesc,
PortPanelSystemDesc, ShipPanelSystemDesc,
};
mod ai;
mod camera;
mod collision;
mod contract;
mod move_ships;
mod select;
mod time;
mod ui;
|
enum IpAddr {
V4(String),
V6(String),
}
fn route(ip_type: IpAdrrKind) {}
fn main() {
let ip_v_four = IpAdrr::V4(String::from("127.0.0.1"));
let ip_v_six = IpAdrrKind::V6(String::from("::1"));
}
|
use std::net::{TcpListener, TcpStream};
use std::thread;
use std::io::BufReader;
fn main() {
let listener = TcpListener::bind("127.0.0.1:3000").unwrap();
for stream in listener.incoming() {
match stream {
Err(_) => { /* ์ ๋นํ ์๋ฌ์ฒ๋ฆฌ */ }
Ok(stream) => {
// ์ปค๋ฅ์
์ฑ๊ณต, ์ ์ค๋ ๋์์ ์ฒ๋ฆฌ
thread::spawn(move|| handle_client(stream));
}
}
}
}
fn handle_client(stream: TcpStream) {
use std::io::{BufRead, Write}; // BufRead trait ์ฌ์ฉ
let mut writer = stream.try_clone().unwrap(); // TODO: ์๋ฌ์ฒ๋ฆฌ
let reader = BufReader::new(stream);
for line in reader.lines() {
let line = line.unwrap(); // IO ์๋ฌ์ผ๊ฒฝ์ฐ ํจ๋
writer.write_all(b"Hello, world!\r\n").unwrap();
println!("{}", line);
}
}
|
pub mod buffer;
pub mod command;
pub mod completion;
pub mod container;
pub mod editor;
pub mod explorer;
pub mod find;
pub mod keypress;
pub mod language;
pub mod lsp;
pub mod movement;
pub mod palette;
pub mod panel;
pub mod proxy;
pub mod scroll;
pub mod signature;
pub mod split;
pub mod source_control;
pub mod outline;
pub mod state;
pub mod status;
pub mod theme;
pub mod window;
|
use std::sync::Arc;
use crate::{
commands::slash,
common::{
redis::get,
tts::{create_tts_engine, TtsType},
},
data::{DatabasePool, GcpAccessToken},
tasks,
};
use api_models::guild::Guild as GuildModel;
use regex::Regex;
use serenity::{
async_trait,
client::{Context, EventHandler},
model::{
channel::Message,
gateway::Ready,
guild::Guild,
id::{GuildId, UserId},
interactions::Interaction,
},
prelude::Mutex,
};
use songbird::{
input::restartable::Restartable, Event, EventContext, EventHandler as VoiceEventHandler,
TrackEvent,
};
use tokio::fs;
use tts::TtsEngine;
pub struct Handler {
user_id: Mutex<Option<UserId>>,
run_loop: Mutex<bool>,
}
impl Handler {
pub fn new() -> Handler {
let run_loop = Mutex::new(true);
Self {
user_id: Mutex::new(None),
run_loop,
}
}
}
#[async_trait]
impl EventHandler for Handler {
async fn cache_ready(&self, ctx: Context, _guilds: Vec<GuildId>) {
info!("Cache is ready");
if *self.run_loop.lock().await {
*self.run_loop.lock().await = false;
let ctx = Arc::new(ctx);
let ctx2 = Arc::clone(&ctx);
let token_loop =
tokio::spawn(async move { tasks::token_renewer::renew_token(ctx2).await });
let _ = token_loop.await;
}
}
async fn ready(&self, _ctx: Context, ready: Ready) {
*self.user_id.lock().await = Some(ready.user.id);
info!("Logged in as {}", ready.user.name);
}
async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
if let Err(e) = slash::handle_slash_command(&ctx, interaction).await {
error!("Failed to reply slash command: {:?}", e);
}
}
async fn guild_create(&self, ctx: Context, guild: Guild, is_new: bool) {
info!("Guild {} recieved; is_new: {}", guild.name, is_new);
let pool = {
let data = ctx.data.read().await;
match data.get::<DatabasePool>() {
Some(pool) => pool.clone(),
None => {
error!("Failed to get database pool");
return;
}
}
};
if let Err(sqlx::Error::RowNotFound) = GuildModel::get(&pool, guild.id.0 as i64).await {
if let Err(e) = GuildModel::create(
&pool,
guild.id.0 as i64,
guild.name.clone(),
guild
.icon_url()
.unwrap_or("".to_string())
.replace(".webp", ".png"),
"ja-JP".to_string(),
"JP-Female-Normal-A".to_string(),
)
.await
{
error!("Failed to insert guild: {:?}", e);
}
}
}
async fn message(&self, ctx: Context, msg: Message) {
// ็บ่จๆกไปถ
// 1) Botใฎ็บ่จใงใฏใชใ
// 2) [z.]ใใๅงใพใใชใ
// 3) z.joinใ้ไฟกใใใใฃใณใใซใงใใ
// 4) ใใฎBotใVCใซๅ
ฅๅฎคใใฆใใ
// 5) </slash:interactid> ~~ใฎใกใใปใผใธใฏ็ก่ฆใใ
// 1) & 2)
if msg.author.bot || msg.content.starts_with("z.") {
return;
}
// 4)
let is_bot_in_vc = match msg.guild(&ctx.cache).await {
Some(guild) => {
let user_id = self.user_id.lock().await;
if let Some(user_id) = user_id.as_ref() {
let bot_user = guild.voice_states.get(&user_id);
bot_user.is_some()
} else {
false
}
}
None => false,
};
if !is_bot_in_vc {
return;
}
// 3)
let guild = match msg.guild(&ctx.cache).await {
Some(guild) => guild,
None => return,
};
let guild_id = guild.id;
let channel_id = msg.channel_id.0;
match get::<_, u64>(&ctx, &format!("bot:channel:joined:{}", guild_id.0)).await {
Ok(v) => {
if v != channel_id {
return;
}
}
Err(e) => {
error!("{:?}", e);
}
}
// 5)
let re = Regex::new(r"^<.+?:\d{18,20}>").unwrap();
if re.is_match(&msg.content) {
return;
}
let manager = match songbird::get(&ctx).await {
Some(manager) => manager.clone(),
None => return,
};
let pool = {
let data = ctx.data.as_ref().read().await;
data.get::<DatabasePool>().unwrap().clone()
};
// * TTS Start * //
let token = {
let data = ctx.data.read().await;
let token = data.get::<GcpAccessToken>().unwrap();
let token = token.lock().await;
token.show()
};
let model = match GuildModel::get(&pool, guild_id.0 as i64).await {
Ok(g) => match g.voice_model.as_str() {
"JP-Female-Normal-A" => TtsType::GcpJpFemaleNormalA(token),
"JP-Female-Normal-B" => TtsType::GcpJpFemaleNormalB(token),
"JP-Female-Premium-A" => TtsType::GcpJpFemalePremiumA(token),
"JP-Female-Premium-B" => TtsType::GcpJpFemalePremiumB(token),
"JP-Male-Normal-A" => TtsType::GcpJpMaleNormalA(token),
"JP-Male-Normal-B" => TtsType::GcpJpMaleNormalB(token),
"JP-Male-Premium-A" => TtsType::GcpJpMalePremiumA(token),
"JP-Male-Premium-B" => TtsType::GcpJpMalePremiumB(token),
_ => return,
},
Err(e) => {
error!("{:?}", e);
return;
}
};
let engine = create_tts_engine(model).unwrap().ensure_gcp();
let path = dbg! {match engine.save(&msg.content.replace("\n", "๏ผ")).await {
Ok(path) => path,
Err(e) => {
error!("TTS save error: {:?}", e);
return;
}
}};
// * TTS End * //
if let Some(handler) = manager.get(guild_id) {
let mut handler = handler.lock().await;
let src = match Restartable::ffmpeg(path.clone(), false).await {
Ok(src) => src,
Err(e) => {
error!("TTS convert error; {:?}", e);
return;
}
};
handler.enqueue_source(src.into());
let _ = handler.add_global_event(Event::Track(TrackEvent::End), FileRemover { path });
}
}
}
struct FileRemover {
path: String,
}
#[async_trait]
impl VoiceEventHandler for FileRemover {
async fn act(&self, _ctx: &EventContext<'_>) -> Option<Event> {
let _ = fs::remove_file(&self.path).await;
None
}
}
|
pub use self::aggregate::Aggregate;
pub use self::filter::{Filter, FilterPredicate};
pub use self::join::{Join, JoinPredicate};
pub use self::project::ProjectIterator;
pub use self::seqscan::SeqScan;
pub use self::tuple_iterator::TupleIterator;
use common::{CrustyError, TableSchema, Tuple};
mod aggregate;
mod filter;
mod join;
mod project;
mod seqscan;
mod testutil;
mod tuple_iterator;
pub trait OpIterator {
/// Opens the iterator. This must be called before any of the other methods.
fn open(&mut self) -> Result<(), CrustyError>;
/// Advances the iterator and returns the next tuple from the operator.
///
/// Returns None when iteration is finished.
///
/// # Panics
///
/// Panic if iterator is not open.
fn next(&mut self) -> Result<Option<Tuple>, CrustyError>;
/// Closes the iterator.
fn close(&mut self) -> Result<(), CrustyError>;
/// Returns the iterator to the start.
///
/// Returns None when iteration is finished.
///
/// # Panics
///
/// Panic if iterator is not open.
fn rewind(&mut self) -> Result<(), CrustyError>;
/// Returns the schema associated with this OpIterator.
fn get_schema(&self) -> &TableSchema;
}
|
fn main() {
let mut m1: Vec<Vec<f64>> = vec![vec![1.0,2.0],vec![3.0,4.0]];
let mut r_m1 = &mut m1;
let rr_m1 = &mut r_m1;
let mut m2: Vec<Vec<f64>> = vec![vec![1.0, 2.0, 3.0, 4.0], vec![4.0, 5.0, 6.0, 7.0], vec![7.0, 8.0, 9.0, 10.0], vec![10.0, 11.0, 12.0, 13.0]];
let mut r_m2 = &mut m2;
let rr_m2 = &mut r_m2;
let mut m3: Vec<Vec<f64>> = vec![vec![0.0, 1.0, 2.0, 3.0, 4.0],
vec![5.0, 6.0, 7.0, 8.0, 9.0],
vec![10.0, 11.0, 12.0, 13.0, 14.0],
vec![15.0, 16.0, 17.0, 18.0, 19.0],
vec![20.0, 21.0, 22.0, 23.0, 24.0]];
let mut r_m3 = &mut m3;
let rr_m3 = &mut r_m3;
println!("Determinant of m1: {}", determinant(rr_m1));
println!("Permanent of m1: {}", permanent(rr_m1));
println!("Determinant of m2: {}", determinant(rr_m2));
println!("Permanent of m2: {}", permanent(rr_m2));
println!("Determinant of m3: {}", determinant(rr_m3));
println!("Permanent of m3: {}", permanent(rr_m3));
}
fn minor( a: &mut Vec<Vec<f64>>, x: usize, y: usize) -> Vec<Vec<f64>> {
let mut out_vec: Vec<Vec<f64>> = vec![vec![0.0; a.len() - 1]; a.len() -1];
for i in 0..a.len()-1 {
for j in 0..a.len()-1 {
match () {
_ if (i < x && j < y) => {
out_vec[i][j] = a[i][j];
},
_ if (i >= x && j < y) => {
out_vec[i][j] = a[i + 1][j];
},
_ if (i < x && j >= y) => {
out_vec[i][j] = a[i][j + 1];
},
_ => { //i > x && j > y
out_vec[i][j] = a[i + 1][j + 1];
},
}
}
}
out_vec
}
fn determinant (matrix: &mut Vec<Vec<f64>>) -> f64 {
match () {
_ if (matrix.len() == 1) => {
matrix[0][0]
},
_ => {
let mut sign = 1.0;
let mut sum = 0.0;
for i in 0..matrix.len() {
sum = sum + sign * matrix[0][i] * determinant(&mut minor(matrix, 0, i));
sign = sign * -1.0;
}
sum
}
}
}
fn permanent (matrix: &mut Vec<Vec<f64>>) -> f64 {
match () {
_ if (matrix.len() == 1) => {
matrix[0][0]
},
_ => {
let mut sum = 0.0;
for i in 0..matrix.len() {
sum = sum + matrix[0][i] * permanent(&mut minor(matrix, 0, i));
}
sum
}
}
} |
//! Static predicate traits.
use std::fmt::Debug;
std_prelude!();
/// A predicate over a single variable.
///
/// For a given `T` implementing `Predicate`,
/// `T::default().fmt(..)`` should print the name
/// of the predicate, with angle brackets to indicate
/// generic predicate parameters.
pub trait Pred<T: ?Sized>: Default + Debug + Copy {
/// Attempts to accept a single `value`.
fn accept(value: &T) -> bool;
}
/// A predicate over two variables.
pub trait Pred2<T: ?Sized>: Default + Debug + Copy {
/// Attempts to accept a pair `(a, b)`.
fn accept(a: &T, b: &T) -> bool;
/// Attempts to accept a pair `(a, b)`.
fn accept_tup((a, b): (&T, &T)) -> bool {
Self::accept(a, b)
}
}
|
use {
super::{
localmap::{local_key, Entry, LocalKey},
Input,
},
crate::error::Error,
http::header::{HeaderName, HeaderValue},
mime::Mime,
};
pub trait FromHeaderValue: Sized {
type Error: Into<Error>;
fn from_header_value(h: &HeaderValue) -> Result<Self, Self::Error>;
}
impl FromHeaderValue for String {
type Error = Error;
#[inline]
fn from_header_value(h: &HeaderValue) -> Result<Self, Self::Error> {
Self::from_utf8(h.as_bytes().to_vec()).map_err(crate::error::bad_request)
}
}
impl FromHeaderValue for Mime {
type Error = Error;
#[inline]
fn from_header_value(h: &HeaderValue) -> Result<Self, Self::Error> {
h.to_str()
.map_err(crate::error::bad_request)?
.parse()
.map_err(crate::error::bad_request)
}
}
pub trait HeaderField {
type Value: FromHeaderValue + Send + 'static;
const NAME: &'static HeaderName;
const KEY: LocalKey<Option<Self::Value>>;
}
#[derive(Debug)]
pub struct ContentType(());
impl HeaderField for ContentType {
type Value = Mime;
const NAME: &'static HeaderName = &http::header::CONTENT_TYPE;
local_key! {
const KEY: Option<Self::Value>;
}
}
/// Parses the header field.
pub fn parse<'a, H>(input: &'a mut Input<'_>) -> Result<Option<&'a H::Value>, Error>
where
H: HeaderField,
{
match input.locals.entry(&H::KEY) {
Entry::Occupied(entry) => Ok(entry.into_mut().as_ref()),
Entry::Vacant(entry) => {
let value = match input.request.headers().get(H::NAME) {
Some(h) => FromHeaderValue::from_header_value(h)
.map(Some)
.map_err(Into::into)?,
None => None,
};
Ok(entry.insert(value).as_ref())
}
}
}
|
/*
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT license.
*/
pub mod scratch_traits;
pub use scratch_traits::*;
pub mod concurrent_queue;
pub use concurrent_queue::*;
pub mod pq_scratch;
pub use pq_scratch::*;
pub mod inmem_query_scratch;
pub use inmem_query_scratch::*;
pub mod scratch_store_manager;
pub use scratch_store_manager::*;
pub mod ssd_query_scratch;
pub use ssd_query_scratch::*;
pub mod ssd_thread_data;
pub use ssd_thread_data::*;
pub mod ssd_io_context;
pub use ssd_io_context::*;
|
use std::collections::BTreeMap;
type Map<T> = BTreeMap<String, T>;
#[derive(Debug, Clone, Copy)]
enum Binop {
Add,
Sub,
Mul,
Eq,
}
#[derive(Debug, Clone)]
enum Value {
IntVal(i32),
BoolVal(bool),
Closure(String, Box<Expr>, Map<Box<Value>>),
}
#[derive(Debug, Clone)]
enum Expr {
IntLit(i32),
BoolLit(bool),
Var(String),
Binop(Binop, Box<Expr>, Box<Expr>),
App(Box<Expr>, Box<Expr>),
Fun(String, Box<Expr>),
}
fn eval(expr: &Expr, env: &mut Map<Box<Value>>) -> Option<Box<Value>> {
let mut eval_binop = |op, e1, e2| {
let apply_binop = move |v1, v2| match op {
Binop::Add => Value::IntVal(v1 + v2),
Binop::Sub => Value::IntVal(v1 + v2),
Binop::Mul => Value::IntVal(v1 * v2),
Binop::Eq => Value::BoolVal(v1 == v2),
};
let ev1 = eval(e1, env)?;
let ev2 = eval(e2, env)?;
match (op, *ev1, *ev2) {
(_, Value::IntVal(v1), Value::IntVal(v2)) => Some(Box::new(apply_binop(v1, v2))),
(Binop::Eq, Value::BoolVal(b1), Value::BoolVal(b2)) => {
Some(Box::new(Value::BoolVal(b1 == b2)))
}
_ => unreachable!(),
}
};
match expr {
Expr::Var(x) => {
let val = env.get(x)?;
Some(val.clone())
}
Expr::IntLit(n) => Some(Box::new(Value::IntVal(*n))),
Expr::BoolLit(b) => Some(Box::new(Value::BoolVal(*b))),
Expr::Binop(op, exp1, exp2) => eval_binop(*op, exp1, exp2),
Expr::Fun(x, exp) => Some(Box::new(Value::Closure(
x.clone(),
exp.clone(),
env.clone(),
))),
Expr::App(fun, arg) => {
let arg = eval(arg, env)?;
let fun = eval(fun, env)?;
match *fun {
Value::Closure(x, body, mut fun_env) => {
fun_env.insert(x, arg);
eval(&*body, &mut fun_env)
}
_ => unreachable!(),
}
}
}
}
fn main() {
let var_name = "x".to_string();
let body = Box::new(Expr::Binop(
Binop::Add,
Box::new(Expr::Var(var_name.clone())),
Box::new(Expr::IntLit(10)),
));
let add_10 = Expr::Fun(var_name, body);
println!("add_10: [{:?}", add_10);
let app = Expr::App(Box::new(add_10), Box::new(Expr::IntLit(7)));
let mut env = Map::new();
match eval(&app, &mut env) {
None => println!("eval failed.\n"),
Some(val) => println!("{:?}", val),
}
}
|
// This file is part of Substrate.
// Copyright (C) 2020 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 2.0.0-rc6
#![allow(unused_parens)]
#![allow(unused_imports)]
use frame_support::{traits::Get, weights::Weight};
use sp_std::marker::PhantomData;
pub struct WeightInfo<T>(PhantomData<T>);
impl<T: frame_system::Trait> pallet_treasury::WeightInfo for WeightInfo<T> {
fn propose_spend() -> Weight {
(79604000 as Weight)
.saturating_add(T::DbWeight::get().reads(1 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn reject_proposal() -> Weight {
(61001000 as Weight)
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn approve_proposal() -> Weight {
(17835000 as Weight)
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(1 as Weight))
}
fn report_awesome(r: u32) -> Weight {
(101602000 as Weight)
.saturating_add((2000 as Weight).saturating_mul(r as Weight))
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
// WARNING! Some components were not used: ["r"]
fn retract_tip() -> Weight {
(82970000 as Weight)
.saturating_add(T::DbWeight::get().reads(1 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn tip_new(r: u32, t: u32) -> Weight {
(63995000 as Weight)
.saturating_add((2000 as Weight).saturating_mul(r as Weight))
.saturating_add((153000 as Weight).saturating_mul(t as Weight))
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn tip(t: u32) -> Weight {
(46765000 as Weight)
.saturating_add((711000 as Weight).saturating_mul(t as Weight))
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(1 as Weight))
}
fn close_tip(t: u32) -> Weight {
(160874000 as Weight)
.saturating_add((379000 as Weight).saturating_mul(t as Weight))
.saturating_add(T::DbWeight::get().reads(3 as Weight))
.saturating_add(T::DbWeight::get().writes(3 as Weight))
}
fn propose_bounty(d: u32) -> Weight {
(86198000 as Weight)
.saturating_add((1000 as Weight).saturating_mul(d as Weight))
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(4 as Weight))
}
fn approve_bounty() -> Weight {
(23063000 as Weight)
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn propose_curator() -> Weight {
(18890000 as Weight)
.saturating_add(T::DbWeight::get().reads(1 as Weight))
.saturating_add(T::DbWeight::get().writes(1 as Weight))
}
fn unassign_curator() -> Weight {
(66768000 as Weight)
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn accept_curator() -> Weight {
(69131000 as Weight)
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
}
fn award_bounty() -> Weight {
(48184000 as Weight)
.saturating_add(T::DbWeight::get().reads(1 as Weight))
.saturating_add(T::DbWeight::get().writes(1 as Weight))
}
fn claim_bounty() -> Weight {
(243104000 as Weight)
.saturating_add(T::DbWeight::get().reads(4 as Weight))
.saturating_add(T::DbWeight::get().writes(5 as Weight))
}
fn close_bounty_proposed() -> Weight {
(65917000 as Weight)
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().writes(3 as Weight))
}
fn close_bounty_active() -> Weight {
(157232000 as Weight)
.saturating_add(T::DbWeight::get().reads(3 as Weight))
.saturating_add(T::DbWeight::get().writes(4 as Weight))
}
fn extend_bounty_expiry() -> Weight {
(46216000 as Weight)
.saturating_add(T::DbWeight::get().reads(1 as Weight))
.saturating_add(T::DbWeight::get().writes(1 as Weight))
}
fn on_initialize_proposals(p: u32) -> Weight {
(119765000 as Weight)
.saturating_add((108368000 as Weight).saturating_mul(p as Weight))
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().reads((3 as Weight).saturating_mul(p as Weight)))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
.saturating_add(T::DbWeight::get().writes((3 as Weight).saturating_mul(p as Weight)))
}
fn on_initialize_bounties(b: u32) -> Weight {
(112536000 as Weight)
.saturating_add((107132000 as Weight).saturating_mul(b as Weight))
.saturating_add(T::DbWeight::get().reads(2 as Weight))
.saturating_add(T::DbWeight::get().reads((3 as Weight).saturating_mul(b as Weight)))
.saturating_add(T::DbWeight::get().writes(2 as Weight))
.saturating_add(T::DbWeight::get().writes((3 as Weight).saturating_mul(b as Weight)))
}
}
|
use crate::{
alloc::{Allocator, GlobalAllocator},
containers::Array,
};
use core::{
borrow::Borrow,
ops::{Deref, DerefMut},
};
pub struct WString<A: Allocator = GlobalAllocator>
{
buf: Array<u16, A>,
}
impl<A: Allocator> WString<A>
{
pub fn new_with(alloc: A) -> Self
{
Self {
buf: Array::new_with(alloc),
}
}
pub fn from_str_with(s: &str, alloc: A) -> Self
{
let w_iter = s.encode_utf16();
let mut buf = Array::new_with(alloc);
buf.reserve(w_iter.size_hint().0);
for wchar in w_iter
{
buf.push(wchar);
}
Self { buf }
}
pub fn push(&mut self, c: char)
{
let len = c.len_utf16();
self.buf.resize(self.buf.len() + len, 0);
let start = self.buf.len() - len;
c.encode_utf16(&mut self.buf[start..]);
}
}
impl WString<GlobalAllocator>
{
pub fn new() -> Self
{
Self::new_with(GlobalAllocator)
}
pub fn from_str(s: &str) -> Self
{
Self::from_str_with(s, GlobalAllocator)
}
}
impl<A: Allocator> AsRef<[u16]> for WString<A>
{
#[inline]
fn as_ref(&self) -> &[u16]
{
&self.buf
}
}
impl<A: Allocator> Borrow<[u16]> for WString<A>
{
#[inline]
fn borrow(&self) -> &[u16]
{
&self.buf
}
}
impl<A: Allocator> Deref for WString<A>
{
type Target = [u16];
#[inline]
fn deref(&self) -> &[u16]
{
&self.buf
}
}
impl<A: Allocator> DerefMut for WString<A>
{
#[inline]
fn deref_mut(&mut self) -> &mut [u16]
{
&mut self.buf
}
}
|
use crate::types;
#[derive(Clone, Debug, PartialEq)]
pub struct Declaration {
name: String,
type_: types::Function,
}
impl Declaration {
pub fn new(name: impl Into<String>, type_: types::Function) -> Self {
Self {
name: name.into(),
type_,
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn type_(&self) -> &types::Function {
&self.type_
}
}
|
use crate::appkit::NSMenuItem;
use crate::base::id;
// https://developer.apple.com/documentation/appkit/nsmenu
#[derive(Clone, Copy, Debug)]
#[repr(C)]
pub struct NSMenu(id);
impl Default for NSMenu {
fn default() -> Self {
Self::new()
}
}
impl NSMenu {
pub fn new() -> Self {
Self(unsafe { msg_send!(class!(NSMenu), new) })
}
pub fn alloc() -> Self {
Self(unsafe { msg_send!(class!(NSMenu), alloc) })
}
pub fn autorelease(self) -> Self {
Self(unsafe { msg_send!(self.0, autorelease) })
}
pub fn add(&mut self, item: NSMenuItem) {
unsafe {
let _: () = msg_send!(self.0, addItem: item);
}
}
}
|
use z80::Z80;
/*
** BIT b, r|(hl)
** Condition Bits: R01_
** Clocks:
** (hl): 3
** r: 2
*/
pub fn bit(z80: &mut Z80, op: u8) {
let val = match op & 0x7 {
0x6 => z80.mmu.rb(z80.r.get_hl()),
0x7 => z80.r.a,
0x0 => z80.r.b,
0x1 => z80.r.c,
0x2 => z80.r.d,
0x3 => z80.r.e,
0x4 => z80.r.h,
0x5 => z80.r.l,
_ => 0,
};
let bit_val = (op >> 3) & 0x7;
z80.r.set_half_carry(true);
z80.r.set_subtract(false);
if val & (1 << bit_val) == 0 {
z80.r.set_zero(true);
} else {
z80.r.set_zero(false);
}
if op & 0x7 == 0x6 {
z80.set_register_clock(3);
} else {
z80.set_register_clock(2);
}
}
|
use shrev::*;
use specs::*;
use types::*;
use dispatch::SystemInfo;
use component::channel::*;
use component::counter::*;
use component::event::TimerEvent;
use component::time::ThisFrame;
use protocol::server::ScoreUpdate;
use protocol::{to_bytes, ServerPacket};
use websocket::OwnedMessage;
pub struct UpdateScore {
reader: Option<OnPlayerKilledReader>,
}
#[derive(SystemData)]
pub struct UpdateScoreData<'a> {
pub entities: Entities<'a>,
pub channel: Read<'a, OnPlayerKilled>,
pub conns: Read<'a, Connections>,
pub timerevent: Write<'a, EventChannel<TimerEvent>>,
pub thisframe: Read<'a, ThisFrame>,
pub score: WriteStorage<'a, Score>,
pub powerups: WriteStorage<'a, Powerups>,
pub upgrades: WriteStorage<'a, Upgrades>,
pub earnings: WriteStorage<'a, Earnings>,
pub total_kills: WriteStorage<'a, TotalKills>,
pub total_deaths: WriteStorage<'a, TotalDeaths>,
}
impl UpdateScore {
pub fn new() -> Self {
Self { reader: None }
}
fn send_update<'a>(player: Entity, data: &UpdateScoreData<'a>) {
let score = *data.score.get(player).unwrap();
let earnings = data.earnings.get(player).unwrap().0;
let upgrades = data.upgrades.get(player).unwrap();
let total_kills = data.total_kills.get(player).unwrap().0;
let total_deaths = data.total_deaths.get(player).unwrap().0;
data.conns.send_to_all(OwnedMessage::Binary(
to_bytes(&ServerPacket::ScoreUpdate(ScoreUpdate {
id: player,
score,
earnings,
upgrades: upgrades.unused,
total_deaths,
total_kills,
})).unwrap(),
));
}
}
impl<'a> System<'a> for UpdateScore {
type SystemData = UpdateScoreData<'a>;
fn setup(&mut self, res: &mut Resources) {
Self::SystemData::setup(res);
self.reader = Some(res.fetch_mut::<OnPlayerKilled>().register_reader());
}
fn run(&mut self, mut data: Self::SystemData) {
for evt in data.channel.read(self.reader.as_mut().unwrap()) {
// Don't do anything if either of the players have left
if !data.entities.is_alive(evt.player) {
continue;
}
if !data.entities.is_alive(evt.killer) {
continue;
}
let transfer = (data.score.get(evt.player).unwrap().0 + 3) / 4;
data.score.get_mut(evt.player).unwrap().0 -= transfer;
data.score.get_mut(evt.killer).unwrap().0 += transfer + 25;
Self::send_update(evt.player, &data);
Self::send_update(evt.killer, &data);
}
}
}
impl SystemInfo for UpdateScore {
type Dependencies = (super::DisplayMessage);
fn name() -> &'static str {
concat!(module_path!(), "::", line!())
}
fn new() -> Self {
Self::new()
}
}
|
mod add;
mod build;
mod check;
mod cmin;
mod coverage;
mod fmt;
mod init;
mod list;
mod run;
mod tmin;
pub use self::{
add::Add, build::Build, check::Check, cmin::Cmin, coverage::Coverage, fmt::Fmt, init::Init,
list::List, run::Run, tmin::Tmin,
};
use clap::{Parser, ValueEnum};
use std::{fmt as stdfmt, path::PathBuf};
#[derive(Copy, Clone, Debug, Eq, PartialEq, ValueEnum)]
pub enum Sanitizer {
Address,
Leak,
Memory,
Thread,
None,
}
impl stdfmt::Display for Sanitizer {
fn fmt(&self, f: &mut stdfmt::Formatter) -> stdfmt::Result {
write!(
f,
"{}",
match self {
Sanitizer::Address => "address",
Sanitizer::Leak => "leak",
Sanitizer::Memory => "memory",
Sanitizer::Thread => "thread",
Sanitizer::None => "",
}
)
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum BuildMode {
Build,
Check,
}
#[derive(Clone, Debug, Eq, PartialEq, Parser)]
pub struct BuildOptions {
#[arg(short = 'D', long, conflicts_with = "release")]
/// Build artifacts in development mode, without optimizations
pub dev: bool,
#[arg(short = 'O', long, conflicts_with = "dev")]
/// Build artifacts in release mode, with optimizations
pub release: bool,
#[arg(short = 'a', long)]
/// Build artifacts with debug assertions and overflow checks enabled (default if not -O)
pub debug_assertions: bool,
/// Build target with verbose output from `cargo build`
#[arg(short = 'v', long)]
pub verbose: bool,
#[arg(long)]
/// Build artifacts with default Cargo features disabled
pub no_default_features: bool,
#[arg(long, conflicts_with_all = &["no_default_features", "features"])]
/// Build artifacts with all Cargo features enabled
pub all_features: bool,
#[arg(long)]
/// Build artifacts with given Cargo feature enabled
pub features: Option<String>,
#[arg(short, long, value_enum, default_value = "address")]
/// Use a specific sanitizer
pub sanitizer: Sanitizer,
#[arg(long = "build-std")]
/// Pass -Zbuild-std to Cargo, which will build the standard library with all the build
/// settings for the fuzz target, including debug assertions, and a sanitizer if requested.
/// Currently this conflicts with coverage instrumentation but -Zbuild-std enables detecting
/// more bugs so this option defaults to true, but when using `cargo fuzz coverage` it
/// defaults to false.
pub build_std: bool,
#[arg(short, long = "careful")]
/// enable "careful" mode: inspired by https://github.com/RalfJung/cargo-careful, this enables
/// building the fuzzing harness along with the standard library (implies --build-std) with
/// debug assertions and extra const UB and init checks.
pub careful_mode: bool,
#[arg(long = "target", default_value(crate::utils::default_target()))]
/// Target triple of the fuzz target
pub triple: String,
#[arg(short = 'Z', value_name = "FLAG")]
/// Unstable (nightly-only) flags to Cargo
pub unstable_flags: Vec<String>,
#[arg(long)]
/// Target dir option to pass to cargo build.
pub target_dir: Option<String>,
#[arg(skip = false)]
/// Instrument program code with source-based code coverage information.
/// This build option will be automatically used when running `cargo fuzz coverage`.
/// The option will not be shown to the user, which is ensured by the `skip` attribute.
/// The attribute takes a default value `false`, ensuring that by default,
/// the coverage option will be disabled).
pub coverage: bool,
/// Dead code is linked by default to prevent a potential error with some
/// optimized targets. This flag allows you to opt out of it.
#[arg(long)]
pub strip_dead_code: bool,
/// By default the 'cfg(fuzzing)' compilation configuration is set. This flag
/// allows you to opt out of it.
#[arg(long)]
pub no_cfg_fuzzing: bool,
#[arg(skip = false)]
/// Add the 'cfg(fuzzing-repro)' compilation configuration. This build
/// option will be automatically used when running `cargo fuzz run <target>
/// <corpus>`. The option will not be shown to the user, which is ensured by
/// the `skip` attribute.
pub cfg_fuzzing_repro: bool,
#[arg(long)]
/// Don't build with the `sanitizer-coverage-trace-compares` LLVM argument
///
/// Using this may improve fuzzer throughput at the cost of worse coverage accuracy.
/// It also allows older CPUs lacking the `popcnt` instruction to use `cargo-fuzz`;
/// the `*-trace-compares` instrumentation assumes that the instruction is
/// available.
pub no_trace_compares: bool,
}
impl stdfmt::Display for BuildOptions {
fn fmt(&self, f: &mut stdfmt::Formatter) -> stdfmt::Result {
if self.dev {
write!(f, " -D")?;
}
if self.release {
write!(f, " -O")?;
}
if self.debug_assertions {
write!(f, " -a")?;
}
if self.verbose {
write!(f, " -v")?;
}
if self.no_default_features {
write!(f, " --no-default-features")?;
}
if self.all_features {
write!(f, " --all-features")?;
}
if let Some(feature) = &self.features {
write!(f, " --features={}", feature)?;
}
match self.sanitizer {
Sanitizer::None => write!(f, " --sanitizer=none")?,
Sanitizer::Address => {}
_ => write!(f, " --sanitizer={}", self.sanitizer)?,
}
if self.triple != crate::utils::default_target() {
write!(f, " --target={}", self.triple)?;
}
for flag in &self.unstable_flags {
write!(f, " -Z{}", flag)?;
}
if let Some(target_dir) = &self.target_dir {
write!(f, " --target-dir={}", target_dir)?;
}
if self.coverage {
write!(f, " --coverage")?;
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Parser)]
pub struct FuzzDirWrapper {
/// The path to the fuzz project directory.
#[arg(long)]
pub fuzz_dir: Option<PathBuf>,
}
impl stdfmt::Display for FuzzDirWrapper {
fn fmt(&self, f: &mut stdfmt::Formatter) -> stdfmt::Result {
if let Some(ref elem) = self.fuzz_dir {
write!(f, " --fuzz-dir={}", elem.display())?;
}
Ok(())
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn display_build_options() {
let default_opts = BuildOptions {
dev: false,
release: false,
debug_assertions: false,
verbose: false,
no_default_features: false,
all_features: false,
features: None,
build_std: false,
careful_mode: false,
sanitizer: Sanitizer::Address,
triple: String::from(crate::utils::default_target()),
unstable_flags: Vec::new(),
target_dir: None,
coverage: false,
strip_dead_code: false,
no_cfg_fuzzing: false,
cfg_fuzzing_repro: false,
no_trace_compares: false,
};
let opts = vec![
default_opts.clone(),
BuildOptions {
dev: true,
..default_opts.clone()
},
BuildOptions {
release: true,
..default_opts.clone()
},
BuildOptions {
debug_assertions: true,
..default_opts.clone()
},
BuildOptions {
verbose: true,
..default_opts.clone()
},
BuildOptions {
no_default_features: true,
..default_opts.clone()
},
BuildOptions {
all_features: true,
..default_opts.clone()
},
BuildOptions {
features: Some(String::from("features")),
..default_opts.clone()
},
BuildOptions {
sanitizer: Sanitizer::None,
..default_opts.clone()
},
BuildOptions {
triple: String::from("custom_triple"),
..default_opts.clone()
},
BuildOptions {
unstable_flags: vec![String::from("unstable"), String::from("flags")],
..default_opts.clone()
},
BuildOptions {
target_dir: Some(String::from("/tmp/test")),
..default_opts.clone()
},
BuildOptions {
coverage: false,
..default_opts
},
];
for case in opts {
assert_eq!(case, BuildOptions::parse_from(case.to_string().split(' ')));
}
}
}
|
#![allow(dead_code)]
use crate::utils::environment;
use std::path::PathBuf;
use std::{env, fs};
use rand::distributions::Alphanumeric;
use rand::Rng;
#[macro_export]
macro_rules! assert_match {
($pattern:pat, $var:expr) => {
assert!(match $var {
$pattern => true,
_ => false,
})
};
($pattern:pat, $var:expr, $val_in_pattern:ident, $exp_value:expr) => {
assert!(match $var {
$pattern => $val_in_pattern == $exp_value,
_ => false,
})
};
($pattern:pat, $var:expr, $val_in_pattern1:ident, $exp_value1:expr, $val_in_pattern2:ident, $exp_value2:expr) => {
assert!(match $var {
$pattern => $val_in_pattern1 == $exp_value1 && $val_in_pattern2 == $exp_value2,
_ => false,
})
};
}
#[macro_export]
macro_rules! assert_kind {
($kind:expr, $var:expr) => {
match $var {
Err(e) => assert_eq!($kind, e.kind()),
_ => assert!(false, "Result expected to be error"),
}
};
}
#[macro_export]
macro_rules! assert_code {
($code:expr, $var:expr) => {
match $var {
Err(e) => assert_eq!($code, e.error_code),
_ => assert!(false, "Result expected to be error"),
}
};
}
pub fn get_rand_string(len: usize) -> String {
rand::thread_rng()
.sample_iter(&Alphanumeric)
.take(len)
.collect()
}
pub struct GenesisTransactions {
pub transactions: Vec<String>,
pub file: Option<TempFile>,
}
impl GenesisTransactions {
pub fn default_transactions() -> Vec<String> {
let test_pool_ip = environment::test_pool_ip();
vec![
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node1","blskey":"4N8aUNHSgjQVgkpm8nhNEfDf6txHznoYREg9kirmJrkivgL4oSEimFF6nsQ6M41QvhM2Z33nves5vfSn9n1UwNFJBYtWVnHYMATn76vLuL3zU88KyeAYcHfsih3He6UHcXDxcaecHVz6jhCYz1P2UZn2bDVruL5wXpehgBfBaLKm3Ba","blskey_pop":"RahHYiCvoNCtPTrVtP7nMC5eTYrsUA8WjXbdhNc8debh1agE9bGiJxWBXYNFbnJXoXhWFMvyqhqhRoq737YQemH5ik9oL7R4NTTCz2LEZhkgLJzB3QRQqJyBNyv7acbdHrAT8nQ9UkLbaVL9NBpnWXBTw4LEMePaSHEw66RzPNdAX1","client_ip":"{}","client_port":9702,"node_ip":"{}","node_port":9701,"services":["VALIDATOR"]}},"dest":"Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv"}},"metadata":{{"from":"Th7MpTaRZVRYnPiabds81Y"}},"type":"0"}},"txnMetadata":{{"seqNo":1,"txnId":"fea82e10e894419fe2bea7d96296a6d46f50f93f9eeda954ec461b2ed2950b62"}},"ver":"1"}}"#,
test_pool_ip, test_pool_ip
),
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node2","blskey":"37rAPpXVoxzKhz7d9gkUe52XuXryuLXoM6P6LbWDB7LSbG62Lsb33sfG7zqS8TK1MXwuCHj1FKNzVpsnafmqLG1vXN88rt38mNFs9TENzm4QHdBzsvCuoBnPH7rpYYDo9DZNJePaDvRvqJKByCabubJz3XXKbEeshzpz4Ma5QYpJqjk","blskey_pop":"Qr658mWZ2YC8JXGXwMDQTzuZCWF7NK9EwxphGmcBvCh6ybUuLxbG65nsX4JvD4SPNtkJ2w9ug1yLTj6fgmuDg41TgECXjLCij3RMsV8CwewBVgVN67wsA45DFWvqvLtu4rjNnE9JbdFTc1Z4WCPA3Xan44K1HoHAq9EVeaRYs8zoF5","client_ip":"{}","client_port":9704,"node_ip":"{}","node_port":9703,"services":["VALIDATOR"]}},"dest":"8ECVSk179mjsjKRLWiQtssMLgp6EPhWXtaYyStWPSGAb"}},"metadata":{{"from":"EbP4aYNeTHL6q385GuVpRV"}},"type":"0"}},"txnMetadata":{{"seqNo":2,"txnId":"1ac8aece2a18ced660fef8694b61aac3af08ba875ce3026a160acbc3a3af35fc"}},"ver":"1"}}"#,
test_pool_ip, test_pool_ip
),
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node3","blskey":"3WFpdbg7C5cnLYZwFZevJqhubkFALBfCBBok15GdrKMUhUjGsk3jV6QKj6MZgEubF7oqCafxNdkm7eswgA4sdKTRc82tLGzZBd6vNqU8dupzup6uYUf32KTHTPQbuUM8Yk4QFXjEf2Usu2TJcNkdgpyeUSX42u5LqdDDpNSWUK5deC5","blskey_pop":"QwDeb2CkNSx6r8QC8vGQK3GRv7Yndn84TGNijX8YXHPiagXajyfTjoR87rXUu4G4QLk2cF8NNyqWiYMus1623dELWwx57rLCFqGh7N4ZRbGDRP4fnVcaKg1BcUxQ866Ven4gw8y4N56S5HzxXNBZtLYmhGHvDtk6PFkFwCvxYrNYjh","client_ip":"{}","client_port":9706,"node_ip":"{}","node_port":9705,"services":["VALIDATOR"]}},"dest":"DKVxG2fXXTU8yT5N7hGEbXB3dfdAnYv1JczDUHpmDxya"}},"metadata":{{"from":"4cU41vWW82ArfxJxHkzXPG"}},"type":"0"}},"txnMetadata":{{"seqNo":3,"txnId":"7e9f355dffa78ed24668f0e0e369fd8c224076571c51e2ea8be5f26479edebe4"}},"ver":"1"}}"#,
test_pool_ip, test_pool_ip
),
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node4","blskey":"2zN3bHM1m4rLz54MJHYSwvqzPchYp8jkHswveCLAEJVcX6Mm1wHQD1SkPYMzUDTZvWvhuE6VNAkK3KxVeEmsanSmvjVkReDeBEMxeDaayjcZjFGPydyey1qxBHmTvAnBKoPydvuTAqx5f7YNNRAdeLmUi99gERUU7TD8KfAa6MpQ9bw","blskey_pop":"RPLagxaR5xdimFzwmzYnz4ZhWtYQEj8iR5ZU53T2gitPCyCHQneUn2Huc4oeLd2B2HzkGnjAff4hWTJT6C7qHYB1Mv2wU5iHHGFWkhnTX9WsEAbunJCV2qcaXScKj4tTfvdDKfLiVuU2av6hbsMztirRze7LvYBkRHV3tGwyCptsrP","client_ip":"{}","client_port":9708,"node_ip":"{}","node_port":9707,"services":["VALIDATOR"]}},"dest":"4PS3EDQ3dW1tci1Bp6543CfuuebjFrg36kLAUcskGfaA"}},"metadata":{{"from":"TWwCRQRZ2ZHMJFn9TzLp7W"}},"type":"0"}},"txnMetadata":{{"seqNo":4,"txnId":"aa5e817d7cc626170eca175822029339a444eb0ee8f0bd20d3b0b76e566fb008"}},"ver":"1"}}"#,
test_pool_ip, test_pool_ip
),
]
}
pub fn new(count: Option<usize>) -> GenesisTransactions {
let count = count.unwrap_or(4);
let transactions = Self::default_transactions()[0..count].to_vec();
GenesisTransactions {
transactions,
file: None,
}
}
pub fn store_to_file(&mut self) -> PathBuf {
let data = self.transactions.join("\n");
let file = TempFile::create(&data);
let path = file.path.clone();
self.file = Some(file);
path
}
}
impl Drop for GenesisTransactions {
fn drop(&mut self) {}
}
pub struct TempFile {
pub path: PathBuf,
}
impl TempFile {
pub fn create(data: &str) -> TempFile {
let mut path = env::temp_dir();
path.push(get_rand_string(10));
fs::write(&path, data).unwrap();
TempFile { path }
}
}
impl Drop for TempFile {
fn drop(&mut self) {
fs::remove_file(&self.path).unwrap()
}
}
|
#[derive(Debug, Copy, Clone)]
pub struct EnvelopePoint {
pub(crate) frame: u16,
pub(crate) value: u16
}
impl EnvelopePoint {
pub(crate) fn new() -> EnvelopePoint {
EnvelopePoint{ frame: 0, value: 0 }
}
}
pub type EnvelopePoints = [EnvelopePoint;12];
#[derive(Debug, Copy, Clone)]
pub struct Envelope {
pub(crate) points: EnvelopePoints,
pub(crate) size: u8,
pub(crate) sustain_point: u8,
pub(crate) loop_start_point: u8,
pub(crate) loop_end_point: u8,
pub(crate) on: bool,
pub(crate) sustain: bool,
pub(crate) has_loop: bool,
}
impl Envelope {
pub(crate) fn new() -> Self {
Envelope{
points: [EnvelopePoint { frame: 0, value: 0 }; 12],
size: 0,
sustain_point: 0,
loop_start_point: 0,
loop_end_point: 0,
on: false,
sustain: false,
has_loop: false
}
}
pub(crate) fn create(points: [EnvelopePoint; 12], size: u8, sustain_point: u8, loop_start_point: u8, loop_end_point: u8, env_type: u8) -> Self {
Envelope {
points,
size,
sustain_point,
loop_start_point,
loop_end_point,
on: (env_type & 1) == 1,
sustain: (env_type & 2) == 2,
has_loop: (env_type & 4) == 4,
}
}
}
|
#![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)]
WebApps_List(#[from] web_apps::list::Error),
#[error(transparent)]
WebApps_ListByResourceGroup(#[from] web_apps::list_by_resource_group::Error),
#[error(transparent)]
WebApps_Get(#[from] web_apps::get::Error),
#[error(transparent)]
WebApps_CreateOrUpdate(#[from] web_apps::create_or_update::Error),
#[error(transparent)]
WebApps_Update(#[from] web_apps::update::Error),
#[error(transparent)]
WebApps_Delete(#[from] web_apps::delete::Error),
#[error(transparent)]
WebApps_AnalyzeCustomHostname(#[from] web_apps::analyze_custom_hostname::Error),
#[error(transparent)]
WebApps_ApplySlotConfigToProduction(#[from] web_apps::apply_slot_config_to_production::Error),
#[error(transparent)]
WebApps_Backup(#[from] web_apps::backup::Error),
#[error(transparent)]
WebApps_ListBackups(#[from] web_apps::list_backups::Error),
#[error(transparent)]
WebApps_DiscoverRestore(#[from] web_apps::discover_restore::Error),
#[error(transparent)]
WebApps_GetBackupStatus(#[from] web_apps::get_backup_status::Error),
#[error(transparent)]
WebApps_DeleteBackup(#[from] web_apps::delete_backup::Error),
#[error(transparent)]
WebApps_ListBackupStatusSecrets(#[from] web_apps::list_backup_status_secrets::Error),
#[error(transparent)]
WebApps_Restore(#[from] web_apps::restore::Error),
#[error(transparent)]
WebApps_ListConfigurations(#[from] web_apps::list_configurations::Error),
#[error(transparent)]
WebApps_UpdateApplicationSettings(#[from] web_apps::update_application_settings::Error),
#[error(transparent)]
WebApps_ListApplicationSettings(#[from] web_apps::list_application_settings::Error),
#[error(transparent)]
WebApps_UpdateAuthSettings(#[from] web_apps::update_auth_settings::Error),
#[error(transparent)]
WebApps_GetAuthSettings(#[from] web_apps::get_auth_settings::Error),
#[error(transparent)]
WebApps_UpdateBackupConfiguration(#[from] web_apps::update_backup_configuration::Error),
#[error(transparent)]
WebApps_DeleteBackupConfiguration(#[from] web_apps::delete_backup_configuration::Error),
#[error(transparent)]
WebApps_GetBackupConfiguration(#[from] web_apps::get_backup_configuration::Error),
#[error(transparent)]
WebApps_UpdateConnectionStrings(#[from] web_apps::update_connection_strings::Error),
#[error(transparent)]
WebApps_ListConnectionStrings(#[from] web_apps::list_connection_strings::Error),
#[error(transparent)]
WebApps_GetDiagnosticLogsConfiguration(#[from] web_apps::get_diagnostic_logs_configuration::Error),
#[error(transparent)]
WebApps_UpdateDiagnosticLogsConfig(#[from] web_apps::update_diagnostic_logs_config::Error),
#[error(transparent)]
WebApps_UpdateMetadata(#[from] web_apps::update_metadata::Error),
#[error(transparent)]
WebApps_ListMetadata(#[from] web_apps::list_metadata::Error),
#[error(transparent)]
WebApps_ListPublishingCredentials(#[from] web_apps::list_publishing_credentials::Error),
#[error(transparent)]
WebApps_UpdateSitePushSettings(#[from] web_apps::update_site_push_settings::Error),
#[error(transparent)]
WebApps_ListSitePushSettings(#[from] web_apps::list_site_push_settings::Error),
#[error(transparent)]
WebApps_ListSlotConfigurationNames(#[from] web_apps::list_slot_configuration_names::Error),
#[error(transparent)]
WebApps_UpdateSlotConfigurationNames(#[from] web_apps::update_slot_configuration_names::Error),
#[error(transparent)]
WebApps_GetConfiguration(#[from] web_apps::get_configuration::Error),
#[error(transparent)]
WebApps_CreateOrUpdateConfiguration(#[from] web_apps::create_or_update_configuration::Error),
#[error(transparent)]
WebApps_UpdateConfiguration(#[from] web_apps::update_configuration::Error),
#[error(transparent)]
WebApps_ListConfigurationSnapshotInfo(#[from] web_apps::list_configuration_snapshot_info::Error),
#[error(transparent)]
WebApps_GetConfigurationSnapshot(#[from] web_apps::get_configuration_snapshot::Error),
#[error(transparent)]
WebApps_RecoverSiteConfigurationSnapshot(#[from] web_apps::recover_site_configuration_snapshot::Error),
#[error(transparent)]
WebApps_GetWebSiteContainerLogs(#[from] web_apps::get_web_site_container_logs::Error),
#[error(transparent)]
WebApps_GetWebSiteContainerLogsZip(#[from] web_apps::get_web_site_container_logs_zip::Error),
#[error(transparent)]
WebApps_ListContinuousWebJobs(#[from] web_apps::list_continuous_web_jobs::Error),
#[error(transparent)]
WebApps_GetContinuousWebJob(#[from] web_apps::get_continuous_web_job::Error),
#[error(transparent)]
WebApps_DeleteContinuousWebJob(#[from] web_apps::delete_continuous_web_job::Error),
#[error(transparent)]
WebApps_StartContinuousWebJob(#[from] web_apps::start_continuous_web_job::Error),
#[error(transparent)]
WebApps_StopContinuousWebJob(#[from] web_apps::stop_continuous_web_job::Error),
#[error(transparent)]
WebApps_ListDeployments(#[from] web_apps::list_deployments::Error),
#[error(transparent)]
WebApps_GetDeployment(#[from] web_apps::get_deployment::Error),
#[error(transparent)]
WebApps_CreateDeployment(#[from] web_apps::create_deployment::Error),
#[error(transparent)]
WebApps_DeleteDeployment(#[from] web_apps::delete_deployment::Error),
#[error(transparent)]
WebApps_ListDeploymentLog(#[from] web_apps::list_deployment_log::Error),
#[error(transparent)]
WebApps_ListDomainOwnershipIdentifiers(#[from] web_apps::list_domain_ownership_identifiers::Error),
#[error(transparent)]
WebApps_GetDomainOwnershipIdentifier(#[from] web_apps::get_domain_ownership_identifier::Error),
#[error(transparent)]
WebApps_CreateOrUpdateDomainOwnershipIdentifier(#[from] web_apps::create_or_update_domain_ownership_identifier::Error),
#[error(transparent)]
WebApps_UpdateDomainOwnershipIdentifier(#[from] web_apps::update_domain_ownership_identifier::Error),
#[error(transparent)]
WebApps_DeleteDomainOwnershipIdentifier(#[from] web_apps::delete_domain_ownership_identifier::Error),
#[error(transparent)]
WebApps_GetMsDeployStatus(#[from] web_apps::get_ms_deploy_status::Error),
#[error(transparent)]
WebApps_CreateMsDeployOperation(#[from] web_apps::create_ms_deploy_operation::Error),
#[error(transparent)]
WebApps_GetMsDeployLog(#[from] web_apps::get_ms_deploy_log::Error),
#[error(transparent)]
WebApps_ListFunctions(#[from] web_apps::list_functions::Error),
#[error(transparent)]
WebApps_GetFunctionsAdminToken(#[from] web_apps::get_functions_admin_token::Error),
#[error(transparent)]
WebApps_GetFunction(#[from] web_apps::get_function::Error),
#[error(transparent)]
WebApps_CreateFunction(#[from] web_apps::create_function::Error),
#[error(transparent)]
WebApps_DeleteFunction(#[from] web_apps::delete_function::Error),
#[error(transparent)]
WebApps_ListFunctionSecrets(#[from] web_apps::list_function_secrets::Error),
#[error(transparent)]
WebApps_ListHostNameBindings(#[from] web_apps::list_host_name_bindings::Error),
#[error(transparent)]
WebApps_GetHostNameBinding(#[from] web_apps::get_host_name_binding::Error),
#[error(transparent)]
WebApps_CreateOrUpdateHostNameBinding(#[from] web_apps::create_or_update_host_name_binding::Error),
#[error(transparent)]
WebApps_DeleteHostNameBinding(#[from] web_apps::delete_host_name_binding::Error),
#[error(transparent)]
WebApps_GetHybridConnection(#[from] web_apps::get_hybrid_connection::Error),
#[error(transparent)]
WebApps_CreateOrUpdateHybridConnection(#[from] web_apps::create_or_update_hybrid_connection::Error),
#[error(transparent)]
WebApps_UpdateHybridConnection(#[from] web_apps::update_hybrid_connection::Error),
#[error(transparent)]
WebApps_DeleteHybridConnection(#[from] web_apps::delete_hybrid_connection::Error),
#[error(transparent)]
WebApps_ListHybridConnectionKeys(#[from] web_apps::list_hybrid_connection_keys::Error),
#[error(transparent)]
WebApps_ListHybridConnections(#[from] web_apps::list_hybrid_connections::Error),
#[error(transparent)]
WebApps_ListRelayServiceConnections(#[from] web_apps::list_relay_service_connections::Error),
#[error(transparent)]
WebApps_GetRelayServiceConnection(#[from] web_apps::get_relay_service_connection::Error),
#[error(transparent)]
WebApps_CreateOrUpdateRelayServiceConnection(#[from] web_apps::create_or_update_relay_service_connection::Error),
#[error(transparent)]
WebApps_UpdateRelayServiceConnection(#[from] web_apps::update_relay_service_connection::Error),
#[error(transparent)]
WebApps_DeleteRelayServiceConnection(#[from] web_apps::delete_relay_service_connection::Error),
#[error(transparent)]
WebApps_ListInstanceIdentifiers(#[from] web_apps::list_instance_identifiers::Error),
#[error(transparent)]
WebApps_GetInstanceMsDeployStatus(#[from] web_apps::get_instance_ms_deploy_status::Error),
#[error(transparent)]
WebApps_CreateInstanceMsDeployOperation(#[from] web_apps::create_instance_ms_deploy_operation::Error),
#[error(transparent)]
WebApps_GetInstanceMsDeployLog(#[from] web_apps::get_instance_ms_deploy_log::Error),
#[error(transparent)]
WebApps_ListInstanceProcesses(#[from] web_apps::list_instance_processes::Error),
#[error(transparent)]
WebApps_GetInstanceProcess(#[from] web_apps::get_instance_process::Error),
#[error(transparent)]
WebApps_DeleteInstanceProcess(#[from] web_apps::delete_instance_process::Error),
#[error(transparent)]
WebApps_GetInstanceProcessDump(#[from] web_apps::get_instance_process_dump::Error),
#[error(transparent)]
WebApps_ListInstanceProcessModules(#[from] web_apps::list_instance_process_modules::Error),
#[error(transparent)]
WebApps_GetInstanceProcessModule(#[from] web_apps::get_instance_process_module::Error),
#[error(transparent)]
WebApps_ListInstanceProcessThreads(#[from] web_apps::list_instance_process_threads::Error),
#[error(transparent)]
WebApps_GetInstanceProcessThread(#[from] web_apps::get_instance_process_thread::Error),
#[error(transparent)]
WebApps_IsCloneable(#[from] web_apps::is_cloneable::Error),
#[error(transparent)]
WebApps_ListSyncFunctionTriggers(#[from] web_apps::list_sync_function_triggers::Error),
#[error(transparent)]
WebApps_ListMetricDefinitions(#[from] web_apps::list_metric_definitions::Error),
#[error(transparent)]
WebApps_ListMetrics(#[from] web_apps::list_metrics::Error),
#[error(transparent)]
WebApps_MigrateStorage(#[from] web_apps::migrate_storage::Error),
#[error(transparent)]
WebApps_MigrateMySql(#[from] web_apps::migrate_my_sql::Error),
#[error(transparent)]
WebApps_GetMigrateMySqlStatus(#[from] web_apps::get_migrate_my_sql_status::Error),
#[error(transparent)]
WebApps_ListNetworkFeatures(#[from] web_apps::list_network_features::Error),
#[error(transparent)]
WebApps_StartWebSiteNetworkTrace(#[from] web_apps::start_web_site_network_trace::Error),
#[error(transparent)]
WebApps_StopWebSiteNetworkTrace(#[from] web_apps::stop_web_site_network_trace::Error),
#[error(transparent)]
WebApps_GenerateNewSitePublishingPassword(#[from] web_apps::generate_new_site_publishing_password::Error),
#[error(transparent)]
WebApps_ListPerfMonCounters(#[from] web_apps::list_perf_mon_counters::Error),
#[error(transparent)]
WebApps_GetSitePhpErrorLogFlag(#[from] web_apps::get_site_php_error_log_flag::Error),
#[error(transparent)]
WebApps_ListPremierAddOns(#[from] web_apps::list_premier_add_ons::Error),
#[error(transparent)]
WebApps_GetPremierAddOn(#[from] web_apps::get_premier_add_on::Error),
#[error(transparent)]
WebApps_AddPremierAddOn(#[from] web_apps::add_premier_add_on::Error),
#[error(transparent)]
WebApps_DeletePremierAddOn(#[from] web_apps::delete_premier_add_on::Error),
#[error(transparent)]
WebApps_ListProcesses(#[from] web_apps::list_processes::Error),
#[error(transparent)]
WebApps_GetProcess(#[from] web_apps::get_process::Error),
#[error(transparent)]
WebApps_DeleteProcess(#[from] web_apps::delete_process::Error),
#[error(transparent)]
WebApps_GetProcessDump(#[from] web_apps::get_process_dump::Error),
#[error(transparent)]
WebApps_ListProcessModules(#[from] web_apps::list_process_modules::Error),
#[error(transparent)]
WebApps_GetProcessModule(#[from] web_apps::get_process_module::Error),
#[error(transparent)]
WebApps_ListProcessThreads(#[from] web_apps::list_process_threads::Error),
#[error(transparent)]
WebApps_GetProcessThread(#[from] web_apps::get_process_thread::Error),
#[error(transparent)]
WebApps_ListPublicCertificates(#[from] web_apps::list_public_certificates::Error),
#[error(transparent)]
WebApps_GetPublicCertificate(#[from] web_apps::get_public_certificate::Error),
#[error(transparent)]
WebApps_CreateOrUpdatePublicCertificate(#[from] web_apps::create_or_update_public_certificate::Error),
#[error(transparent)]
WebApps_DeletePublicCertificate(#[from] web_apps::delete_public_certificate::Error),
#[error(transparent)]
WebApps_ListPublishingProfileXmlWithSecrets(#[from] web_apps::list_publishing_profile_xml_with_secrets::Error),
#[error(transparent)]
WebApps_Recover(#[from] web_apps::recover::Error),
#[error(transparent)]
WebApps_ResetProductionSlotConfig(#[from] web_apps::reset_production_slot_config::Error),
#[error(transparent)]
WebApps_Restart(#[from] web_apps::restart::Error),
#[error(transparent)]
WebApps_ListSiteExtensions(#[from] web_apps::list_site_extensions::Error),
#[error(transparent)]
WebApps_GetSiteExtension(#[from] web_apps::get_site_extension::Error),
#[error(transparent)]
WebApps_InstallSiteExtension(#[from] web_apps::install_site_extension::Error),
#[error(transparent)]
WebApps_DeleteSiteExtension(#[from] web_apps::delete_site_extension::Error),
#[error(transparent)]
WebApps_ListSlots(#[from] web_apps::list_slots::Error),
#[error(transparent)]
WebApps_GetSlot(#[from] web_apps::get_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateSlot(#[from] web_apps::create_or_update_slot::Error),
#[error(transparent)]
WebApps_UpdateSlot(#[from] web_apps::update_slot::Error),
#[error(transparent)]
WebApps_DeleteSlot(#[from] web_apps::delete_slot::Error),
#[error(transparent)]
WebApps_AnalyzeCustomHostnameSlot(#[from] web_apps::analyze_custom_hostname_slot::Error),
#[error(transparent)]
WebApps_ApplySlotConfigurationSlot(#[from] web_apps::apply_slot_configuration_slot::Error),
#[error(transparent)]
WebApps_BackupSlot(#[from] web_apps::backup_slot::Error),
#[error(transparent)]
WebApps_ListBackupsSlot(#[from] web_apps::list_backups_slot::Error),
#[error(transparent)]
WebApps_DiscoverRestoreSlot(#[from] web_apps::discover_restore_slot::Error),
#[error(transparent)]
WebApps_GetBackupStatusSlot(#[from] web_apps::get_backup_status_slot::Error),
#[error(transparent)]
WebApps_DeleteBackupSlot(#[from] web_apps::delete_backup_slot::Error),
#[error(transparent)]
WebApps_ListBackupStatusSecretsSlot(#[from] web_apps::list_backup_status_secrets_slot::Error),
#[error(transparent)]
WebApps_RestoreSlot(#[from] web_apps::restore_slot::Error),
#[error(transparent)]
WebApps_ListConfigurationsSlot(#[from] web_apps::list_configurations_slot::Error),
#[error(transparent)]
WebApps_UpdateApplicationSettingsSlot(#[from] web_apps::update_application_settings_slot::Error),
#[error(transparent)]
WebApps_ListApplicationSettingsSlot(#[from] web_apps::list_application_settings_slot::Error),
#[error(transparent)]
WebApps_UpdateAuthSettingsSlot(#[from] web_apps::update_auth_settings_slot::Error),
#[error(transparent)]
WebApps_GetAuthSettingsSlot(#[from] web_apps::get_auth_settings_slot::Error),
#[error(transparent)]
WebApps_UpdateBackupConfigurationSlot(#[from] web_apps::update_backup_configuration_slot::Error),
#[error(transparent)]
WebApps_DeleteBackupConfigurationSlot(#[from] web_apps::delete_backup_configuration_slot::Error),
#[error(transparent)]
WebApps_GetBackupConfigurationSlot(#[from] web_apps::get_backup_configuration_slot::Error),
#[error(transparent)]
WebApps_UpdateConnectionStringsSlot(#[from] web_apps::update_connection_strings_slot::Error),
#[error(transparent)]
WebApps_ListConnectionStringsSlot(#[from] web_apps::list_connection_strings_slot::Error),
#[error(transparent)]
WebApps_GetDiagnosticLogsConfigurationSlot(#[from] web_apps::get_diagnostic_logs_configuration_slot::Error),
#[error(transparent)]
WebApps_UpdateDiagnosticLogsConfigSlot(#[from] web_apps::update_diagnostic_logs_config_slot::Error),
#[error(transparent)]
WebApps_UpdateMetadataSlot(#[from] web_apps::update_metadata_slot::Error),
#[error(transparent)]
WebApps_ListMetadataSlot(#[from] web_apps::list_metadata_slot::Error),
#[error(transparent)]
WebApps_ListPublishingCredentialsSlot(#[from] web_apps::list_publishing_credentials_slot::Error),
#[error(transparent)]
WebApps_UpdateSitePushSettingsSlot(#[from] web_apps::update_site_push_settings_slot::Error),
#[error(transparent)]
WebApps_ListSitePushSettingsSlot(#[from] web_apps::list_site_push_settings_slot::Error),
#[error(transparent)]
WebApps_GetConfigurationSlot(#[from] web_apps::get_configuration_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateConfigurationSlot(#[from] web_apps::create_or_update_configuration_slot::Error),
#[error(transparent)]
WebApps_UpdateConfigurationSlot(#[from] web_apps::update_configuration_slot::Error),
#[error(transparent)]
WebApps_ListConfigurationSnapshotInfoSlot(#[from] web_apps::list_configuration_snapshot_info_slot::Error),
#[error(transparent)]
WebApps_GetConfigurationSnapshotSlot(#[from] web_apps::get_configuration_snapshot_slot::Error),
#[error(transparent)]
WebApps_RecoverSiteConfigurationSnapshotSlot(#[from] web_apps::recover_site_configuration_snapshot_slot::Error),
#[error(transparent)]
WebApps_GetWebSiteContainerLogsSlot(#[from] web_apps::get_web_site_container_logs_slot::Error),
#[error(transparent)]
WebApps_GetWebSiteContainerLogsZipSlot(#[from] web_apps::get_web_site_container_logs_zip_slot::Error),
#[error(transparent)]
WebApps_ListContinuousWebJobsSlot(#[from] web_apps::list_continuous_web_jobs_slot::Error),
#[error(transparent)]
WebApps_GetContinuousWebJobSlot(#[from] web_apps::get_continuous_web_job_slot::Error),
#[error(transparent)]
WebApps_DeleteContinuousWebJobSlot(#[from] web_apps::delete_continuous_web_job_slot::Error),
#[error(transparent)]
WebApps_StartContinuousWebJobSlot(#[from] web_apps::start_continuous_web_job_slot::Error),
#[error(transparent)]
WebApps_StopContinuousWebJobSlot(#[from] web_apps::stop_continuous_web_job_slot::Error),
#[error(transparent)]
WebApps_ListDeploymentsSlot(#[from] web_apps::list_deployments_slot::Error),
#[error(transparent)]
WebApps_GetDeploymentSlot(#[from] web_apps::get_deployment_slot::Error),
#[error(transparent)]
WebApps_CreateDeploymentSlot(#[from] web_apps::create_deployment_slot::Error),
#[error(transparent)]
WebApps_DeleteDeploymentSlot(#[from] web_apps::delete_deployment_slot::Error),
#[error(transparent)]
WebApps_ListDeploymentLogSlot(#[from] web_apps::list_deployment_log_slot::Error),
#[error(transparent)]
WebApps_ListDomainOwnershipIdentifiersSlot(#[from] web_apps::list_domain_ownership_identifiers_slot::Error),
#[error(transparent)]
WebApps_GetDomainOwnershipIdentifierSlot(#[from] web_apps::get_domain_ownership_identifier_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateDomainOwnershipIdentifierSlot(#[from] web_apps::create_or_update_domain_ownership_identifier_slot::Error),
#[error(transparent)]
WebApps_UpdateDomainOwnershipIdentifierSlot(#[from] web_apps::update_domain_ownership_identifier_slot::Error),
#[error(transparent)]
WebApps_DeleteDomainOwnershipIdentifierSlot(#[from] web_apps::delete_domain_ownership_identifier_slot::Error),
#[error(transparent)]
WebApps_GetMsDeployStatusSlot(#[from] web_apps::get_ms_deploy_status_slot::Error),
#[error(transparent)]
WebApps_CreateMsDeployOperationSlot(#[from] web_apps::create_ms_deploy_operation_slot::Error),
#[error(transparent)]
WebApps_GetMsDeployLogSlot(#[from] web_apps::get_ms_deploy_log_slot::Error),
#[error(transparent)]
WebApps_ListInstanceFunctionsSlot(#[from] web_apps::list_instance_functions_slot::Error),
#[error(transparent)]
WebApps_GetFunctionsAdminTokenSlot(#[from] web_apps::get_functions_admin_token_slot::Error),
#[error(transparent)]
WebApps_GetInstanceFunctionSlot(#[from] web_apps::get_instance_function_slot::Error),
#[error(transparent)]
WebApps_CreateInstanceFunctionSlot(#[from] web_apps::create_instance_function_slot::Error),
#[error(transparent)]
WebApps_DeleteInstanceFunctionSlot(#[from] web_apps::delete_instance_function_slot::Error),
#[error(transparent)]
WebApps_ListFunctionSecretsSlot(#[from] web_apps::list_function_secrets_slot::Error),
#[error(transparent)]
WebApps_ListHostNameBindingsSlot(#[from] web_apps::list_host_name_bindings_slot::Error),
#[error(transparent)]
WebApps_GetHostNameBindingSlot(#[from] web_apps::get_host_name_binding_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateHostNameBindingSlot(#[from] web_apps::create_or_update_host_name_binding_slot::Error),
#[error(transparent)]
WebApps_DeleteHostNameBindingSlot(#[from] web_apps::delete_host_name_binding_slot::Error),
#[error(transparent)]
WebApps_GetHybridConnectionSlot(#[from] web_apps::get_hybrid_connection_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateHybridConnectionSlot(#[from] web_apps::create_or_update_hybrid_connection_slot::Error),
#[error(transparent)]
WebApps_UpdateHybridConnectionSlot(#[from] web_apps::update_hybrid_connection_slot::Error),
#[error(transparent)]
WebApps_DeleteHybridConnectionSlot(#[from] web_apps::delete_hybrid_connection_slot::Error),
#[error(transparent)]
WebApps_ListHybridConnectionKeysSlot(#[from] web_apps::list_hybrid_connection_keys_slot::Error),
#[error(transparent)]
WebApps_ListHybridConnectionsSlot(#[from] web_apps::list_hybrid_connections_slot::Error),
#[error(transparent)]
WebApps_ListRelayServiceConnectionsSlot(#[from] web_apps::list_relay_service_connections_slot::Error),
#[error(transparent)]
WebApps_GetRelayServiceConnectionSlot(#[from] web_apps::get_relay_service_connection_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateRelayServiceConnectionSlot(#[from] web_apps::create_or_update_relay_service_connection_slot::Error),
#[error(transparent)]
WebApps_UpdateRelayServiceConnectionSlot(#[from] web_apps::update_relay_service_connection_slot::Error),
#[error(transparent)]
WebApps_DeleteRelayServiceConnectionSlot(#[from] web_apps::delete_relay_service_connection_slot::Error),
#[error(transparent)]
WebApps_ListInstanceIdentifiersSlot(#[from] web_apps::list_instance_identifiers_slot::Error),
#[error(transparent)]
WebApps_GetInstanceMsDeployStatusSlot(#[from] web_apps::get_instance_ms_deploy_status_slot::Error),
#[error(transparent)]
WebApps_CreateInstanceMsDeployOperationSlot(#[from] web_apps::create_instance_ms_deploy_operation_slot::Error),
#[error(transparent)]
WebApps_GetInstanceMsDeployLogSlot(#[from] web_apps::get_instance_ms_deploy_log_slot::Error),
#[error(transparent)]
WebApps_ListInstanceProcessesSlot(#[from] web_apps::list_instance_processes_slot::Error),
#[error(transparent)]
WebApps_GetInstanceProcessSlot(#[from] web_apps::get_instance_process_slot::Error),
#[error(transparent)]
WebApps_DeleteInstanceProcessSlot(#[from] web_apps::delete_instance_process_slot::Error),
#[error(transparent)]
WebApps_GetInstanceProcessDumpSlot(#[from] web_apps::get_instance_process_dump_slot::Error),
#[error(transparent)]
WebApps_ListInstanceProcessModulesSlot(#[from] web_apps::list_instance_process_modules_slot::Error),
#[error(transparent)]
WebApps_GetInstanceProcessModuleSlot(#[from] web_apps::get_instance_process_module_slot::Error),
#[error(transparent)]
WebApps_ListInstanceProcessThreadsSlot(#[from] web_apps::list_instance_process_threads_slot::Error),
#[error(transparent)]
WebApps_GetInstanceProcessThreadSlot(#[from] web_apps::get_instance_process_thread_slot::Error),
#[error(transparent)]
WebApps_IsCloneableSlot(#[from] web_apps::is_cloneable_slot::Error),
#[error(transparent)]
WebApps_ListSyncFunctionTriggersSlot(#[from] web_apps::list_sync_function_triggers_slot::Error),
#[error(transparent)]
WebApps_ListMetricDefinitionsSlot(#[from] web_apps::list_metric_definitions_slot::Error),
#[error(transparent)]
WebApps_ListMetricsSlot(#[from] web_apps::list_metrics_slot::Error),
#[error(transparent)]
WebApps_GetMigrateMySqlStatusSlot(#[from] web_apps::get_migrate_my_sql_status_slot::Error),
#[error(transparent)]
WebApps_ListNetworkFeaturesSlot(#[from] web_apps::list_network_features_slot::Error),
#[error(transparent)]
WebApps_StartWebSiteNetworkTraceSlot(#[from] web_apps::start_web_site_network_trace_slot::Error),
#[error(transparent)]
WebApps_StopWebSiteNetworkTraceSlot(#[from] web_apps::stop_web_site_network_trace_slot::Error),
#[error(transparent)]
WebApps_GenerateNewSitePublishingPasswordSlot(#[from] web_apps::generate_new_site_publishing_password_slot::Error),
#[error(transparent)]
WebApps_ListPerfMonCountersSlot(#[from] web_apps::list_perf_mon_counters_slot::Error),
#[error(transparent)]
WebApps_GetSitePhpErrorLogFlagSlot(#[from] web_apps::get_site_php_error_log_flag_slot::Error),
#[error(transparent)]
WebApps_ListPremierAddOnsSlot(#[from] web_apps::list_premier_add_ons_slot::Error),
#[error(transparent)]
WebApps_GetPremierAddOnSlot(#[from] web_apps::get_premier_add_on_slot::Error),
#[error(transparent)]
WebApps_AddPremierAddOnSlot(#[from] web_apps::add_premier_add_on_slot::Error),
#[error(transparent)]
WebApps_DeletePremierAddOnSlot(#[from] web_apps::delete_premier_add_on_slot::Error),
#[error(transparent)]
WebApps_ListProcessesSlot(#[from] web_apps::list_processes_slot::Error),
#[error(transparent)]
WebApps_GetProcessSlot(#[from] web_apps::get_process_slot::Error),
#[error(transparent)]
WebApps_DeleteProcessSlot(#[from] web_apps::delete_process_slot::Error),
#[error(transparent)]
WebApps_GetProcessDumpSlot(#[from] web_apps::get_process_dump_slot::Error),
#[error(transparent)]
WebApps_ListProcessModulesSlot(#[from] web_apps::list_process_modules_slot::Error),
#[error(transparent)]
WebApps_GetProcessModuleSlot(#[from] web_apps::get_process_module_slot::Error),
#[error(transparent)]
WebApps_ListProcessThreadsSlot(#[from] web_apps::list_process_threads_slot::Error),
#[error(transparent)]
WebApps_GetProcessThreadSlot(#[from] web_apps::get_process_thread_slot::Error),
#[error(transparent)]
WebApps_ListPublicCertificatesSlot(#[from] web_apps::list_public_certificates_slot::Error),
#[error(transparent)]
WebApps_GetPublicCertificateSlot(#[from] web_apps::get_public_certificate_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdatePublicCertificateSlot(#[from] web_apps::create_or_update_public_certificate_slot::Error),
#[error(transparent)]
WebApps_DeletePublicCertificateSlot(#[from] web_apps::delete_public_certificate_slot::Error),
#[error(transparent)]
WebApps_ListPublishingProfileXmlWithSecretsSlot(#[from] web_apps::list_publishing_profile_xml_with_secrets_slot::Error),
#[error(transparent)]
WebApps_RecoverSlot(#[from] web_apps::recover_slot::Error),
#[error(transparent)]
WebApps_ResetSlotConfigurationSlot(#[from] web_apps::reset_slot_configuration_slot::Error),
#[error(transparent)]
WebApps_RestartSlot(#[from] web_apps::restart_slot::Error),
#[error(transparent)]
WebApps_ListSiteExtensionsSlot(#[from] web_apps::list_site_extensions_slot::Error),
#[error(transparent)]
WebApps_GetSiteExtensionSlot(#[from] web_apps::get_site_extension_slot::Error),
#[error(transparent)]
WebApps_InstallSiteExtensionSlot(#[from] web_apps::install_site_extension_slot::Error),
#[error(transparent)]
WebApps_DeleteSiteExtensionSlot(#[from] web_apps::delete_site_extension_slot::Error),
#[error(transparent)]
WebApps_ListSlotDifferencesSlot(#[from] web_apps::list_slot_differences_slot::Error),
#[error(transparent)]
WebApps_SwapSlotSlot(#[from] web_apps::swap_slot_slot::Error),
#[error(transparent)]
WebApps_ListSnapshotsSlot(#[from] web_apps::list_snapshots_slot::Error),
#[error(transparent)]
WebApps_GetSourceControlSlot(#[from] web_apps::get_source_control_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateSourceControlSlot(#[from] web_apps::create_or_update_source_control_slot::Error),
#[error(transparent)]
WebApps_UpdateSourceControlSlot(#[from] web_apps::update_source_control_slot::Error),
#[error(transparent)]
WebApps_DeleteSourceControlSlot(#[from] web_apps::delete_source_control_slot::Error),
#[error(transparent)]
WebApps_StartSlot(#[from] web_apps::start_slot::Error),
#[error(transparent)]
WebApps_StopSlot(#[from] web_apps::stop_slot::Error),
#[error(transparent)]
WebApps_SyncRepositorySlot(#[from] web_apps::sync_repository_slot::Error),
#[error(transparent)]
WebApps_SyncFunctionTriggersSlot(#[from] web_apps::sync_function_triggers_slot::Error),
#[error(transparent)]
WebApps_ListTriggeredWebJobsSlot(#[from] web_apps::list_triggered_web_jobs_slot::Error),
#[error(transparent)]
WebApps_GetTriggeredWebJobSlot(#[from] web_apps::get_triggered_web_job_slot::Error),
#[error(transparent)]
WebApps_DeleteTriggeredWebJobSlot(#[from] web_apps::delete_triggered_web_job_slot::Error),
#[error(transparent)]
WebApps_ListTriggeredWebJobHistorySlot(#[from] web_apps::list_triggered_web_job_history_slot::Error),
#[error(transparent)]
WebApps_GetTriggeredWebJobHistorySlot(#[from] web_apps::get_triggered_web_job_history_slot::Error),
#[error(transparent)]
WebApps_RunTriggeredWebJobSlot(#[from] web_apps::run_triggered_web_job_slot::Error),
#[error(transparent)]
WebApps_ListUsagesSlot(#[from] web_apps::list_usages_slot::Error),
#[error(transparent)]
WebApps_ListVnetConnectionsSlot(#[from] web_apps::list_vnet_connections_slot::Error),
#[error(transparent)]
WebApps_GetVnetConnectionSlot(#[from] web_apps::get_vnet_connection_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateVnetConnectionSlot(#[from] web_apps::create_or_update_vnet_connection_slot::Error),
#[error(transparent)]
WebApps_UpdateVnetConnectionSlot(#[from] web_apps::update_vnet_connection_slot::Error),
#[error(transparent)]
WebApps_DeleteVnetConnectionSlot(#[from] web_apps::delete_vnet_connection_slot::Error),
#[error(transparent)]
WebApps_GetVnetConnectionGatewaySlot(#[from] web_apps::get_vnet_connection_gateway_slot::Error),
#[error(transparent)]
WebApps_CreateOrUpdateVnetConnectionGatewaySlot(#[from] web_apps::create_or_update_vnet_connection_gateway_slot::Error),
#[error(transparent)]
WebApps_UpdateVnetConnectionGatewaySlot(#[from] web_apps::update_vnet_connection_gateway_slot::Error),
#[error(transparent)]
WebApps_ListWebJobsSlot(#[from] web_apps::list_web_jobs_slot::Error),
#[error(transparent)]
WebApps_GetWebJobSlot(#[from] web_apps::get_web_job_slot::Error),
#[error(transparent)]
WebApps_ListSlotDifferencesFromProduction(#[from] web_apps::list_slot_differences_from_production::Error),
#[error(transparent)]
WebApps_SwapSlotWithProduction(#[from] web_apps::swap_slot_with_production::Error),
#[error(transparent)]
WebApps_ListSnapshots(#[from] web_apps::list_snapshots::Error),
#[error(transparent)]
WebApps_GetSourceControl(#[from] web_apps::get_source_control::Error),
#[error(transparent)]
WebApps_CreateOrUpdateSourceControl(#[from] web_apps::create_or_update_source_control::Error),
#[error(transparent)]
WebApps_UpdateSourceControl(#[from] web_apps::update_source_control::Error),
#[error(transparent)]
WebApps_DeleteSourceControl(#[from] web_apps::delete_source_control::Error),
#[error(transparent)]
WebApps_Start(#[from] web_apps::start::Error),
#[error(transparent)]
WebApps_Stop(#[from] web_apps::stop::Error),
#[error(transparent)]
WebApps_SyncRepository(#[from] web_apps::sync_repository::Error),
#[error(transparent)]
WebApps_SyncFunctionTriggers(#[from] web_apps::sync_function_triggers::Error),
#[error(transparent)]
WebApps_ListTriggeredWebJobs(#[from] web_apps::list_triggered_web_jobs::Error),
#[error(transparent)]
WebApps_GetTriggeredWebJob(#[from] web_apps::get_triggered_web_job::Error),
#[error(transparent)]
WebApps_DeleteTriggeredWebJob(#[from] web_apps::delete_triggered_web_job::Error),
#[error(transparent)]
WebApps_ListTriggeredWebJobHistory(#[from] web_apps::list_triggered_web_job_history::Error),
#[error(transparent)]
WebApps_GetTriggeredWebJobHistory(#[from] web_apps::get_triggered_web_job_history::Error),
#[error(transparent)]
WebApps_RunTriggeredWebJob(#[from] web_apps::run_triggered_web_job::Error),
#[error(transparent)]
WebApps_ListUsages(#[from] web_apps::list_usages::Error),
#[error(transparent)]
WebApps_ListVnetConnections(#[from] web_apps::list_vnet_connections::Error),
#[error(transparent)]
WebApps_GetVnetConnection(#[from] web_apps::get_vnet_connection::Error),
#[error(transparent)]
WebApps_CreateOrUpdateVnetConnection(#[from] web_apps::create_or_update_vnet_connection::Error),
#[error(transparent)]
WebApps_UpdateVnetConnection(#[from] web_apps::update_vnet_connection::Error),
#[error(transparent)]
WebApps_DeleteVnetConnection(#[from] web_apps::delete_vnet_connection::Error),
#[error(transparent)]
WebApps_GetVnetConnectionGateway(#[from] web_apps::get_vnet_connection_gateway::Error),
#[error(transparent)]
WebApps_CreateOrUpdateVnetConnectionGateway(#[from] web_apps::create_or_update_vnet_connection_gateway::Error),
#[error(transparent)]
WebApps_UpdateVnetConnectionGateway(#[from] web_apps::update_vnet_connection_gateway::Error),
#[error(transparent)]
WebApps_ListWebJobs(#[from] web_apps::list_web_jobs::Error),
#[error(transparent)]
WebApps_GetWebJob(#[from] web_apps::get_web_job::Error),
}
pub mod web_apps {
use super::{models, API_VERSION};
pub async fn list(
operation_config: &crate::OperationConfig,
subscription_id: &str,
) -> std::result::Result<models::WebAppCollection, list::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/providers/Microsoft.Web/sites",
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::WebAppCollection =
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();
Err(list::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list {
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_resource_group(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
include_slots: Option<bool>,
subscription_id: &str,
) -> std::result::Result<models::WebAppCollection, list_by_resource_group::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites",
operation_config.base_path(),
subscription_id,
resource_group_name
);
let mut url = url::Url::parse(url_str).map_err(list_by_resource_group::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_by_resource_group::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
if let Some(include_slots) = include_slots {
url.query_pairs_mut()
.append_pair("includeSlots", include_slots.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_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::WebAppCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_by_resource_group::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_by_resource_group::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_by_resource_group {
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 get(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::Site, get::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
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::Site =
serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get::Error::NotFound404 {}),
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("Error response #response_type")]
NotFound404 {},
#[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,
resource_group_name: &str,
name: &str,
site_envelope: &models::Site,
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.Web/sites/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
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(site_envelope).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::Site = 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 => {
let rsp_body = rsp.body();
let rsp_value: models::Site = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update::Response::Accepted202(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::Site),
Accepted202(models::Site),
}
#[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 update(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_envelope: &models::SitePatchResource,
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.Web/sites/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
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(site_envelope).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::Site =
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 => {
let rsp_body = rsp.body();
let rsp_value: models::Site =
serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(update::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Site),
Accepted202(models::Site),
}
#[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,
resource_group_name: &str,
name: &str,
delete_metrics: Option<bool>,
delete_empty_server_farm: Option<bool>,
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.Web/sites/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
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);
if let Some(delete_metrics) = delete_metrics {
url.query_pairs_mut()
.append_pair("deleteMetrics", delete_metrics.to_string().as_str());
}
if let Some(delete_empty_server_farm) = delete_empty_server_farm {
url.query_pairs_mut()
.append_pair("deleteEmptyServerFarm", delete_empty_server_farm.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(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),
http::StatusCode::NOT_FOUND => Err(delete::Error::NotFound404 {}),
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("Error response #response_type")]
NotFound404 {},
#[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 analyze_custom_hostname(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
host_name: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::CustomHostnameAnalysisResult, analyze_custom_hostname::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/analyzeCustomHostname",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(analyze_custom_hostname::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(analyze_custom_hostname::Error::GetTokenError)?;
req_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(host_name) = host_name {
url.query_pairs_mut().append_pair("hostName", host_name);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(analyze_custom_hostname::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(analyze_custom_hostname::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomHostnameAnalysisResult = serde_json::from_slice(rsp_body)
.map_err(|source| analyze_custom_hostname::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(analyze_custom_hostname::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod analyze_custom_hostname {
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 apply_slot_config_to_production(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_swap_entity: &models::CsmSlotEntity,
subscription_id: &str,
) -> std::result::Result<(), apply_slot_config_to_production::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/applySlotConfig",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(apply_slot_config_to_production::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(apply_slot_config_to_production::Error::GetTokenError)?;
req_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(slot_swap_entity).map_err(apply_slot_config_to_production::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(apply_slot_config_to_production::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(apply_slot_config_to_production::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(apply_slot_config_to_production::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod apply_slot_config_to_production {
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 backup(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
request: &models::BackupRequest,
subscription_id: &str,
) -> std::result::Result<models::BackupItem, backup::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backup",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(backup::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(backup::Error::GetTokenError)?;
req_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(request).map_err(backup::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(backup::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(backup::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItem =
serde_json::from_slice(rsp_body).map_err(|source| backup::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(backup::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod backup {
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_backups(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupItemCollection, list_backups::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_backups::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_backups::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backups::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_backups::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItemCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_backups::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_backups::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_backups {
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 discover_restore(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
request: &models::RestoreRequest,
subscription_id: &str,
) -> std::result::Result<models::RestoreRequest, discover_restore::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/discover",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(discover_restore::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(discover_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(request).map_err(discover_restore::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(discover_restore::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(discover_restore::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestoreRequest = serde_json::from_slice(rsp_body)
.map_err(|source| discover_restore::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(discover_restore::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod discover_restore {
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 get_backup_status(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupItem, get_backup_status::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(get_backup_status::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_backup_status::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backup_status::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_backup_status::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItem = serde_json::from_slice(rsp_body)
.map_err(|source| get_backup_status::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_backup_status::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_backup_status {
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_backup(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_backup::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(delete_backup::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_backup::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backup::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_backup::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_backup::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_backup::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_backup {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_backup_status_secrets(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
request: &models::BackupRequest,
subscription_id: &str,
) -> std::result::Result<models::BackupItem, list_backup_status_secrets::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(list_backup_status_secrets::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_backup_status_secrets::Error::GetTokenError)?;
req_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(request).map_err(list_backup_status_secrets::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_backup_status_secrets::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_backup_status_secrets::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItem = serde_json::from_slice(rsp_body)
.map_err(|source| list_backup_status_secrets::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_backup_status_secrets::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_backup_status_secrets {
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 restore(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
request: &models::RestoreRequest,
subscription_id: &str,
) -> std::result::Result<models::RestoreResponse, restore::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}/restore",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(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(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(request).map_err(restore::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(restore::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(restore::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestoreResponse =
serde_json::from_slice(rsp_body).map_err(|source| restore::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(restore::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod restore {
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_configurations(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResourceCollection, list_configurations::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_configurations::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configurations::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configurations::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_configurations::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResourceCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_configurations::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_configurations::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_configurations {
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 update_application_settings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
app_settings: &models::StringDictionary,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, update_application_settings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/appsettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_application_settings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_application_settings::Error::GetTokenError)?;
req_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(app_settings).map_err(update_application_settings::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_application_settings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_application_settings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| update_application_settings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_application_settings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_application_settings {
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_application_settings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, list_application_settings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/appsettings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_application_settings::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_application_settings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_application_settings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_application_settings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| list_application_settings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_application_settings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_application_settings {
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 update_auth_settings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_auth_settings: &models::SiteAuthSettings,
subscription_id: &str,
) -> std::result::Result<models::SiteAuthSettings, update_auth_settings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_auth_settings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_auth_settings::Error::GetTokenError)?;
req_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(site_auth_settings).map_err(update_auth_settings::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update_auth_settings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_auth_settings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteAuthSettings = serde_json::from_slice(rsp_body)
.map_err(|source| update_auth_settings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_auth_settings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_auth_settings {
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 get_auth_settings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteAuthSettings, get_auth_settings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_auth_settings::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(get_auth_settings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(get_auth_settings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_auth_settings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteAuthSettings = serde_json::from_slice(rsp_body)
.map_err(|source| get_auth_settings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_auth_settings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_auth_settings {
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 update_backup_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
request: &models::BackupRequest,
subscription_id: &str,
) -> std::result::Result<models::BackupRequest, update_backup_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/backup",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_backup_configuration::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_backup_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);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(request).map_err(update_backup_configuration::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_backup_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_backup_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupRequest = serde_json::from_slice(rsp_body)
.map_err(|source| update_backup_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_backup_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_backup_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 async fn delete_backup_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_backup_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/backup",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(delete_backup_configuration::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_backup_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(delete_backup_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_backup_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(delete_backup_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_backup_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 async fn get_backup_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupRequest, get_backup_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/backup/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_backup_configuration::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(get_backup_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.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(get_backup_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_backup_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupRequest = serde_json::from_slice(rsp_body)
.map_err(|source| get_backup_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_backup_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_backup_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 async fn update_connection_strings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
connection_strings: &models::ConnectionStringDictionary,
subscription_id: &str,
) -> std::result::Result<models::ConnectionStringDictionary, update_connection_strings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/connectionstrings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_connection_strings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_connection_strings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(connection_strings).map_err(update_connection_strings::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_connection_strings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_connection_strings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectionStringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| update_connection_strings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_connection_strings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_connection_strings {
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_connection_strings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::ConnectionStringDictionary, list_connection_strings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/connectionstrings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_connection_strings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_connection_strings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_connection_strings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_connection_strings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectionStringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| list_connection_strings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_connection_strings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_connection_strings {
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 get_diagnostic_logs_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteLogsConfig, get_diagnostic_logs_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/logs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_diagnostic_logs_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(get_diagnostic_logs_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(get_diagnostic_logs_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_diagnostic_logs_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteLogsConfig = serde_json::from_slice(rsp_body)
.map_err(|source| get_diagnostic_logs_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_diagnostic_logs_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_diagnostic_logs_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 async fn update_diagnostic_logs_config(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_logs_config: &models::SiteLogsConfig,
subscription_id: &str,
) -> std::result::Result<models::SiteLogsConfig, update_diagnostic_logs_config::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/logs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_diagnostic_logs_config::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_diagnostic_logs_config::Error::GetTokenError)?;
req_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(site_logs_config).map_err(update_diagnostic_logs_config::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_diagnostic_logs_config::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_diagnostic_logs_config::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteLogsConfig = serde_json::from_slice(rsp_body)
.map_err(|source| update_diagnostic_logs_config::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_diagnostic_logs_config::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_diagnostic_logs_config {
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 update_metadata(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
metadata: &models::StringDictionary,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, update_metadata::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/metadata",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_metadata::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_metadata::Error::GetTokenError)?;
req_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(metadata).map_err(update_metadata::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update_metadata::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_metadata::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| update_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_metadata::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_metadata {
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_metadata(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, list_metadata::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/metadata/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_metadata::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_metadata::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_metadata::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metadata::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary =
serde_json::from_slice(rsp_body).map_err(|source| list_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metadata::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metadata {
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_publishing_credentials(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::User, list_publishing_credentials::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/publishingcredentials/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_publishing_credentials::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_publishing_credentials::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_publishing_credentials::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_publishing_credentials::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::User = serde_json::from_slice(rsp_body)
.map_err(|source| list_publishing_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_publishing_credentials::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_publishing_credentials {
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 update_site_push_settings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
push_settings: &models::PushSettings,
subscription_id: &str,
) -> std::result::Result<models::PushSettings, update_site_push_settings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/pushsettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_site_push_settings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_site_push_settings::Error::GetTokenError)?;
req_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(push_settings).map_err(update_site_push_settings::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_site_push_settings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_site_push_settings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PushSettings = serde_json::from_slice(rsp_body)
.map_err(|source| update_site_push_settings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_site_push_settings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_site_push_settings {
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_site_push_settings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::PushSettings, list_site_push_settings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/pushsettings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_site_push_settings::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_site_push_settings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_site_push_settings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_site_push_settings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PushSettings = serde_json::from_slice(rsp_body)
.map_err(|source| list_site_push_settings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_site_push_settings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_site_push_settings {
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_slot_configuration_names(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SlotConfigNamesResource, list_slot_configuration_names::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/slotConfigNames",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_slot_configuration_names::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_slot_configuration_names::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_slot_configuration_names::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_slot_configuration_names::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SlotConfigNamesResource = serde_json::from_slice(rsp_body)
.map_err(|source| list_slot_configuration_names::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_slot_configuration_names::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_slot_configuration_names {
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 update_slot_configuration_names(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_config_names: &models::SlotConfigNamesResource,
subscription_id: &str,
) -> std::result::Result<models::SlotConfigNamesResource, update_slot_configuration_names::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/slotConfigNames",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_slot_configuration_names::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_slot_configuration_names::Error::GetTokenError)?;
req_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(slot_config_names).map_err(update_slot_configuration_names::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_slot_configuration_names::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_slot_configuration_names::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SlotConfigNamesResource = serde_json::from_slice(rsp_body)
.map_err(|source| update_slot_configuration_names::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_slot_configuration_names::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_slot_configuration_names {
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 get_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, get_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_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(get_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(get_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| get_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_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 async fn create_or_update_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_config: &models::SiteConfigResource,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, create_or_update_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_configuration::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_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);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(site_config).map_err(create_or_update_configuration::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_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 async fn update_configuration(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_config: &models::SiteConfigResource,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, update_configuration::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_configuration::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_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);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(site_config).map_err(update_configuration::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update_configuration::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_configuration::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| update_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_configuration::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_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 async fn list_configuration_snapshot_info(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigurationSnapshotInfoCollection, list_configuration_snapshot_info::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web/snapshots",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_configuration_snapshot_info::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configuration_snapshot_info::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configuration_snapshot_info::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_configuration_snapshot_info::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigurationSnapshotInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_configuration_snapshot_info::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_configuration_snapshot_info::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_configuration_snapshot_info {
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 get_configuration_snapshot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
snapshot_id: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, get_configuration_snapshot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web/snapshots/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
snapshot_id
);
let mut url = url::Url::parse(url_str).map_err(get_configuration_snapshot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configuration_snapshot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configuration_snapshot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_configuration_snapshot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| get_configuration_snapshot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_configuration_snapshot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_configuration_snapshot {
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 recover_site_configuration_snapshot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
snapshot_id: &str,
subscription_id: &str,
) -> std::result::Result<(), recover_site_configuration_snapshot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web/snapshots/{}/recover",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
snapshot_id
);
let mut url = url::Url::parse(url_str).map_err(recover_site_configuration_snapshot::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(recover_site_configuration_snapshot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(recover_site_configuration_snapshot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(recover_site_configuration_snapshot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(recover_site_configuration_snapshot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod recover_site_configuration_snapshot {
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 get_web_site_container_logs(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<get_web_site_container_logs::Response, get_web_site_container_logs::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/containerlogs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_web_site_container_logs::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(get_web_site_container_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);
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(get_web_site_container_logs::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_web_site_container_logs::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(get_web_site_container_logs::Response::NoContent204),
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(get_web_site_container_logs::Response::Ok200(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(get_web_site_container_logs::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_web_site_container_logs {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Ok200(bytes::Bytes),
}
#[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 get_web_site_container_logs_zip(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<get_web_site_container_logs_zip::Response, get_web_site_container_logs_zip::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/containerlogs/zip/download",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_web_site_container_logs_zip::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(get_web_site_container_logs_zip::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(get_web_site_container_logs_zip::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_web_site_container_logs_zip::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(get_web_site_container_logs_zip::Response::NoContent204),
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(get_web_site_container_logs_zip::Response::Ok200(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(get_web_site_container_logs_zip::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_web_site_container_logs_zip {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Ok200(bytes::Bytes),
}
#[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_continuous_web_jobs(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::ContinuousWebJobCollection, list_continuous_web_jobs::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_continuous_web_jobs::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_continuous_web_jobs::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_continuous_web_jobs::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_continuous_web_jobs::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ContinuousWebJobCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_continuous_web_jobs::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_continuous_web_jobs::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_continuous_web_jobs {
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 get_continuous_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::ContinuousWebJob, get_continuous_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(get_continuous_web_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(get_continuous_web_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(get_continuous_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_continuous_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ContinuousWebJob = serde_json::from_slice(rsp_body)
.map_err(|source| get_continuous_web_job::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_continuous_web_job::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_continuous_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_continuous_web_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_continuous_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_continuous_web_job::Response, delete_continuous_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(delete_continuous_web_job::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_continuous_web_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(delete_continuous_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_continuous_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_continuous_web_job::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_continuous_web_job::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_continuous_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_continuous_web_job {
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 start_continuous_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<(), start_continuous_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(start_continuous_web_job::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(start_continuous_web_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.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(start_continuous_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(start_continuous_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(start_continuous_web_job::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(start_continuous_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod start_continuous_web_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 stop_continuous_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<(), stop_continuous_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}/stop",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(stop_continuous_web_job::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(stop_continuous_web_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.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(stop_continuous_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(stop_continuous_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(stop_continuous_web_job::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(stop_continuous_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod stop_continuous_web_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_deployments(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::DeploymentCollection, list_deployments::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_deployments::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_deployments::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployments::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_deployments::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DeploymentCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_deployments::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_deployments::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_deployments {
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 get_deployment(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
subscription_id: &str,
) -> std::result::Result<models::Deployment, get_deployment::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
id
);
let mut url = url::Url::parse(url_str).map_err(get_deployment::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_deployment::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployment::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_deployment::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Deployment =
serde_json::from_slice(rsp_body).map_err(|source| get_deployment::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_deployment::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_deployment {
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_deployment(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
deployment: &models::Deployment,
subscription_id: &str,
) -> std::result::Result<models::Deployment, create_deployment::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
id
);
let mut url = url::Url::parse(url_str).map_err(create_deployment::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_deployment::Error::GetTokenError)?;
req_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(deployment).map_err(create_deployment::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_deployment::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_deployment::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Deployment = serde_json::from_slice(rsp_body)
.map_err(|source| create_deployment::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_deployment::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_deployment {
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_deployment(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
subscription_id: &str,
) -> std::result::Result<delete_deployment::Response, delete_deployment::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
id
);
let mut url = url::Url::parse(url_str).map_err(delete_deployment::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_deployment::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployment::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_deployment::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_deployment::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_deployment::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_deployment::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_deployment {
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_deployment_log(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
subscription_id: &str,
) -> std::result::Result<models::Deployment, list_deployment_log::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}/log",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
id
);
let mut url = url::Url::parse(url_str).map_err(list_deployment_log::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_deployment_log::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployment_log::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_deployment_log::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Deployment = serde_json::from_slice(rsp_body)
.map_err(|source| list_deployment_log::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_deployment_log::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_deployment_log {
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_domain_ownership_identifiers(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::IdentifierCollection, list_domain_ownership_identifiers::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_domain_ownership_identifiers::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_domain_ownership_identifiers::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_domain_ownership_identifiers::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_domain_ownership_identifiers::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IdentifierCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_domain_ownership_identifiers::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_domain_ownership_identifiers::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_domain_ownership_identifiers {
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 get_domain_ownership_identifier(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
subscription_id: &str,
) -> std::result::Result<models::Identifier, get_domain_ownership_identifier::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(get_domain_ownership_identifier::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_domain_ownership_identifier::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_domain_ownership_identifier::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_domain_ownership_identifier::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Identifier = serde_json::from_slice(rsp_body)
.map_err(|source| get_domain_ownership_identifier::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_domain_ownership_identifier::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_domain_ownership_identifier {
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_domain_ownership_identifier(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
domain_ownership_identifier: &models::Identifier,
subscription_id: &str,
) -> std::result::Result<models::Identifier, create_or_update_domain_ownership_identifier::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_domain_ownership_identifier::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_domain_ownership_identifier::Error::GetTokenError)?;
req_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(domain_ownership_identifier)
.map_err(create_or_update_domain_ownership_identifier::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_domain_ownership_identifier::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_domain_ownership_identifier::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Identifier = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_domain_ownership_identifier::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_domain_ownership_identifier::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_domain_ownership_identifier {
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 update_domain_ownership_identifier(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
domain_ownership_identifier: &models::Identifier,
subscription_id: &str,
) -> std::result::Result<models::Identifier, update_domain_ownership_identifier::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(update_domain_ownership_identifier::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_domain_ownership_identifier::Error::GetTokenError)?;
req_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(domain_ownership_identifier).map_err(update_domain_ownership_identifier::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_domain_ownership_identifier::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_domain_ownership_identifier::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Identifier = serde_json::from_slice(rsp_body)
.map_err(|source| update_domain_ownership_identifier::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_domain_ownership_identifier::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_domain_ownership_identifier {
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_domain_ownership_identifier(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_domain_ownership_identifier::Response, delete_domain_ownership_identifier::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(delete_domain_ownership_identifier::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_domain_ownership_identifier::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_domain_ownership_identifier::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_domain_ownership_identifier::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_domain_ownership_identifier::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_domain_ownership_identifier::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_domain_ownership_identifier::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_domain_ownership_identifier {
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 get_ms_deploy_status(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, get_ms_deploy_status::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_ms_deploy_status::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_ms_deploy_status::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_ms_deploy_status::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_ms_deploy_status::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| get_ms_deploy_status::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_ms_deploy_status::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_ms_deploy_status {
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_ms_deploy_operation(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
ms_deploy: &models::MsDeploy,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, create_ms_deploy_operation::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(create_ms_deploy_operation::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_ms_deploy_operation::Error::GetTokenError)?;
req_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(ms_deploy).map_err(create_ms_deploy_operation::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_ms_deploy_operation::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_ms_deploy_operation::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| create_ms_deploy_operation::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::CONFLICT => Err(create_ms_deploy_operation::Error::Conflict409 {}),
status_code => {
let rsp_body = rsp.body();
Err(create_ms_deploy_operation::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_ms_deploy_operation {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
Conflict409 {},
#[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 get_ms_deploy_log(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployLog, get_ms_deploy_log::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/MSDeploy/log",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_ms_deploy_log::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_ms_deploy_log::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_ms_deploy_log::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_ms_deploy_log::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployLog = serde_json::from_slice(rsp_body)
.map_err(|source| get_ms_deploy_log::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_ms_deploy_log::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_ms_deploy_log::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_ms_deploy_log {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_functions(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionEnvelopeCollection, list_functions::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_functions::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_functions::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_functions::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_functions::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionEnvelopeCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_functions::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_functions::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_functions::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_functions {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_functions_admin_token(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<String, get_functions_admin_token::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/admin/token",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_functions_admin_token::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_functions_admin_token::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_functions_admin_token::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_functions_admin_token::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: String = serde_json::from_slice(rsp_body)
.map_err(|source| get_functions_admin_token::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_functions_admin_token::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_functions_admin_token {
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 get_function(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionEnvelope, get_function::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
function_name
);
let mut url = url::Url::parse(url_str).map_err(get_function::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_function::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_function::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_function::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionEnvelope =
serde_json::from_slice(rsp_body).map_err(|source| get_function::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_function::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_function::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_function {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_function(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
function_envelope: &models::FunctionEnvelope,
subscription_id: &str,
) -> std::result::Result<models::FunctionEnvelope, create_function::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
function_name
);
let mut url = url::Url::parse(url_str).map_err(create_function::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_function::Error::GetTokenError)?;
req_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(function_envelope).map_err(create_function::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(create_function::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_function::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionEnvelope = serde_json::from_slice(rsp_body)
.map_err(|source| create_function::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_function::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_function {
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_function(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_function::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
function_name
);
let mut url = url::Url::parse(url_str).map_err(delete_function::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_function::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_function::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_function::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_function::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_function::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_function {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_function_secrets(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionSecrets, list_function_secrets::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}/listsecrets",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
function_name
);
let mut url = url::Url::parse(url_str).map_err(list_function_secrets::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_function_secrets::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_function_secrets::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_function_secrets::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionSecrets = serde_json::from_slice(rsp_body)
.map_err(|source| list_function_secrets::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_function_secrets::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_function_secrets {
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_host_name_bindings(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::HostNameBindingCollection, list_host_name_bindings::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_host_name_bindings::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_host_name_bindings::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_host_name_bindings::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_host_name_bindings::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HostNameBindingCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_host_name_bindings::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_host_name_bindings::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_host_name_bindings {
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 get_host_name_binding(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
host_name: &str,
subscription_id: &str,
) -> std::result::Result<models::HostNameBinding, get_host_name_binding::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
host_name
);
let mut url = url::Url::parse(url_str).map_err(get_host_name_binding::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_host_name_binding::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_host_name_binding::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_host_name_binding::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HostNameBinding = serde_json::from_slice(rsp_body)
.map_err(|source| get_host_name_binding::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_host_name_binding::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_host_name_binding {
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_host_name_binding(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
host_name: &str,
host_name_binding: &models::HostNameBinding,
subscription_id: &str,
) -> std::result::Result<models::HostNameBinding, create_or_update_host_name_binding::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
host_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_host_name_binding::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_host_name_binding::Error::GetTokenError)?;
req_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(host_name_binding).map_err(create_or_update_host_name_binding::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_host_name_binding::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_host_name_binding::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HostNameBinding = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_host_name_binding::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_host_name_binding::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_host_name_binding {
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_host_name_binding(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
host_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_host_name_binding::Response, delete_host_name_binding::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
host_name
);
let mut url = url::Url::parse(url_str).map_err(delete_host_name_binding::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_host_name_binding::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_host_name_binding::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_host_name_binding::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_host_name_binding::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_host_name_binding::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_host_name_binding::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_host_name_binding {
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 get_hybrid_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, get_hybrid_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(get_hybrid_connection::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_hybrid_connection::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_hybrid_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_hybrid_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| get_hybrid_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_hybrid_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_hybrid_connection {
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_hybrid_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
connection_envelope: &models::HybridConnection,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, create_or_update_hybrid_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_hybrid_connection::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_hybrid_connection::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_hybrid_connection::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_hybrid_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_hybrid_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_hybrid_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_hybrid_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_hybrid_connection {
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 update_hybrid_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
connection_envelope: &models::HybridConnection,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, update_hybrid_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(update_hybrid_connection::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_hybrid_connection::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_hybrid_connection::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_hybrid_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_hybrid_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| update_hybrid_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_hybrid_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_hybrid_connection {
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_hybrid_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_hybrid_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(delete_hybrid_connection::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_hybrid_connection::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_hybrid_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_hybrid_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_hybrid_connection::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_hybrid_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_hybrid_connection {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_hybrid_connection_keys(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnectionKey, list_hybrid_connection_keys::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}/listKeys",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(list_hybrid_connection_keys::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_hybrid_connection_keys::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_hybrid_connection_keys::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_hybrid_connection_keys::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnectionKey = serde_json::from_slice(rsp_body)
.map_err(|source| list_hybrid_connection_keys::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_hybrid_connection_keys::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_hybrid_connection_keys {
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_hybrid_connections(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, list_hybrid_connections::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionRelays",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_hybrid_connections::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_hybrid_connections::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_hybrid_connections::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_hybrid_connections::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| list_hybrid_connections::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_hybrid_connections::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_hybrid_connections {
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_relay_service_connections(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, list_relay_service_connections::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_relay_service_connections::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_relay_service_connections::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_relay_service_connections::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_relay_service_connections::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| list_relay_service_connections::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_relay_service_connections::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_relay_service_connections {
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 get_relay_service_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, get_relay_service_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(get_relay_service_connection::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_relay_service_connection::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_relay_service_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_relay_service_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| get_relay_service_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_relay_service_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_relay_service_connection {
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_relay_service_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
connection_envelope: &models::RelayServiceConnectionEntity,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, create_or_update_relay_service_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_relay_service_connection::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_relay_service_connection::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_relay_service_connection::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_relay_service_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_relay_service_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_relay_service_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_relay_service_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_relay_service_connection {
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 update_relay_service_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
connection_envelope: &models::RelayServiceConnectionEntity,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, update_relay_service_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(update_relay_service_connection::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_relay_service_connection::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_relay_service_connection::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_relay_service_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_relay_service_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| update_relay_service_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_relay_service_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_relay_service_connection {
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_relay_service_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_relay_service_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(delete_relay_service_connection::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_relay_service_connection::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_relay_service_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_relay_service_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_relay_service_connection::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_relay_service_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_relay_service_connection {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_identifiers(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::WebAppInstanceCollection, list_instance_identifiers::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_instance_identifiers::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_identifiers::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_identifiers::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_identifiers::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebAppInstanceCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_identifiers::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_instance_identifiers::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_identifiers {
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 get_instance_ms_deploy_status(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, get_instance_ms_deploy_status::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_ms_deploy_status::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_ms_deploy_status::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_ms_deploy_status::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_ms_deploy_status::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_ms_deploy_status::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_instance_ms_deploy_status::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_ms_deploy_status {
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_instance_ms_deploy_operation(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
instance_id: &str,
ms_deploy: &models::MsDeploy,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, create_instance_ms_deploy_operation::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(create_instance_ms_deploy_operation::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_instance_ms_deploy_operation::Error::GetTokenError)?;
req_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(ms_deploy).map_err(create_instance_ms_deploy_operation::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_instance_ms_deploy_operation::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_instance_ms_deploy_operation::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| create_instance_ms_deploy_operation::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::CONFLICT => Err(create_instance_ms_deploy_operation::Error::Conflict409 {}),
status_code => {
let rsp_body = rsp.body();
Err(create_instance_ms_deploy_operation::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_instance_ms_deploy_operation {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
Conflict409 {},
#[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 get_instance_ms_deploy_log(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployLog, get_instance_ms_deploy_log::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/extensions/MSDeploy/log",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_ms_deploy_log::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_ms_deploy_log::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_ms_deploy_log::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_ms_deploy_log::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployLog = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_ms_deploy_log::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_ms_deploy_log::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_ms_deploy_log::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_ms_deploy_log {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_processes(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfoCollection, list_instance_processes::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(list_instance_processes::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_processes::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_processes::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_processes::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_processes::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_processes::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_processes::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_processes {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfo, get_instance_process::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_process::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_process(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_instance_process::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(delete_instance_process::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_instance_process::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_instance_process::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_instance_process::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_instance_process::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_instance_process {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_dump(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<bytes::Bytes, get_instance_process_dump::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/dump",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_dump::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_dump::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_dump::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_dump::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_dump::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_dump::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_dump {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_process_modules(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfoCollection, list_instance_process_modules::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/modules",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_instance_process_modules::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_modules::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_modules::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_process_modules::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_process_modules::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_process_modules::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_process_modules::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_process_modules {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_module(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
base_address: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfo, get_instance_process_module::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/modules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id,
base_address
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_module::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_module::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_module::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_module::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_process_module::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_module::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_module::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_module {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_process_threads(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfoCollection, list_instance_process_threads::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/threads",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_instance_process_threads::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_threads::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_threads::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_process_threads::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_process_threads::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_process_threads::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_process_threads::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_process_threads {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_thread(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
thread_id: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfo, get_instance_process_thread::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/threads/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
instance_id,
process_id,
thread_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_thread::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_thread::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_thread::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_thread::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_process_thread::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_thread::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_thread::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_thread {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 is_cloneable(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteCloneability, is_cloneable::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/iscloneable",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(is_cloneable::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(is_cloneable::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(is_cloneable::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(is_cloneable::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteCloneability =
serde_json::from_slice(rsp_body).map_err(|source| is_cloneable::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(is_cloneable::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod is_cloneable {
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_sync_function_triggers(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionSecrets, list_sync_function_triggers::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/listsyncfunctiontriggerstatus",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_sync_function_triggers::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_sync_function_triggers::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_sync_function_triggers::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_sync_function_triggers::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionSecrets = serde_json::from_slice(rsp_body)
.map_err(|source| list_sync_function_triggers::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_sync_function_triggers::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_sync_function_triggers {
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,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::ResourceMetricDefinitionCollection, list_metric_definitions::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/metricdefinitions",
operation_config.base_path(),
subscription_id,
resource_group_name,
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::ResourceMetricDefinitionCollection = 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_metrics(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
details: Option<bool>,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ResourceMetricCollection, list_metrics::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/metrics",
operation_config.base_path(),
subscription_id,
resource_group_name,
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);
if let Some(details) = details {
url.query_pairs_mut().append_pair("details", details.to_string().as_str());
}
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_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::ResourceMetricCollection =
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 migrate_storage(
operation_config: &crate::OperationConfig,
subscription_name: &str,
resource_group_name: &str,
name: &str,
migration_options: &models::StorageMigrationOptions,
subscription_id: &str,
) -> std::result::Result<models::StorageMigrationResponse, migrate_storage::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/migrate",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(migrate_storage::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(migrate_storage::Error::GetTokenError)?;
req_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("subscriptionName", subscription_name);
req_builder = req_builder.header("content-type", "application/json");
let req_body = azure_core::to_json(migration_options).map_err(migrate_storage::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(migrate_storage::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(migrate_storage::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StorageMigrationResponse = serde_json::from_slice(rsp_body)
.map_err(|source| migrate_storage::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(migrate_storage::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod migrate_storage {
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 migrate_my_sql(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
migration_request_envelope: &models::MigrateMySqlRequest,
subscription_id: &str,
) -> std::result::Result<models::Operation, migrate_my_sql::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/migratemysql",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(migrate_my_sql::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(migrate_my_sql::Error::GetTokenError)?;
req_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(migration_request_envelope).map_err(migrate_my_sql::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(migrate_my_sql::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(migrate_my_sql::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Operation =
serde_json::from_slice(rsp_body).map_err(|source| migrate_my_sql::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(migrate_my_sql::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod migrate_my_sql {
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 get_migrate_my_sql_status(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::MigrateMySqlStatus, get_migrate_my_sql_status::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/migratemysql/status",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_migrate_my_sql_status::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_migrate_my_sql_status::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_migrate_my_sql_status::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_migrate_my_sql_status::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MigrateMySqlStatus = serde_json::from_slice(rsp_body)
.map_err(|source| get_migrate_my_sql_status::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_migrate_my_sql_status::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_migrate_my_sql_status {
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_network_features(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
view: &str,
subscription_id: &str,
) -> std::result::Result<models::NetworkFeatures, list_network_features::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkFeatures/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
view
);
let mut url = url::Url::parse(url_str).map_err(list_network_features::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_network_features::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_network_features::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_network_features::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::NetworkFeatures = serde_json::from_slice(rsp_body)
.map_err(|source| list_network_features::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_network_features::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_network_features::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_network_features {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 start_web_site_network_trace(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
duration_in_seconds: Option<i32>,
max_frame_length: Option<i32>,
sas_url: Option<&str>,
subscription_id: &str,
) -> std::result::Result<String, start_web_site_network_trace::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(start_web_site_network_trace::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(start_web_site_network_trace::Error::GetTokenError)?;
req_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(duration_in_seconds) = duration_in_seconds {
url.query_pairs_mut()
.append_pair("durationInSeconds", duration_in_seconds.to_string().as_str());
}
if let Some(max_frame_length) = max_frame_length {
url.query_pairs_mut()
.append_pair("maxFrameLength", max_frame_length.to_string().as_str());
}
if let Some(sas_url) = sas_url {
url.query_pairs_mut().append_pair("sasUrl", sas_url);
}
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(start_web_site_network_trace::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(start_web_site_network_trace::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: String = serde_json::from_slice(rsp_body)
.map_err(|source| start_web_site_network_trace::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(start_web_site_network_trace::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod start_web_site_network_trace {
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 stop_web_site_network_trace(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<String, stop_web_site_network_trace::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/stop",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(stop_web_site_network_trace::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(stop_web_site_network_trace::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(stop_web_site_network_trace::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(stop_web_site_network_trace::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: String = serde_json::from_slice(rsp_body)
.map_err(|source| stop_web_site_network_trace::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(stop_web_site_network_trace::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod stop_web_site_network_trace {
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 generate_new_site_publishing_password(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<generate_new_site_publishing_password::Response, generate_new_site_publishing_password::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/newpassword",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(generate_new_site_publishing_password::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_new_site_publishing_password::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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_new_site_publishing_password::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(generate_new_site_publishing_password::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(generate_new_site_publishing_password::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(generate_new_site_publishing_password::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(generate_new_site_publishing_password::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod generate_new_site_publishing_password {
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_perf_mon_counters(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::PerfMonCounterCollection, list_perf_mon_counters::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/perfcounters",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_perf_mon_counters::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_perf_mon_counters::Error::GetTokenError)?;
req_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_perf_mon_counters::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_perf_mon_counters::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PerfMonCounterCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_perf_mon_counters::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_perf_mon_counters::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_perf_mon_counters {
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 get_site_php_error_log_flag(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SitePhpErrorLogFlag, get_site_php_error_log_flag::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/phplogging",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_site_php_error_log_flag::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_site_php_error_log_flag::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_php_error_log_flag::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_site_php_error_log_flag::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SitePhpErrorLogFlag = serde_json::from_slice(rsp_body)
.map_err(|source| get_site_php_error_log_flag::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_site_php_error_log_flag::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_site_php_error_log_flag {
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_premier_add_ons(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::PremierAddOn, list_premier_add_ons::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_premier_add_ons::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_premier_add_ons::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_premier_add_ons::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_premier_add_ons::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PremierAddOn = serde_json::from_slice(rsp_body)
.map_err(|source| list_premier_add_ons::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_premier_add_ons::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_premier_add_ons {
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 get_premier_add_on(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
premier_add_on_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PremierAddOn, get_premier_add_on::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
premier_add_on_name
);
let mut url = url::Url::parse(url_str).map_err(get_premier_add_on::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_premier_add_on::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_premier_add_on::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_premier_add_on::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PremierAddOn = serde_json::from_slice(rsp_body)
.map_err(|source| get_premier_add_on::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_premier_add_on::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_premier_add_on {
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 add_premier_add_on(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
premier_add_on_name: &str,
premier_add_on: &models::PremierAddOn,
subscription_id: &str,
) -> std::result::Result<models::PremierAddOn, add_premier_add_on::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
premier_add_on_name
);
let mut url = url::Url::parse(url_str).map_err(add_premier_add_on::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(add_premier_add_on::Error::GetTokenError)?;
req_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(premier_add_on).map_err(add_premier_add_on::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(add_premier_add_on::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(add_premier_add_on::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PremierAddOn = serde_json::from_slice(rsp_body)
.map_err(|source| add_premier_add_on::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(add_premier_add_on::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod add_premier_add_on {
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_premier_add_on(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
premier_add_on_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_premier_add_on::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
premier_add_on_name
);
let mut url = url::Url::parse(url_str).map_err(delete_premier_add_on::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_premier_add_on::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_premier_add_on::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_premier_add_on::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(delete_premier_add_on::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_premier_add_on {
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_processes(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfoCollection, list_processes::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_processes::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_processes::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_processes::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_processes::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfoCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_processes::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_processes::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_processes::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_processes {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfo, get_process::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_process::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfo =
serde_json::from_slice(rsp_body).map_err(|source| get_process::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_process(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_process::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id
);
let mut url = url::Url::parse(url_str).map_err(delete_process::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_process::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_process::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_process::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_process::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_process {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_dump(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
subscription_id: &str,
) -> std::result::Result<bytes::Bytes, get_process_dump::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/dump",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_process_dump::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_dump::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_dump::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_dump::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_dump::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_dump::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_dump {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_process_modules(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfoCollection, list_process_modules::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/modules",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_process_modules::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_modules::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_modules::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_process_modules::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_process_modules::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_process_modules::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_process_modules::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_process_modules {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_module(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
base_address: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfo, get_process_module::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/modules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id,
base_address
);
let mut url = url::Url::parse(url_str).map_err(get_process_module::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_module::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_module::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_module::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_process_module::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_module::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_module::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_module {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_process_threads(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfoCollection, list_process_threads::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/threads",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_process_threads::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_threads::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_threads::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_process_threads::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_process_threads::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_process_threads::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_process_threads::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_process_threads {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_thread(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
thread_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfo, get_process_thread::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/threads/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
process_id,
thread_id
);
let mut url = url::Url::parse(url_str).map_err(get_process_thread::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_thread::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_thread::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_thread::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_process_thread::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_thread::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_thread::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_thread {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_public_certificates(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::PublicCertificateCollection, list_public_certificates::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_public_certificates::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_public_certificates::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_public_certificates::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_public_certificates::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PublicCertificateCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_public_certificates::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_public_certificates::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_public_certificates {
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 get_public_certificate(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
public_certificate_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PublicCertificate, get_public_certificate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
public_certificate_name
);
let mut url = url::Url::parse(url_str).map_err(get_public_certificate::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_public_certificate::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_public_certificate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_public_certificate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PublicCertificate = serde_json::from_slice(rsp_body)
.map_err(|source| get_public_certificate::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_public_certificate::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_public_certificate {
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_public_certificate(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
public_certificate_name: &str,
public_certificate: &models::PublicCertificate,
subscription_id: &str,
) -> std::result::Result<models::PublicCertificate, create_or_update_public_certificate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
public_certificate_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_public_certificate::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_public_certificate::Error::GetTokenError)?;
req_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(public_certificate).map_err(create_or_update_public_certificate::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_public_certificate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_public_certificate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PublicCertificate = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_public_certificate::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_public_certificate::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_public_certificate {
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_public_certificate(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
public_certificate_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_public_certificate::Response, delete_public_certificate::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
public_certificate_name
);
let mut url = url::Url::parse(url_str).map_err(delete_public_certificate::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_public_certificate::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_public_certificate::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_public_certificate::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_public_certificate::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_public_certificate::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_public_certificate::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_public_certificate {
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_publishing_profile_xml_with_secrets(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
publishing_profile_options: &models::CsmPublishingProfileOptions,
subscription_id: &str,
) -> std::result::Result<bytes::Bytes, list_publishing_profile_xml_with_secrets::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publishxml",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_publishing_profile_xml_with_secrets::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_publishing_profile_xml_with_secrets::Error::GetTokenError)?;
req_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(publishing_profile_options).map_err(list_publishing_profile_xml_with_secrets::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_publishing_profile_xml_with_secrets::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_publishing_profile_xml_with_secrets::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_publishing_profile_xml_with_secrets::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_publishing_profile_xml_with_secrets {
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 recover(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
recovery_entity: &models::SnapshotRecoveryRequest,
subscription_id: &str,
) -> std::result::Result<recover::Response, recover::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recover",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(recover::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(recover::Error::GetTokenError)?;
req_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(recovery_entity).map_err(recover::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(recover::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(recover::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::ACCEPTED => Ok(recover::Response::Accepted202),
http::StatusCode::OK => Ok(recover::Response::Ok200),
status_code => {
let rsp_body = rsp.body();
Err(recover::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod recover {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Accepted202,
Ok200,
}
#[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 reset_production_slot_config(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<(), reset_production_slot_config::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/resetSlotConfig",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(reset_production_slot_config::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(reset_production_slot_config::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(reset_production_slot_config::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(reset_production_slot_config::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(reset_production_slot_config::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod reset_production_slot_config {
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 restart(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
soft_restart: Option<bool>,
synchronous: Option<bool>,
subscription_id: &str,
) -> std::result::Result<(), restart::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/restart",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(restart::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(restart::Error::GetTokenError)?;
req_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(soft_restart) = soft_restart {
url.query_pairs_mut().append_pair("softRestart", soft_restart.to_string().as_str());
}
if let Some(synchronous) = synchronous {
url.query_pairs_mut().append_pair("synchronous", synchronous.to_string().as_str());
}
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(restart::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(restart::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(restart::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod restart {
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_site_extensions(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteExtensionInfoCollection, list_site_extensions::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_site_extensions::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_site_extensions::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_extensions::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_site_extensions::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_site_extensions::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_site_extensions::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_site_extensions::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_site_extensions {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_site_extension(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_extension_id: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteExtensionInfo, get_site_extension::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
site_extension_id
);
let mut url = url::Url::parse(url_str).map_err(get_site_extension::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_site_extension::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_extension::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_site_extension::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_site_extension::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_site_extension::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_site_extension::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_site_extension {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 install_site_extension(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_extension_id: &str,
subscription_id: &str,
) -> std::result::Result<install_site_extension::Response, install_site_extension::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
site_extension_id
);
let mut url = url::Url::parse(url_str).map_err(install_site_extension::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(install_site_extension::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(install_site_extension::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(install_site_extension::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfo = serde_json::from_slice(rsp_body)
.map_err(|source| install_site_extension::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(install_site_extension::Response::Created201(rsp_value))
}
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfo = serde_json::from_slice(rsp_body)
.map_err(|source| install_site_extension::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(install_site_extension::Response::Ok200(rsp_value))
}
http::StatusCode::TOO_MANY_REQUESTS => Err(install_site_extension::Error::TooManyRequests429 {}),
status_code => {
let rsp_body = rsp.body();
Err(install_site_extension::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod install_site_extension {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Created201(models::SiteExtensionInfo),
Ok200(models::SiteExtensionInfo),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
TooManyRequests429 {},
#[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_site_extension(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_extension_id: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_site_extension::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
site_extension_id
);
let mut url = url::Url::parse(url_str).map_err(delete_site_extension::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_site_extension::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_extension::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_site_extension::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_site_extension::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_site_extension::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_site_extension {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_slots(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::WebAppCollection, list_slots::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_slots::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_slots::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_slots::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_slots::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebAppCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_slots::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_slots::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_slots {
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 get_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::Site, get_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Site =
serde_json::from_slice(rsp_body).map_err(|source| get_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_envelope: &models::Site,
slot: &str,
skip_dns_registration: Option<bool>,
skip_custom_domain_verification: Option<bool>,
force_dns_registration: Option<bool>,
ttl_in_seconds: Option<&str>,
subscription_id: &str,
) -> std::result::Result<create_or_update_slot::Response, create_or_update_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_slot::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_slot::Error::GetTokenError)?;
req_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(site_envelope).map_err(create_or_update_slot::Error::SerializeError)?;
if let Some(skip_dns_registration) = skip_dns_registration {
url.query_pairs_mut()
.append_pair("skipDnsRegistration", skip_dns_registration.to_string().as_str());
}
if let Some(skip_custom_domain_verification) = skip_custom_domain_verification {
url.query_pairs_mut()
.append_pair("skipCustomDomainVerification", skip_custom_domain_verification.to_string().as_str());
}
if let Some(force_dns_registration) = force_dns_registration {
url.query_pairs_mut()
.append_pair("forceDnsRegistration", force_dns_registration.to_string().as_str());
}
if let Some(ttl_in_seconds) = ttl_in_seconds {
url.query_pairs_mut().append_pair("ttlInSeconds", ttl_in_seconds);
}
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Site = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_slot::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::Site = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_slot::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Site),
Accepted202(models::Site),
}
#[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 update_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_envelope: &models::SitePatchResource,
slot: &str,
skip_dns_registration: Option<bool>,
skip_custom_domain_verification: Option<bool>,
force_dns_registration: Option<bool>,
ttl_in_seconds: Option<&str>,
subscription_id: &str,
) -> std::result::Result<update_slot::Response, update_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_slot::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_slot::Error::GetTokenError)?;
req_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(site_envelope).map_err(update_slot::Error::SerializeError)?;
if let Some(skip_dns_registration) = skip_dns_registration {
url.query_pairs_mut()
.append_pair("skipDnsRegistration", skip_dns_registration.to_string().as_str());
}
if let Some(skip_custom_domain_verification) = skip_custom_domain_verification {
url.query_pairs_mut()
.append_pair("skipCustomDomainVerification", skip_custom_domain_verification.to_string().as_str());
}
if let Some(force_dns_registration) = force_dns_registration {
url.query_pairs_mut()
.append_pair("forceDnsRegistration", force_dns_registration.to_string().as_str());
}
if let Some(ttl_in_seconds) = ttl_in_seconds {
url.query_pairs_mut().append_pair("ttlInSeconds", ttl_in_seconds);
}
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Site =
serde_json::from_slice(rsp_body).map_err(|source| update_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_slot::Response::Ok200(rsp_value))
}
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::Site =
serde_json::from_slice(rsp_body).map_err(|source| update_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_slot::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(update_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::Site),
Accepted202(models::Site),
}
#[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_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
delete_metrics: Option<bool>,
delete_empty_server_farm: Option<bool>,
skip_dns_registration: Option<bool>,
subscription_id: &str,
) -> std::result::Result<delete_slot::Response, delete_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(delete_slot::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_slot::Error::GetTokenError)?;
req_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(delete_metrics) = delete_metrics {
url.query_pairs_mut()
.append_pair("deleteMetrics", delete_metrics.to_string().as_str());
}
if let Some(delete_empty_server_farm) = delete_empty_server_farm {
url.query_pairs_mut()
.append_pair("deleteEmptyServerFarm", delete_empty_server_farm.to_string().as_str());
}
if let Some(skip_dns_registration) = skip_dns_registration {
url.query_pairs_mut()
.append_pair("skipDnsRegistration", skip_dns_registration.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(delete_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_slot::Response::NoContent204),
http::StatusCode::NOT_FOUND => Err(delete_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
NoContent204,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 analyze_custom_hostname_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
host_name: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::CustomHostnameAnalysisResult, analyze_custom_hostname_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/analyzeCustomHostname",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(analyze_custom_hostname_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(analyze_custom_hostname_slot::Error::GetTokenError)?;
req_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(host_name) = host_name {
url.query_pairs_mut().append_pair("hostName", host_name);
}
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(analyze_custom_hostname_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(analyze_custom_hostname_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CustomHostnameAnalysisResult = serde_json::from_slice(rsp_body)
.map_err(|source| analyze_custom_hostname_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(analyze_custom_hostname_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod analyze_custom_hostname_slot {
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 apply_slot_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_swap_entity: &models::CsmSlotEntity,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), apply_slot_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/applySlotConfig",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(apply_slot_configuration_slot::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(apply_slot_configuration_slot::Error::GetTokenError)?;
req_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(slot_swap_entity).map_err(apply_slot_configuration_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(apply_slot_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(apply_slot_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(apply_slot_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod apply_slot_configuration_slot {
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 backup_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
request: &models::BackupRequest,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupItem, backup_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backup",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(backup_slot::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(backup_slot::Error::GetTokenError)?;
req_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(request).map_err(backup_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(backup_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(backup_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItem =
serde_json::from_slice(rsp_body).map_err(|source| backup_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(backup_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod backup_slot {
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_backups_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupItemCollection, list_backups_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_backups_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_backups_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backups_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_backups_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItemCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_backups_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_backups_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_backups_slot {
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 discover_restore_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
request: &models::RestoreRequest,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::RestoreRequest, discover_restore_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/discover",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(discover_restore_slot::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(discover_restore_slot::Error::GetTokenError)?;
req_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(request).map_err(discover_restore_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(discover_restore_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(discover_restore_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestoreRequest = serde_json::from_slice(rsp_body)
.map_err(|source| discover_restore_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(discover_restore_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod discover_restore_slot {
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 get_backup_status_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupItem, get_backup_status_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(get_backup_status_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_backup_status_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backup_status_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_backup_status_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItem = serde_json::from_slice(rsp_body)
.map_err(|source| get_backup_status_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_backup_status_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_backup_status_slot {
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_backup_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_backup_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(delete_backup_slot::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_backup_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backup_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_backup_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_backup_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_backup_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_backup_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_backup_status_secrets_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
request: &models::BackupRequest,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupItem, list_backup_status_secrets_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(list_backup_status_secrets_slot::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_backup_status_secrets_slot::Error::GetTokenError)?;
req_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(request).map_err(list_backup_status_secrets_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_backup_status_secrets_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_backup_status_secrets_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupItem = serde_json::from_slice(rsp_body)
.map_err(|source| list_backup_status_secrets_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_backup_status_secrets_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_backup_status_secrets_slot {
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 restore_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
backup_id: &str,
request: &models::RestoreRequest,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::RestoreResponse, restore_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}/restore",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
backup_id
);
let mut url = url::Url::parse(url_str).map_err(restore_slot::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(restore_slot::Error::GetTokenError)?;
req_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(request).map_err(restore_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(restore_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(restore_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RestoreResponse =
serde_json::from_slice(rsp_body).map_err(|source| restore_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(restore_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod restore_slot {
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_configurations_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResourceCollection, list_configurations_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_configurations_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configurations_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configurations_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_configurations_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResourceCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_configurations_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_configurations_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_configurations_slot {
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 update_application_settings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
app_settings: &models::StringDictionary,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, update_application_settings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/appsettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_application_settings_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_application_settings_slot::Error::GetTokenError)?;
req_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(app_settings).map_err(update_application_settings_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_application_settings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_application_settings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| update_application_settings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_application_settings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_application_settings_slot {
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_application_settings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, list_application_settings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/appsettings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_application_settings_slot::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_application_settings_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_application_settings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_application_settings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| list_application_settings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_application_settings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_application_settings_slot {
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 update_auth_settings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_auth_settings: &models::SiteAuthSettings,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteAuthSettings, update_auth_settings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_auth_settings_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_auth_settings_slot::Error::GetTokenError)?;
req_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(site_auth_settings).map_err(update_auth_settings_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_auth_settings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_auth_settings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteAuthSettings = serde_json::from_slice(rsp_body)
.map_err(|source| update_auth_settings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_auth_settings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_auth_settings_slot {
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 get_auth_settings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteAuthSettings, get_auth_settings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_auth_settings_slot::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(get_auth_settings_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(get_auth_settings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_auth_settings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteAuthSettings = serde_json::from_slice(rsp_body)
.map_err(|source| get_auth_settings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_auth_settings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_auth_settings_slot {
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 update_backup_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
request: &models::BackupRequest,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupRequest, update_backup_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/backup",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_backup_configuration_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_backup_configuration_slot::Error::GetTokenError)?;
req_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(request).map_err(update_backup_configuration_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_backup_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_backup_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupRequest = serde_json::from_slice(rsp_body)
.map_err(|source| update_backup_configuration_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_backup_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_backup_configuration_slot {
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_backup_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_backup_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/backup",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(delete_backup_configuration_slot::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_backup_configuration_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_backup_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_backup_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(delete_backup_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_backup_configuration_slot {
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 get_backup_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::BackupRequest, get_backup_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/backup/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_backup_configuration_slot::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(get_backup_configuration_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(get_backup_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_backup_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::BackupRequest = serde_json::from_slice(rsp_body)
.map_err(|source| get_backup_configuration_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_backup_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_backup_configuration_slot {
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 update_connection_strings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
connection_strings: &models::ConnectionStringDictionary,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ConnectionStringDictionary, update_connection_strings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/connectionstrings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_connection_strings_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_connection_strings_slot::Error::GetTokenError)?;
req_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(connection_strings).map_err(update_connection_strings_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_connection_strings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_connection_strings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectionStringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| update_connection_strings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_connection_strings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_connection_strings_slot {
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_connection_strings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ConnectionStringDictionary, list_connection_strings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/connectionstrings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_connection_strings_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::POST);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(list_connection_strings_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_connection_strings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_connection_strings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ConnectionStringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| list_connection_strings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_connection_strings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_connection_strings_slot {
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 get_diagnostic_logs_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteLogsConfig, get_diagnostic_logs_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/logs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_diagnostic_logs_configuration_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_diagnostic_logs_configuration_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_diagnostic_logs_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_diagnostic_logs_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteLogsConfig = serde_json::from_slice(rsp_body)
.map_err(|source| get_diagnostic_logs_configuration_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_diagnostic_logs_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_diagnostic_logs_configuration_slot {
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 update_diagnostic_logs_config_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_logs_config: &models::SiteLogsConfig,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteLogsConfig, update_diagnostic_logs_config_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/logs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_diagnostic_logs_config_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_diagnostic_logs_config_slot::Error::GetTokenError)?;
req_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(site_logs_config).map_err(update_diagnostic_logs_config_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_diagnostic_logs_config_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_diagnostic_logs_config_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteLogsConfig = serde_json::from_slice(rsp_body)
.map_err(|source| update_diagnostic_logs_config_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_diagnostic_logs_config_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_diagnostic_logs_config_slot {
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 update_metadata_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
metadata: &models::StringDictionary,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, update_metadata_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/metadata",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_metadata_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_metadata_slot::Error::GetTokenError)?;
req_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(metadata).map_err(update_metadata_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(update_metadata_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_metadata_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| update_metadata_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_metadata_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_metadata_slot {
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_metadata_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::StringDictionary, list_metadata_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/metadata/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_metadata_slot::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_metadata_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(list_metadata_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metadata_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::StringDictionary = serde_json::from_slice(rsp_body)
.map_err(|source| list_metadata_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metadata_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metadata_slot {
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_publishing_credentials_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::User, list_publishing_credentials_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/publishingcredentials/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_publishing_credentials_slot::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_publishing_credentials_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_publishing_credentials_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_publishing_credentials_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::User = serde_json::from_slice(rsp_body)
.map_err(|source| list_publishing_credentials_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_publishing_credentials_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_publishing_credentials_slot {
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 update_site_push_settings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
push_settings: &models::PushSettings,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PushSettings, update_site_push_settings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/pushsettings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_site_push_settings_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::PUT);
if let Some(token_credential) = operation_config.token_credential() {
let token_response = token_credential
.get_token(operation_config.token_credential_resource())
.await
.map_err(update_site_push_settings_slot::Error::GetTokenError)?;
req_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(push_settings).map_err(update_site_push_settings_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_site_push_settings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_site_push_settings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PushSettings = serde_json::from_slice(rsp_body)
.map_err(|source| update_site_push_settings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_site_push_settings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_site_push_settings_slot {
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_site_push_settings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PushSettings, list_site_push_settings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/pushsettings/list",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_site_push_settings_slot::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_site_push_settings_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_site_push_settings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_site_push_settings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PushSettings = serde_json::from_slice(rsp_body)
.map_err(|source| list_site_push_settings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_site_push_settings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_site_push_settings_slot {
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 get_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, get_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_configuration_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configuration_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| get_configuration_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_configuration_slot {
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_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_config: &models::SiteConfigResource,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, create_or_update_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_configuration_slot::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_configuration_slot::Error::GetTokenError)?;
req_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(site_config).map_err(create_or_update_configuration_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_configuration_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_configuration_slot {
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 update_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_config: &models::SiteConfigResource,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, update_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_configuration_slot::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_configuration_slot::Error::GetTokenError)?;
req_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(site_config).map_err(update_configuration_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| update_configuration_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_configuration_slot {
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_configuration_snapshot_info_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigurationSnapshotInfoCollection, list_configuration_snapshot_info_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web/snapshots",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_configuration_snapshot_info_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configuration_snapshot_info_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configuration_snapshot_info_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_configuration_snapshot_info_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigurationSnapshotInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_configuration_snapshot_info_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_configuration_snapshot_info_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_configuration_snapshot_info_slot {
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 get_configuration_snapshot_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
snapshot_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteConfigResource, get_configuration_snapshot_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web/snapshots/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
snapshot_id
);
let mut url = url::Url::parse(url_str).map_err(get_configuration_snapshot_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_configuration_snapshot_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_configuration_snapshot_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_configuration_snapshot_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteConfigResource = serde_json::from_slice(rsp_body)
.map_err(|source| get_configuration_snapshot_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_configuration_snapshot_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_configuration_snapshot_slot {
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 recover_site_configuration_snapshot_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
snapshot_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), recover_site_configuration_snapshot_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web/snapshots/{}/recover",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
snapshot_id
);
let mut url = url::Url::parse(url_str).map_err(recover_site_configuration_snapshot_slot::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(recover_site_configuration_snapshot_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(recover_site_configuration_snapshot_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(recover_site_configuration_snapshot_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(recover_site_configuration_snapshot_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod recover_site_configuration_snapshot_slot {
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 get_web_site_container_logs_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<get_web_site_container_logs_slot::Response, get_web_site_container_logs_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/containerlogs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_web_site_container_logs_slot::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(get_web_site_container_logs_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(get_web_site_container_logs_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_web_site_container_logs_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(get_web_site_container_logs_slot::Response::NoContent204),
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(get_web_site_container_logs_slot::Response::Ok200(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(get_web_site_container_logs_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_web_site_container_logs_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Ok200(bytes::Bytes),
}
#[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 get_web_site_container_logs_zip_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<get_web_site_container_logs_zip_slot::Response, get_web_site_container_logs_zip_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/containerlogs/zip/download",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_web_site_container_logs_zip_slot::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(get_web_site_container_logs_zip_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(get_web_site_container_logs_zip_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_web_site_container_logs_zip_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(get_web_site_container_logs_zip_slot::Response::NoContent204),
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(get_web_site_container_logs_zip_slot::Response::Ok200(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(get_web_site_container_logs_zip_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_web_site_container_logs_zip_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
NoContent204,
Ok200(bytes::Bytes),
}
#[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_continuous_web_jobs_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ContinuousWebJobCollection, list_continuous_web_jobs_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_continuous_web_jobs_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_continuous_web_jobs_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_continuous_web_jobs_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_continuous_web_jobs_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ContinuousWebJobCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_continuous_web_jobs_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_continuous_web_jobs_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_continuous_web_jobs_slot {
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 get_continuous_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ContinuousWebJob, get_continuous_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(get_continuous_web_job_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_continuous_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_continuous_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_continuous_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ContinuousWebJob = serde_json::from_slice(rsp_body)
.map_err(|source| get_continuous_web_job_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_continuous_web_job_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_continuous_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_continuous_web_job_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_continuous_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<delete_continuous_web_job_slot::Response, delete_continuous_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(delete_continuous_web_job_slot::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_continuous_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_continuous_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_continuous_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_continuous_web_job_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_continuous_web_job_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_continuous_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_continuous_web_job_slot {
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 start_continuous_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), start_continuous_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(start_continuous_web_job_slot::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(start_continuous_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(start_continuous_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(start_continuous_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(start_continuous_web_job_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(start_continuous_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod start_continuous_web_job_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 stop_continuous_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), stop_continuous_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}/stop",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(stop_continuous_web_job_slot::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(stop_continuous_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(stop_continuous_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(stop_continuous_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(stop_continuous_web_job_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(stop_continuous_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod stop_continuous_web_job_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_deployments_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::DeploymentCollection, list_deployments_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_deployments_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_deployments_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployments_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_deployments_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::DeploymentCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_deployments_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_deployments_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_deployments_slot {
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 get_deployment_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::Deployment, get_deployment_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
id
);
let mut url = url::Url::parse(url_str).map_err(get_deployment_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_deployment_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployment_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_deployment_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Deployment = serde_json::from_slice(rsp_body)
.map_err(|source| get_deployment_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_deployment_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_deployment_slot {
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_deployment_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
slot: &str,
deployment: &models::Deployment,
subscription_id: &str,
) -> std::result::Result<models::Deployment, create_deployment_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
id
);
let mut url = url::Url::parse(url_str).map_err(create_deployment_slot::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_deployment_slot::Error::GetTokenError)?;
req_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(deployment).map_err(create_deployment_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_deployment_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_deployment_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Deployment = serde_json::from_slice(rsp_body)
.map_err(|source| create_deployment_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_deployment_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_deployment_slot {
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_deployment_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<delete_deployment_slot::Response, delete_deployment_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
id
);
let mut url = url::Url::parse(url_str).map_err(delete_deployment_slot::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_deployment_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployment_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_deployment_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_deployment_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_deployment_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_deployment_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_deployment_slot {
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_deployment_log_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::Deployment, list_deployment_log_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}/log",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
id
);
let mut url = url::Url::parse(url_str).map_err(list_deployment_log_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_deployment_log_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_deployment_log_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_deployment_log_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Deployment = serde_json::from_slice(rsp_body)
.map_err(|source| list_deployment_log_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_deployment_log_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_deployment_log_slot {
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_domain_ownership_identifiers_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::IdentifierCollection, list_domain_ownership_identifiers_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_domain_ownership_identifiers_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_domain_ownership_identifiers_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_domain_ownership_identifiers_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_domain_ownership_identifiers_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::IdentifierCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_domain_ownership_identifiers_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_domain_ownership_identifiers_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_domain_ownership_identifiers_slot {
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 get_domain_ownership_identifier_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::Identifier, get_domain_ownership_identifier_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(get_domain_ownership_identifier_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_domain_ownership_identifier_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_domain_ownership_identifier_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_domain_ownership_identifier_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Identifier = serde_json::from_slice(rsp_body)
.map_err(|source| get_domain_ownership_identifier_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_domain_ownership_identifier_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_domain_ownership_identifier_slot {
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_domain_ownership_identifier_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
domain_ownership_identifier: &models::Identifier,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::Identifier, create_or_update_domain_ownership_identifier_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_domain_ownership_identifier_slot::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_domain_ownership_identifier_slot::Error::GetTokenError)?;
req_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(domain_ownership_identifier)
.map_err(create_or_update_domain_ownership_identifier_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_domain_ownership_identifier_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_domain_ownership_identifier_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Identifier = serde_json::from_slice(rsp_body).map_err(|source| {
create_or_update_domain_ownership_identifier_slot::Error::DeserializeError(source, rsp_body.clone())
})?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_domain_ownership_identifier_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_domain_ownership_identifier_slot {
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 update_domain_ownership_identifier_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
domain_ownership_identifier: &models::Identifier,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::Identifier, update_domain_ownership_identifier_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(update_domain_ownership_identifier_slot::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_domain_ownership_identifier_slot::Error::GetTokenError)?;
req_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(domain_ownership_identifier).map_err(update_domain_ownership_identifier_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_domain_ownership_identifier_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_domain_ownership_identifier_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::Identifier = serde_json::from_slice(rsp_body)
.map_err(|source| update_domain_ownership_identifier_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_domain_ownership_identifier_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_domain_ownership_identifier_slot {
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_domain_ownership_identifier_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
domain_ownership_identifier_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<delete_domain_ownership_identifier_slot::Response, delete_domain_ownership_identifier_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
domain_ownership_identifier_name
);
let mut url = url::Url::parse(url_str).map_err(delete_domain_ownership_identifier_slot::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_domain_ownership_identifier_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_domain_ownership_identifier_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_domain_ownership_identifier_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_domain_ownership_identifier_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_domain_ownership_identifier_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_domain_ownership_identifier_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_domain_ownership_identifier_slot {
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 get_ms_deploy_status_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, get_ms_deploy_status_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_ms_deploy_status_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_ms_deploy_status_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_ms_deploy_status_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_ms_deploy_status_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| get_ms_deploy_status_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_ms_deploy_status_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_ms_deploy_status_slot {
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_ms_deploy_operation_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
ms_deploy: &models::MsDeploy,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, create_ms_deploy_operation_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(create_ms_deploy_operation_slot::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_ms_deploy_operation_slot::Error::GetTokenError)?;
req_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(ms_deploy).map_err(create_ms_deploy_operation_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_ms_deploy_operation_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_ms_deploy_operation_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| create_ms_deploy_operation_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::CONFLICT => Err(create_ms_deploy_operation_slot::Error::Conflict409 {}),
status_code => {
let rsp_body = rsp.body();
Err(create_ms_deploy_operation_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_ms_deploy_operation_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
Conflict409 {},
#[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 get_ms_deploy_log_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployLog, get_ms_deploy_log_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/extensions/MSDeploy/log",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_ms_deploy_log_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_ms_deploy_log_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_ms_deploy_log_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_ms_deploy_log_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployLog = serde_json::from_slice(rsp_body)
.map_err(|source| get_ms_deploy_log_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_ms_deploy_log_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_ms_deploy_log_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_ms_deploy_log_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_functions_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionEnvelopeCollection, list_instance_functions_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_instance_functions_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_functions_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_functions_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_functions_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionEnvelopeCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_functions_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_functions_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_functions_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_functions_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_functions_admin_token_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<String, get_functions_admin_token_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/admin/token",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_functions_admin_token_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_functions_admin_token_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_functions_admin_token_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_functions_admin_token_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: String = serde_json::from_slice(rsp_body)
.map_err(|source| get_functions_admin_token_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_functions_admin_token_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_functions_admin_token_slot {
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 get_instance_function_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionEnvelope, get_instance_function_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
function_name
);
let mut url = url::Url::parse(url_str).map_err(get_instance_function_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_function_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_function_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_function_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionEnvelope = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_function_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_function_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_function_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_function_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_function_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
slot: &str,
function_envelope: &models::FunctionEnvelope,
subscription_id: &str,
) -> std::result::Result<models::FunctionEnvelope, create_instance_function_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
function_name
);
let mut url = url::Url::parse(url_str).map_err(create_instance_function_slot::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_instance_function_slot::Error::GetTokenError)?;
req_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(function_envelope).map_err(create_instance_function_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_instance_function_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_instance_function_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionEnvelope = serde_json::from_slice(rsp_body)
.map_err(|source| create_instance_function_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_instance_function_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_instance_function_slot {
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_instance_function_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_instance_function_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
function_name
);
let mut url = url::Url::parse(url_str).map_err(delete_instance_function_slot::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_instance_function_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_function_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_instance_function_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_instance_function_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_instance_function_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_instance_function_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_function_secrets_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
function_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionSecrets, list_function_secrets_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}/listsecrets",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
function_name
);
let mut url = url::Url::parse(url_str).map_err(list_function_secrets_slot::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_function_secrets_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_function_secrets_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_function_secrets_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionSecrets = serde_json::from_slice(rsp_body)
.map_err(|source| list_function_secrets_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_function_secrets_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_function_secrets_slot {
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_host_name_bindings_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HostNameBindingCollection, list_host_name_bindings_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_host_name_bindings_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_host_name_bindings_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_host_name_bindings_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_host_name_bindings_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HostNameBindingCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_host_name_bindings_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_host_name_bindings_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_host_name_bindings_slot {
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 get_host_name_binding_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
host_name: &str,
subscription_id: &str,
) -> std::result::Result<models::HostNameBinding, get_host_name_binding_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
host_name
);
let mut url = url::Url::parse(url_str).map_err(get_host_name_binding_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_host_name_binding_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_host_name_binding_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_host_name_binding_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HostNameBinding = serde_json::from_slice(rsp_body)
.map_err(|source| get_host_name_binding_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_host_name_binding_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_host_name_binding_slot {
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_host_name_binding_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
host_name: &str,
host_name_binding: &models::HostNameBinding,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HostNameBinding, create_or_update_host_name_binding_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
host_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_host_name_binding_slot::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_host_name_binding_slot::Error::GetTokenError)?;
req_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(host_name_binding).map_err(create_or_update_host_name_binding_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_host_name_binding_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_host_name_binding_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HostNameBinding = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_host_name_binding_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_host_name_binding_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_host_name_binding_slot {
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_host_name_binding_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
host_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_host_name_binding_slot::Response, delete_host_name_binding_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
host_name
);
let mut url = url::Url::parse(url_str).map_err(delete_host_name_binding_slot::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_host_name_binding_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_host_name_binding_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_host_name_binding_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_host_name_binding_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_host_name_binding_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_host_name_binding_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_host_name_binding_slot {
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 get_hybrid_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, get_hybrid_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(get_hybrid_connection_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_hybrid_connection_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_hybrid_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_hybrid_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| get_hybrid_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_hybrid_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_hybrid_connection_slot {
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_hybrid_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
connection_envelope: &models::HybridConnection,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, create_or_update_hybrid_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_hybrid_connection_slot::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_hybrid_connection_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_hybrid_connection_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_hybrid_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_hybrid_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_hybrid_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_hybrid_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_hybrid_connection_slot {
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 update_hybrid_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
connection_envelope: &models::HybridConnection,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, update_hybrid_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(update_hybrid_connection_slot::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_hybrid_connection_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_hybrid_connection_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_hybrid_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_hybrid_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| update_hybrid_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_hybrid_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_hybrid_connection_slot {
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_hybrid_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_hybrid_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
namespace_name,
relay_name
);
let mut url = url::Url::parse(url_str).map_err(delete_hybrid_connection_slot::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_hybrid_connection_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_hybrid_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_hybrid_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_hybrid_connection_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_hybrid_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_hybrid_connection_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_hybrid_connection_keys_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
namespace_name: &str,
relay_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnectionKey, list_hybrid_connection_keys_slot::Error> {
let http_client = operation_config.http_client();
let url_str = & format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}/listKeys" , operation_config . base_path () , subscription_id , resource_group_name , name , slot , namespace_name , relay_name) ;
let mut url = url::Url::parse(url_str).map_err(list_hybrid_connection_keys_slot::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_hybrid_connection_keys_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_hybrid_connection_keys_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_hybrid_connection_keys_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnectionKey = serde_json::from_slice(rsp_body)
.map_err(|source| list_hybrid_connection_keys_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_hybrid_connection_keys_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_hybrid_connection_keys_slot {
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_hybrid_connections_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::HybridConnection, list_hybrid_connections_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionRelays",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_hybrid_connections_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_hybrid_connections_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_hybrid_connections_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_hybrid_connections_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::HybridConnection = serde_json::from_slice(rsp_body)
.map_err(|source| list_hybrid_connections_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_hybrid_connections_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_hybrid_connections_slot {
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_relay_service_connections_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, list_relay_service_connections_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_relay_service_connections_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_relay_service_connections_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_relay_service_connections_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_relay_service_connections_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| list_relay_service_connections_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_relay_service_connections_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_relay_service_connections_slot {
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 get_relay_service_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, get_relay_service_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(get_relay_service_connection_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_relay_service_connection_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_relay_service_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_relay_service_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| get_relay_service_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_relay_service_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_relay_service_connection_slot {
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_relay_service_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
connection_envelope: &models::RelayServiceConnectionEntity,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, create_or_update_relay_service_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_relay_service_connection_slot::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_relay_service_connection_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_relay_service_connection_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_relay_service_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_relay_service_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_relay_service_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_relay_service_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_relay_service_connection_slot {
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 update_relay_service_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
connection_envelope: &models::RelayServiceConnectionEntity,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::RelayServiceConnectionEntity, update_relay_service_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(update_relay_service_connection_slot::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_relay_service_connection_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_relay_service_connection_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_relay_service_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_relay_service_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::RelayServiceConnectionEntity = serde_json::from_slice(rsp_body)
.map_err(|source| update_relay_service_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_relay_service_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_relay_service_connection_slot {
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_relay_service_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
entity_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_relay_service_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
entity_name
);
let mut url = url::Url::parse(url_str).map_err(delete_relay_service_connection_slot::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_relay_service_connection_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_relay_service_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_relay_service_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_relay_service_connection_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_relay_service_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_relay_service_connection_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_identifiers_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::WebAppInstanceCollection, list_instance_identifiers_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_instance_identifiers_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_identifiers_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_identifiers_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_identifiers_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebAppInstanceCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_identifiers_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_instance_identifiers_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_identifiers_slot {
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 get_instance_ms_deploy_status_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, get_instance_ms_deploy_status_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_ms_deploy_status_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_ms_deploy_status_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_ms_deploy_status_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_ms_deploy_status_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_ms_deploy_status_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_instance_ms_deploy_status_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_ms_deploy_status_slot {
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_instance_ms_deploy_operation_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
instance_id: &str,
ms_deploy: &models::MsDeploy,
subscription_id: &str,
) -> std::result::Result<models::MsDeployStatus, create_instance_ms_deploy_operation_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/extensions/MSDeploy",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(create_instance_ms_deploy_operation_slot::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_instance_ms_deploy_operation_slot::Error::GetTokenError)?;
req_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(ms_deploy).map_err(create_instance_ms_deploy_operation_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_instance_ms_deploy_operation_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_instance_ms_deploy_operation_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployStatus = serde_json::from_slice(rsp_body)
.map_err(|source| create_instance_ms_deploy_operation_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::CONFLICT => Err(create_instance_ms_deploy_operation_slot::Error::Conflict409 {}),
status_code => {
let rsp_body = rsp.body();
Err(create_instance_ms_deploy_operation_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_instance_ms_deploy_operation_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
Conflict409 {},
#[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 get_instance_ms_deploy_log_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::MsDeployLog, get_instance_ms_deploy_log_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/extensions/MSDeploy/log",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_ms_deploy_log_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_ms_deploy_log_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_ms_deploy_log_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_ms_deploy_log_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MsDeployLog = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_ms_deploy_log_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_ms_deploy_log_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_ms_deploy_log_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_ms_deploy_log_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_processes_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfoCollection, list_instance_processes_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id
);
let mut url = url::Url::parse(url_str).map_err(list_instance_processes_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_processes_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_processes_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_processes_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_processes_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_processes_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_processes_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_processes_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfo, get_instance_process_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_process_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_process_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_instance_process_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(delete_instance_process_slot::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_instance_process_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_instance_process_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_instance_process_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_instance_process_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_instance_process_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_dump_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<bytes::Bytes, get_instance_process_dump_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/dump",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_dump_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_dump_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_dump_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_dump_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_dump_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_dump_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_dump_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_process_modules_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfoCollection, list_instance_process_modules_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/modules",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_instance_process_modules_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_modules_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_modules_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_process_modules_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_process_modules_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_process_modules_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_process_modules_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_process_modules_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_module_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
base_address: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfo, get_instance_process_module_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/modules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id,
base_address
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_module_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_module_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_module_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_module_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_process_module_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_module_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_module_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_module_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_instance_process_threads_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfoCollection, list_instance_process_threads_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/threads",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_instance_process_threads_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_threads_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_threads_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_instance_process_threads_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_instance_process_threads_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_instance_process_threads_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_instance_process_threads_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_instance_process_threads_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_instance_process_thread_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
thread_id: &str,
slot: &str,
instance_id: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfo, get_instance_process_thread_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/threads/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
instance_id,
process_id,
thread_id
);
let mut url = url::Url::parse(url_str).map_err(get_instance_process_thread_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_instance_process_thread_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_instance_process_thread_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_instance_process_thread_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_instance_process_thread_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_instance_process_thread_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_instance_process_thread_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_instance_process_thread_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 is_cloneable_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteCloneability, is_cloneable_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/iscloneable",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(is_cloneable_slot::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(is_cloneable_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(is_cloneable_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(is_cloneable_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteCloneability = serde_json::from_slice(rsp_body)
.map_err(|source| is_cloneable_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(is_cloneable_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod is_cloneable_slot {
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_sync_function_triggers_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::FunctionSecrets, list_sync_function_triggers_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/listsyncfunctiontriggerstatus",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_sync_function_triggers_slot::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_sync_function_triggers_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_sync_function_triggers_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_sync_function_triggers_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::FunctionSecrets = serde_json::from_slice(rsp_body)
.map_err(|source| list_sync_function_triggers_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_sync_function_triggers_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_sync_function_triggers_slot {
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_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ResourceMetricDefinitionCollection, list_metric_definitions_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/metricdefinitions",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_metric_definitions_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metric_definitions_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ResourceMetricDefinitionCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_metric_definitions_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metric_definitions_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metric_definitions_slot {
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_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
details: Option<bool>,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::ResourceMetricCollection, list_metrics_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/metrics",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_metrics_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_slot::Error::GetTokenError)?;
req_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(details) = details {
url.query_pairs_mut().append_pair("details", details.to_string().as_str());
}
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_metrics_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_metrics_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ResourceMetricCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_metrics_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_metrics_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_metrics_slot {
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 get_migrate_my_sql_status_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::MigrateMySqlStatus, get_migrate_my_sql_status_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/migratemysql/status",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_migrate_my_sql_status_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_migrate_my_sql_status_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_migrate_my_sql_status_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_migrate_my_sql_status_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::MigrateMySqlStatus = serde_json::from_slice(rsp_body)
.map_err(|source| get_migrate_my_sql_status_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_migrate_my_sql_status_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_migrate_my_sql_status_slot {
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_network_features_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
view: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::NetworkFeatures, list_network_features_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkFeatures/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
view
);
let mut url = url::Url::parse(url_str).map_err(list_network_features_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_network_features_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_network_features_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_network_features_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::NetworkFeatures = serde_json::from_slice(rsp_body)
.map_err(|source| list_network_features_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_network_features_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_network_features_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_network_features_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 start_web_site_network_trace_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
duration_in_seconds: Option<i32>,
slot: &str,
max_frame_length: Option<i32>,
sas_url: Option<&str>,
subscription_id: &str,
) -> std::result::Result<String, start_web_site_network_trace_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(start_web_site_network_trace_slot::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(start_web_site_network_trace_slot::Error::GetTokenError)?;
req_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(duration_in_seconds) = duration_in_seconds {
url.query_pairs_mut()
.append_pair("durationInSeconds", duration_in_seconds.to_string().as_str());
}
if let Some(max_frame_length) = max_frame_length {
url.query_pairs_mut()
.append_pair("maxFrameLength", max_frame_length.to_string().as_str());
}
if let Some(sas_url) = sas_url {
url.query_pairs_mut().append_pair("sasUrl", sas_url);
}
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(start_web_site_network_trace_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(start_web_site_network_trace_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: String = serde_json::from_slice(rsp_body)
.map_err(|source| start_web_site_network_trace_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(start_web_site_network_trace_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod start_web_site_network_trace_slot {
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 stop_web_site_network_trace_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<String, stop_web_site_network_trace_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/stop",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(stop_web_site_network_trace_slot::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(stop_web_site_network_trace_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(stop_web_site_network_trace_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(stop_web_site_network_trace_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: String = serde_json::from_slice(rsp_body)
.map_err(|source| stop_web_site_network_trace_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(stop_web_site_network_trace_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod stop_web_site_network_trace_slot {
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 generate_new_site_publishing_password_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<generate_new_site_publishing_password_slot::Response, generate_new_site_publishing_password_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/newpassword",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(generate_new_site_publishing_password_slot::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_new_site_publishing_password_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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_new_site_publishing_password_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(generate_new_site_publishing_password_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(generate_new_site_publishing_password_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(generate_new_site_publishing_password_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(generate_new_site_publishing_password_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod generate_new_site_publishing_password_slot {
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_perf_mon_counters_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::PerfMonCounterCollection, list_perf_mon_counters_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/perfcounters",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_perf_mon_counters_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_perf_mon_counters_slot::Error::GetTokenError)?;
req_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_perf_mon_counters_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_perf_mon_counters_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PerfMonCounterCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_perf_mon_counters_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_perf_mon_counters_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_perf_mon_counters_slot {
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 get_site_php_error_log_flag_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SitePhpErrorLogFlag, get_site_php_error_log_flag_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/phplogging",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_site_php_error_log_flag_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_site_php_error_log_flag_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_php_error_log_flag_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_site_php_error_log_flag_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SitePhpErrorLogFlag = serde_json::from_slice(rsp_body)
.map_err(|source| get_site_php_error_log_flag_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_site_php_error_log_flag_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_site_php_error_log_flag_slot {
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_premier_add_ons_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PremierAddOn, list_premier_add_ons_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_premier_add_ons_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_premier_add_ons_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_premier_add_ons_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_premier_add_ons_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PremierAddOn = serde_json::from_slice(rsp_body)
.map_err(|source| list_premier_add_ons_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_premier_add_ons_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_premier_add_ons_slot {
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 get_premier_add_on_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
premier_add_on_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PremierAddOn, get_premier_add_on_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
premier_add_on_name
);
let mut url = url::Url::parse(url_str).map_err(get_premier_add_on_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_premier_add_on_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_premier_add_on_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_premier_add_on_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PremierAddOn = serde_json::from_slice(rsp_body)
.map_err(|source| get_premier_add_on_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_premier_add_on_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_premier_add_on_slot {
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 add_premier_add_on_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
premier_add_on_name: &str,
premier_add_on: &models::PremierAddOn,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PremierAddOn, add_premier_add_on_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
premier_add_on_name
);
let mut url = url::Url::parse(url_str).map_err(add_premier_add_on_slot::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(add_premier_add_on_slot::Error::GetTokenError)?;
req_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(premier_add_on).map_err(add_premier_add_on_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(add_premier_add_on_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(add_premier_add_on_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PremierAddOn = serde_json::from_slice(rsp_body)
.map_err(|source| add_premier_add_on_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(add_premier_add_on_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod add_premier_add_on_slot {
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_premier_add_on_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
premier_add_on_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_premier_add_on_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
premier_add_on_name
);
let mut url = url::Url::parse(url_str).map_err(delete_premier_add_on_slot::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_premier_add_on_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_premier_add_on_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_premier_add_on_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(delete_premier_add_on_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_premier_add_on_slot {
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_processes_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfoCollection, list_processes_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_processes_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_processes_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_processes_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_processes_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_processes_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_processes_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_processes_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_processes_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessInfo, get_process_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_process_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_process_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_process_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_process_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id
);
let mut url = url::Url::parse(url_str).map_err(delete_process_slot::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_process_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_process_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_process_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_process_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_process_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_dump_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<bytes::Bytes, get_process_dump_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/dump",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id
);
let mut url = url::Url::parse(url_str).map_err(get_process_dump_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_dump_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_dump_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_dump_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_dump_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_dump_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_dump_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_process_modules_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfoCollection, list_process_modules_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/modules",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_process_modules_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_modules_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_modules_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_process_modules_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_process_modules_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_process_modules_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_process_modules_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_process_modules_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_module_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
base_address: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessModuleInfo, get_process_module_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/modules/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id,
base_address
);
let mut url = url::Url::parse(url_str).map_err(get_process_module_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_module_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_module_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_module_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessModuleInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_process_module_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_module_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_module_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_module_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_process_threads_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfoCollection, list_process_threads_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/threads",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id
);
let mut url = url::Url::parse(url_str).map_err(list_process_threads_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_threads_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_threads_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_process_threads_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_process_threads_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_process_threads_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_process_threads_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_process_threads_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_process_thread_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
process_id: &str,
thread_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::ProcessThreadInfo, get_process_thread_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/threads/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
process_id,
thread_id
);
let mut url = url::Url::parse(url_str).map_err(get_process_thread_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_process_thread_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_process_thread_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_process_thread_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::ProcessThreadInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_process_thread_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_process_thread_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_process_thread_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_process_thread_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_public_certificates_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PublicCertificateCollection, list_public_certificates_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_public_certificates_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_public_certificates_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_public_certificates_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_public_certificates_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PublicCertificateCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_public_certificates_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_public_certificates_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_public_certificates_slot {
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 get_public_certificate_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
public_certificate_name: &str,
subscription_id: &str,
) -> std::result::Result<models::PublicCertificate, get_public_certificate_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
public_certificate_name
);
let mut url = url::Url::parse(url_str).map_err(get_public_certificate_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_public_certificate_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_public_certificate_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_public_certificate_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PublicCertificate = serde_json::from_slice(rsp_body)
.map_err(|source| get_public_certificate_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_public_certificate_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_public_certificate_slot {
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_public_certificate_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
public_certificate_name: &str,
public_certificate: &models::PublicCertificate,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::PublicCertificate, create_or_update_public_certificate_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
public_certificate_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_public_certificate_slot::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_public_certificate_slot::Error::GetTokenError)?;
req_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(public_certificate).map_err(create_or_update_public_certificate_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_public_certificate_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_public_certificate_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::PublicCertificate = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_public_certificate_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_public_certificate_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_public_certificate_slot {
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_public_certificate_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
public_certificate_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_public_certificate_slot::Response, delete_public_certificate_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
public_certificate_name
);
let mut url = url::Url::parse(url_str).map_err(delete_public_certificate_slot::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_public_certificate_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_public_certificate_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_public_certificate_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_public_certificate_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_public_certificate_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_public_certificate_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_public_certificate_slot {
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_publishing_profile_xml_with_secrets_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
publishing_profile_options: &models::CsmPublishingProfileOptions,
slot: &str,
subscription_id: &str,
) -> std::result::Result<bytes::Bytes, list_publishing_profile_xml_with_secrets_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publishxml",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_publishing_profile_xml_with_secrets_slot::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_publishing_profile_xml_with_secrets_slot::Error::GetTokenError)?;
req_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(publishing_profile_options)
.map_err(list_publishing_profile_xml_with_secrets_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_publishing_profile_xml_with_secrets_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_publishing_profile_xml_with_secrets_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value = rsp_body.clone();
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_publishing_profile_xml_with_secrets_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_publishing_profile_xml_with_secrets_slot {
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 recover_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
recovery_entity: &models::SnapshotRecoveryRequest,
slot: &str,
subscription_id: &str,
) -> std::result::Result<recover_slot::Response, recover_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/recover",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(recover_slot::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(recover_slot::Error::GetTokenError)?;
req_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(recovery_entity).map_err(recover_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(recover_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(recover_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::ACCEPTED => Ok(recover_slot::Response::Accepted202),
http::StatusCode::OK => Ok(recover_slot::Response::Ok200),
status_code => {
let rsp_body = rsp.body();
Err(recover_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod recover_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Accepted202,
Ok200,
}
#[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 reset_slot_configuration_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), reset_slot_configuration_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/resetSlotConfig",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(reset_slot_configuration_slot::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(reset_slot_configuration_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(reset_slot_configuration_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(reset_slot_configuration_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(reset_slot_configuration_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod reset_slot_configuration_slot {
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 restart_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
soft_restart: Option<bool>,
synchronous: Option<bool>,
subscription_id: &str,
) -> std::result::Result<(), restart_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/restart",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(restart_slot::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(restart_slot::Error::GetTokenError)?;
req_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(soft_restart) = soft_restart {
url.query_pairs_mut().append_pair("softRestart", soft_restart.to_string().as_str());
}
if let Some(synchronous) = synchronous {
url.query_pairs_mut().append_pair("synchronous", synchronous.to_string().as_str());
}
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(restart_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(restart_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(restart_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod restart_slot {
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_site_extensions_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteExtensionInfoCollection, list_site_extensions_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_site_extensions_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_site_extensions_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_extensions_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_site_extensions_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfoCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_site_extensions_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_site_extensions_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_site_extensions_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_site_extensions_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_site_extension_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_extension_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SiteExtensionInfo, get_site_extension_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
site_extension_id
);
let mut url = url::Url::parse(url_str).map_err(get_site_extension_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_site_extension_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_extension_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_site_extension_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_site_extension_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_site_extension_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_site_extension_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_site_extension_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 install_site_extension_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_extension_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<install_site_extension_slot::Response, install_site_extension_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
site_extension_id
);
let mut url = url::Url::parse(url_str).map_err(install_site_extension_slot::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(install_site_extension_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(install_site_extension_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(install_site_extension_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfo = serde_json::from_slice(rsp_body)
.map_err(|source| install_site_extension_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(install_site_extension_slot::Response::Created201(rsp_value))
}
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteExtensionInfo = serde_json::from_slice(rsp_body)
.map_err(|source| install_site_extension_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(install_site_extension_slot::Response::Ok200(rsp_value))
}
http::StatusCode::TOO_MANY_REQUESTS => Err(install_site_extension_slot::Error::TooManyRequests429 {}),
status_code => {
let rsp_body = rsp.body();
Err(install_site_extension_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod install_site_extension_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Created201(models::SiteExtensionInfo),
Ok200(models::SiteExtensionInfo),
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
TooManyRequests429 {},
#[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_site_extension_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_extension_id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_site_extension_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
site_extension_id
);
let mut url = url::Url::parse(url_str).map_err(delete_site_extension_slot::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_site_extension_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_site_extension_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_site_extension_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_site_extension_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_site_extension_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_site_extension_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_slot_differences_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_swap_entity: &models::CsmSlotEntity,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SlotDifferenceCollection, list_slot_differences_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/slotsdiffs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_slot_differences_slot::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_slot_differences_slot::Error::GetTokenError)?;
req_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(slot_swap_entity).map_err(list_slot_differences_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_slot_differences_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_slot_differences_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SlotDifferenceCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_slot_differences_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_slot_differences_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_slot_differences_slot {
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 swap_slot_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_swap_entity: &models::CsmSlotEntity,
slot: &str,
subscription_id: &str,
) -> std::result::Result<swap_slot_slot::Response, swap_slot_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/slotsswap",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(swap_slot_slot::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(swap_slot_slot::Error::GetTokenError)?;
req_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(slot_swap_entity).map_err(swap_slot_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder.body(req_body).map_err(swap_slot_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(swap_slot_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(swap_slot_slot::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(swap_slot_slot::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
Err(swap_slot_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod swap_slot_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
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_snapshots_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::SnapshotCollection, list_snapshots_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/snapshots",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_snapshots_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_snapshots_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_snapshots_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_snapshots_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SnapshotCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_snapshots_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_snapshots_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_snapshots_slot {
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 get_source_control_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<get_source_control_slot::Response, get_source_control_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(get_source_control_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_source_control_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_source_control_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_source_control_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| get_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(get_source_control_slot::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| get_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(get_source_control_slot::Response::Created201(rsp_value))
}
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| get_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(get_source_control_slot::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(get_source_control_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_source_control_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SiteSourceControl),
Created201(models::SiteSourceControl),
Accepted202(models::SiteSourceControl),
}
#[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_source_control_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_source_control: &models::SiteSourceControl,
slot: &str,
subscription_id: &str,
) -> std::result::Result<create_or_update_source_control_slot::Response, create_or_update_source_control_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_source_control_slot::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_source_control_slot::Error::GetTokenError)?;
req_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(site_source_control).map_err(create_or_update_source_control_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_source_control_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_source_control_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_source_control_slot::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_source_control_slot::Response::Created201(rsp_value))
}
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_source_control_slot::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_source_control_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_source_control_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SiteSourceControl),
Created201(models::SiteSourceControl),
Accepted202(models::SiteSourceControl),
}
#[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 update_source_control_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_source_control: &models::SiteSourceControl,
slot: &str,
subscription_id: &str,
) -> std::result::Result<update_source_control_slot::Response, update_source_control_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(update_source_control_slot::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_source_control_slot::Error::GetTokenError)?;
req_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(site_source_control).map_err(update_source_control_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_source_control_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_source_control_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| update_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_source_control_slot::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| update_source_control_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_source_control_slot::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(update_source_control_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_source_control_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SiteSourceControl),
Created201(models::SiteSourceControl),
}
#[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_source_control_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<delete_source_control_slot::Response, delete_source_control_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(delete_source_control_slot::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_source_control_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_source_control_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_source_control_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_source_control_slot::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(delete_source_control_slot::Response::Accepted202),
http::StatusCode::NOT_FOUND => Err(delete_source_control_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_source_control_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_source_control_slot {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 start_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), start_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(start_slot::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(start_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(start_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(start_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(start_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod start_slot {
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 stop_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), stop_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/stop",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(stop_slot::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(stop_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(stop_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(stop_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(stop_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod stop_slot {
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 sync_repository_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), sync_repository_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sync",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(sync_repository_slot::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(sync_repository_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(sync_repository_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(sync_repository_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(sync_repository_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod sync_repository_slot {
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 sync_function_triggers_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), sync_function_triggers_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/syncfunctiontriggers",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(sync_function_triggers_slot::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(sync_function_triggers_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(sync_function_triggers_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(sync_function_triggers_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(sync_function_triggers_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod sync_function_triggers_slot {
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_triggered_web_jobs_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredWebJobCollection, list_triggered_web_jobs_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_triggered_web_jobs_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_jobs_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_jobs_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_triggered_web_jobs_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredWebJobCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_triggered_web_jobs_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_triggered_web_jobs_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_triggered_web_jobs_slot {
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 get_triggered_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredWebJob, get_triggered_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(get_triggered_web_job_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_triggered_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredWebJob = serde_json::from_slice(rsp_body)
.map_err(|source| get_triggered_web_job_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_triggered_web_job_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_triggered_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_triggered_web_job_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_triggered_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<delete_triggered_web_job_slot::Response, delete_triggered_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(delete_triggered_web_job_slot::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_triggered_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_triggered_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_triggered_web_job_slot::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_triggered_web_job_slot::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_triggered_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_triggered_web_job_slot {
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_triggered_web_job_history_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredJobHistoryCollection, list_triggered_web_job_history_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}/history",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(list_triggered_web_job_history_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_job_history_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_job_history_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_triggered_web_job_history_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredJobHistoryCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_triggered_web_job_history_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_triggered_web_job_history_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_triggered_web_job_history_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_triggered_web_job_history_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_triggered_web_job_history_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
id: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredJobHistory, get_triggered_web_job_history_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}/history/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name,
id
);
let mut url = url::Url::parse(url_str).map_err(get_triggered_web_job_history_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_job_history_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_job_history_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_triggered_web_job_history_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredJobHistory = serde_json::from_slice(rsp_body)
.map_err(|source| get_triggered_web_job_history_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_triggered_web_job_history_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_triggered_web_job_history_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_triggered_web_job_history_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 run_triggered_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), run_triggered_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}/run",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(run_triggered_web_job_slot::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(run_triggered_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(run_triggered_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(run_triggered_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(run_triggered_web_job_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(run_triggered_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod run_triggered_web_job_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_usages_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::CsmUsageQuotaCollection, list_usages_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/usages",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_usages_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_usages_slot::Error::GetTokenError)?;
req_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_usages_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_usages_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CsmUsageQuotaCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_usages_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_usages_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_usages_slot {
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_vnet_connections_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<Vec<models::VnetInfo>, list_vnet_connections_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_vnet_connections_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_vnet_connections_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connections_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_vnet_connections_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: Vec<models::VnetInfo> = serde_json::from_slice(rsp_body)
.map_err(|source| list_vnet_connections_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_vnet_connections_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_vnet_connections_slot {
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 get_vnet_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetInfo, get_vnet_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(get_vnet_connection_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_vnet_connection_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_vnet_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_vnet_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_vnet_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_vnet_connection_slot {
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_vnet_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
connection_envelope: &models::VnetInfo,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetInfo, create_or_update_vnet_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_vnet_connection_slot::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_vnet_connection_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_vnet_connection_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_vnet_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_vnet_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetInfo = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_vnet_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_vnet_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_vnet_connection_slot {
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 update_vnet_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
connection_envelope: &models::VnetInfo,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetInfo, update_vnet_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(update_vnet_connection_slot::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_vnet_connection_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_vnet_connection_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_vnet_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_vnet_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetInfo = serde_json::from_slice(rsp_body)
.map_err(|source| update_vnet_connection_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_vnet_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_vnet_connection_slot {
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_vnet_connection_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_vnet_connection_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(delete_vnet_connection_slot::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_vnet_connection_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connection_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_vnet_connection_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_vnet_connection_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_vnet_connection_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_vnet_connection_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_vnet_connection_gateway_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
gateway_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetGateway, get_vnet_connection_gateway_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}/gateways/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name,
gateway_name
);
let mut url = url::Url::parse(url_str).map_err(get_vnet_connection_gateway_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_vnet_connection_gateway_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connection_gateway_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_vnet_connection_gateway_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetGateway = serde_json::from_slice(rsp_body)
.map_err(|source| get_vnet_connection_gateway_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_vnet_connection_gateway_slot::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_vnet_connection_gateway_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_vnet_connection_gateway_slot {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_vnet_connection_gateway_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
gateway_name: &str,
connection_envelope: &models::VnetGateway,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetGateway, create_or_update_vnet_connection_gateway_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}/gateways/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name,
gateway_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_vnet_connection_gateway_slot::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_vnet_connection_gateway_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_vnet_connection_gateway_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_vnet_connection_gateway_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_vnet_connection_gateway_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetGateway = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_vnet_connection_gateway_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_vnet_connection_gateway_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_vnet_connection_gateway_slot {
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 update_vnet_connection_gateway_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
gateway_name: &str,
connection_envelope: &models::VnetGateway,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetGateway, update_vnet_connection_gateway_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}/gateways/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
vnet_name,
gateway_name
);
let mut url = url::Url::parse(url_str).map_err(update_vnet_connection_gateway_slot::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_vnet_connection_gateway_slot::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_vnet_connection_gateway_slot::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_vnet_connection_gateway_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_vnet_connection_gateway_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetGateway = serde_json::from_slice(rsp_body)
.map_err(|source| update_vnet_connection_gateway_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_vnet_connection_gateway_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_vnet_connection_gateway_slot {
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_web_jobs_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::WebJobCollection, list_web_jobs_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/webjobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot
);
let mut url = url::Url::parse(url_str).map_err(list_web_jobs_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_web_jobs_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_web_jobs_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_web_jobs_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebJobCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_web_jobs_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_web_jobs_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_web_jobs_slot {
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 get_web_job_slot(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
slot: &str,
subscription_id: &str,
) -> std::result::Result<models::WebJob, get_web_job_slot::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/webjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
slot,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(get_web_job_slot::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_web_job_slot::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_web_job_slot::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_web_job_slot::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebJob = serde_json::from_slice(rsp_body)
.map_err(|source| get_web_job_slot::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_web_job_slot::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_web_job_slot {
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_slot_differences_from_production(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_swap_entity: &models::CsmSlotEntity,
subscription_id: &str,
) -> std::result::Result<models::SlotDifferenceCollection, list_slot_differences_from_production::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slotsdiffs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_slot_differences_from_production::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_slot_differences_from_production::Error::GetTokenError)?;
req_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(slot_swap_entity).map_err(list_slot_differences_from_production::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(list_slot_differences_from_production::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_slot_differences_from_production::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SlotDifferenceCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_slot_differences_from_production::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_slot_differences_from_production::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_slot_differences_from_production {
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 swap_slot_with_production(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
slot_swap_entity: &models::CsmSlotEntity,
subscription_id: &str,
) -> std::result::Result<swap_slot_with_production::Response, swap_slot_with_production::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slotsswap",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(swap_slot_with_production::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(swap_slot_with_production::Error::GetTokenError)?;
req_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(slot_swap_entity).map_err(swap_slot_with_production::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(swap_slot_with_production::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(swap_slot_with_production::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(swap_slot_with_production::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(swap_slot_with_production::Response::Accepted202),
status_code => {
let rsp_body = rsp.body();
Err(swap_slot_with_production::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod swap_slot_with_production {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
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_snapshots(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::SnapshotCollection, list_snapshots::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/snapshots",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_snapshots::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_snapshots::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_snapshots::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_snapshots::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SnapshotCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_snapshots::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_snapshots::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_snapshots {
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 get_source_control(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<get_source_control::Response, get_source_control::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(get_source_control::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_source_control::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_source_control::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_source_control::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| get_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(get_source_control::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| get_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(get_source_control::Response::Created201(rsp_value))
}
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| get_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(get_source_control::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(get_source_control::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_source_control {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SiteSourceControl),
Created201(models::SiteSourceControl),
Accepted202(models::SiteSourceControl),
}
#[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_source_control(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_source_control: &models::SiteSourceControl,
subscription_id: &str,
) -> std::result::Result<create_or_update_source_control::Response, create_or_update_source_control::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_source_control::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_source_control::Error::GetTokenError)?;
req_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(site_source_control).map_err(create_or_update_source_control::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_source_control::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_source_control::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_source_control::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_source_control::Response::Created201(rsp_value))
}
http::StatusCode::ACCEPTED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(create_or_update_source_control::Response::Accepted202(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_source_control::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_source_control {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SiteSourceControl),
Created201(models::SiteSourceControl),
Accepted202(models::SiteSourceControl),
}
#[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 update_source_control(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
site_source_control: &models::SiteSourceControl,
subscription_id: &str,
) -> std::result::Result<update_source_control::Response, update_source_control::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(update_source_control::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_source_control::Error::GetTokenError)?;
req_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(site_source_control).map_err(update_source_control::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_source_control::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_source_control::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| update_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_source_control::Response::Ok200(rsp_value))
}
http::StatusCode::CREATED => {
let rsp_body = rsp.body();
let rsp_value: models::SiteSourceControl = serde_json::from_slice(rsp_body)
.map_err(|source| update_source_control::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(update_source_control::Response::Created201(rsp_value))
}
status_code => {
let rsp_body = rsp.body();
Err(update_source_control::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_source_control {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200(models::SiteSourceControl),
Created201(models::SiteSourceControl),
}
#[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_source_control(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<delete_source_control::Response, delete_source_control::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(delete_source_control::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_source_control::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_source_control::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_source_control::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_source_control::Response::Ok200),
http::StatusCode::ACCEPTED => Ok(delete_source_control::Response::Accepted202),
http::StatusCode::NOT_FOUND => Err(delete_source_control::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_source_control::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_source_control {
use super::{models, API_VERSION};
#[derive(Debug)]
pub enum Response {
Ok200,
Accepted202,
}
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 start(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<(), start::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/start",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(start::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(start::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(start::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(start::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(start::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod start {
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 stop(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<(), stop::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/stop",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(stop::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(stop::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(stop::Error::BuildRequestError)?;
let rsp = http_client.execute_request(req).await.map_err(stop::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(stop::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod stop {
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 sync_repository(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<(), sync_repository::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sync",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(sync_repository::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(sync_repository::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(sync_repository::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(sync_repository::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(sync_repository::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod sync_repository {
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 sync_function_triggers(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<(), sync_function_triggers::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/syncfunctiontriggers",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(sync_function_triggers::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(sync_function_triggers::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_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(sync_function_triggers::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(sync_function_triggers::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::NO_CONTENT => Ok(()),
status_code => {
let rsp_body = rsp.body();
Err(sync_function_triggers::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod sync_function_triggers {
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_triggered_web_jobs(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredWebJobCollection, list_triggered_web_jobs::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_triggered_web_jobs::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_jobs::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_jobs::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_triggered_web_jobs::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredWebJobCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_triggered_web_jobs::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_triggered_web_jobs::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_triggered_web_jobs {
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 get_triggered_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredWebJob, get_triggered_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(get_triggered_web_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(get_triggered_web_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(get_triggered_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_triggered_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredWebJob = serde_json::from_slice(rsp_body)
.map_err(|source| get_triggered_web_job::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_triggered_web_job::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_triggered_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_triggered_web_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_triggered_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<delete_triggered_web_job::Response, delete_triggered_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(delete_triggered_web_job::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_triggered_web_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(delete_triggered_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_triggered_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(delete_triggered_web_job::Response::Ok200),
http::StatusCode::NO_CONTENT => Ok(delete_triggered_web_job::Response::NoContent204),
status_code => {
let rsp_body = rsp.body();
Err(delete_triggered_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_triggered_web_job {
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_triggered_web_job_history(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredJobHistoryCollection, list_triggered_web_job_history::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}/history",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(list_triggered_web_job_history::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_job_history::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_job_history::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_triggered_web_job_history::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredJobHistoryCollection = serde_json::from_slice(rsp_body)
.map_err(|source| list_triggered_web_job_history::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(list_triggered_web_job_history::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(list_triggered_web_job_history::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_triggered_web_job_history {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_triggered_web_job_history(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
id: &str,
subscription_id: &str,
) -> std::result::Result<models::TriggeredJobHistory, get_triggered_web_job_history::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}/history/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name,
id
);
let mut url = url::Url::parse(url_str).map_err(get_triggered_web_job_history::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_triggered_web_job_history::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_triggered_web_job_history::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_triggered_web_job_history::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::TriggeredJobHistory = serde_json::from_slice(rsp_body)
.map_err(|source| get_triggered_web_job_history::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_triggered_web_job_history::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_triggered_web_job_history::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_triggered_web_job_history {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 run_triggered_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<(), run_triggered_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}/run",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(run_triggered_web_job::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(run_triggered_web_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.header(http::header::CONTENT_LENGTH, 0);
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(run_triggered_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(run_triggered_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(run_triggered_web_job::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(run_triggered_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod run_triggered_web_job {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_usages(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
filter: Option<&str>,
subscription_id: &str,
) -> std::result::Result<models::CsmUsageQuotaCollection, list_usages::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/usages",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_usages::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_usages::Error::GetTokenError)?;
req_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_usages::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_usages::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::CsmUsageQuotaCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_usages::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_usages::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_usages {
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_vnet_connections(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<Vec<models::VnetInfo>, list_vnet_connections::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_vnet_connections::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_vnet_connections::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connections::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_vnet_connections::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: Vec<models::VnetInfo> = serde_json::from_slice(rsp_body)
.map_err(|source| list_vnet_connections::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_vnet_connections::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_vnet_connections {
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 get_vnet_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetInfo, get_vnet_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(get_vnet_connection::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_vnet_connection::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_vnet_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetInfo = serde_json::from_slice(rsp_body)
.map_err(|source| get_vnet_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_vnet_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_vnet_connection {
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_vnet_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
connection_envelope: &models::VnetInfo,
subscription_id: &str,
) -> std::result::Result<models::VnetInfo, create_or_update_vnet_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_vnet_connection::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_vnet_connection::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_vnet_connection::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_vnet_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_vnet_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetInfo = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_vnet_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_vnet_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_vnet_connection {
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 update_vnet_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
connection_envelope: &models::VnetInfo,
subscription_id: &str,
) -> std::result::Result<models::VnetInfo, update_vnet_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(update_vnet_connection::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_vnet_connection::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_vnet_connection::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_vnet_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_vnet_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetInfo = serde_json::from_slice(rsp_body)
.map_err(|source| update_vnet_connection::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_vnet_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_vnet_connection {
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_vnet_connection(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
subscription_id: &str,
) -> std::result::Result<(), delete_vnet_connection::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name
);
let mut url = url::Url::parse(url_str).map_err(delete_vnet_connection::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_vnet_connection::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connection::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(delete_vnet_connection::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => Ok(()),
http::StatusCode::NOT_FOUND => Err(delete_vnet_connection::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(delete_vnet_connection::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod delete_vnet_connection {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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 get_vnet_connection_gateway(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
gateway_name: &str,
subscription_id: &str,
) -> std::result::Result<models::VnetGateway, get_vnet_connection_gateway::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}/gateways/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name,
gateway_name
);
let mut url = url::Url::parse(url_str).map_err(get_vnet_connection_gateway::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_vnet_connection_gateway::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_vnet_connection_gateway::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_vnet_connection_gateway::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetGateway = serde_json::from_slice(rsp_body)
.map_err(|source| get_vnet_connection_gateway::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
http::StatusCode::NOT_FOUND => Err(get_vnet_connection_gateway::Error::NotFound404 {}),
status_code => {
let rsp_body = rsp.body();
Err(get_vnet_connection_gateway::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_vnet_connection_gateway {
use super::{models, API_VERSION};
#[derive(Debug, thiserror :: Error)]
pub enum Error {
#[error("Error response #response_type")]
NotFound404 {},
#[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_vnet_connection_gateway(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
gateway_name: &str,
connection_envelope: &models::VnetGateway,
subscription_id: &str,
) -> std::result::Result<models::VnetGateway, create_or_update_vnet_connection_gateway::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}/gateways/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name,
gateway_name
);
let mut url = url::Url::parse(url_str).map_err(create_or_update_vnet_connection_gateway::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_vnet_connection_gateway::Error::GetTokenError)?;
req_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(connection_envelope).map_err(create_or_update_vnet_connection_gateway::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(create_or_update_vnet_connection_gateway::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(create_or_update_vnet_connection_gateway::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetGateway = serde_json::from_slice(rsp_body)
.map_err(|source| create_or_update_vnet_connection_gateway::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(create_or_update_vnet_connection_gateway::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod create_or_update_vnet_connection_gateway {
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 update_vnet_connection_gateway(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
vnet_name: &str,
gateway_name: &str,
connection_envelope: &models::VnetGateway,
subscription_id: &str,
) -> std::result::Result<models::VnetGateway, update_vnet_connection_gateway::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}/gateways/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
vnet_name,
gateway_name
);
let mut url = url::Url::parse(url_str).map_err(update_vnet_connection_gateway::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_vnet_connection_gateway::Error::GetTokenError)?;
req_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(connection_envelope).map_err(update_vnet_connection_gateway::Error::SerializeError)?;
req_builder = req_builder.uri(url.as_str());
let req = req_builder
.body(req_body)
.map_err(update_vnet_connection_gateway::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(update_vnet_connection_gateway::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::VnetGateway = serde_json::from_slice(rsp_body)
.map_err(|source| update_vnet_connection_gateway::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(update_vnet_connection_gateway::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod update_vnet_connection_gateway {
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_web_jobs(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
subscription_id: &str,
) -> std::result::Result<models::WebJobCollection, list_web_jobs::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/webjobs",
operation_config.base_path(),
subscription_id,
resource_group_name,
name
);
let mut url = url::Url::parse(url_str).map_err(list_web_jobs::Error::ParseUrlError)?;
let mut req_builder = http::request::Builder::new();
req_builder = req_builder.method(http::Method::GET);
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_web_jobs::Error::GetTokenError)?;
req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
}
url.query_pairs_mut().append_pair("api-version", super::API_VERSION);
let req_body = bytes::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_web_jobs::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(list_web_jobs::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebJobCollection =
serde_json::from_slice(rsp_body).map_err(|source| list_web_jobs::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(list_web_jobs::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod list_web_jobs {
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 get_web_job(
operation_config: &crate::OperationConfig,
resource_group_name: &str,
name: &str,
web_job_name: &str,
subscription_id: &str,
) -> std::result::Result<models::WebJob, get_web_job::Error> {
let http_client = operation_config.http_client();
let url_str = &format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/webjobs/{}",
operation_config.base_path(),
subscription_id,
resource_group_name,
name,
web_job_name
);
let mut url = url::Url::parse(url_str).map_err(get_web_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(get_web_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(get_web_job::Error::BuildRequestError)?;
let rsp = http_client
.execute_request(req)
.await
.map_err(get_web_job::Error::ExecuteRequestError)?;
match rsp.status() {
http::StatusCode::OK => {
let rsp_body = rsp.body();
let rsp_value: models::WebJob =
serde_json::from_slice(rsp_body).map_err(|source| get_web_job::Error::DeserializeError(source, rsp_body.clone()))?;
Ok(rsp_value)
}
status_code => {
let rsp_body = rsp.body();
Err(get_web_job::Error::UnexpectedResponse {
status_code,
body: rsp_body.clone(),
})
}
}
}
pub mod get_web_job {
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),
}
}
}
|
use std::cell::RefCell;
use std::rc::Rc;
use crate::treenode::TreeNode;
pub fn build_tree(preorder: Vec<i32>, inorder: Vec<i32>) -> Option<Rc<RefCell<TreeNode>>> {
fn build_tree_by_slice(preorder: &[i32], inorder: &[i32]) -> Option<Rc<RefCell<TreeNode>>> {
match preorder.len() {
0 => None,
n => {
let val = preorder[0];
let index_in_inorder = inorder.iter().position(|&r| r == val).unwrap();
let left = build_tree_by_slice(&preorder[1..=index_in_inorder], &inorder[..index_in_inorder]);
let right = build_tree_by_slice(&preorder[index_in_inorder + 1..], &inorder[index_in_inorder + 1..]);
Some(Rc::new(RefCell::new(TreeNode { val, left, right })))
}
}
}
build_tree_by_slice(preorder.as_slice(), inorder.as_slice())
} |
use std::env;
use std::fs::*;
use clap::*;
use serde::{Serialize, Deserialize};
use std::io::prelude::*;
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ProgramArgs {
pub input_file: String,
pub output_file: String,
pub printbed_width: f32,
pub printbed_height: f32,
pub scaling_x: f32,
pub scaling_y: f32,
pub preserve_aspect: bool
}
impl ProgramArgs {
pub fn new() -> Option<Self> {
if env::args().len() == 1 {
let raw_config = read_to_string("config");
let config: ProgramArgs;
match raw_config {
Ok(val) => config = serde_json::from_str(&val).unwrap(),
_ => return None
}
return Some(config);
}
else {
let arguments = App::new("SVG Slicer")
.version("0.1.0")
.author("Austin Haskell")
.about("SVG Slicer designed to handle large files. Seperates files into quadrants based on printbed size")
.arg(Arg::with_name("file")
.short("f")
.long("file")
.takes_value(true)
.required(true)
.help("File to slice"))
.arg(Arg::with_name("output")
.short("o")
.long("output")
.takes_value(true)
.help("Filename of output gcode. "))
.arg(Arg::with_name("width")
.short("w")
.long("width")
.required(true)
.takes_value(true)
.help("Width (in mm) of printbed."))
.arg(Arg::with_name("height")
.short("h")
.long("height")
.required(true)
.takes_value(true)
.help("Height (in mm) of printbed."))
.arg(Arg::with_name("x_scaling")
.short("x")
.long("xscale")
.required(true)
.takes_value(true)
.help("Scale svg file to fit x meters in the x direction. "))
.arg(Arg::with_name("y_scaling")
.short("y")
.long("yscale")
.takes_value(true)
.help("Scale svg file to fit y meters in the x direction. "))
.arg(Arg::with_name("preserve_aspect")
.short("a")
.long("aspect")
.takes_value(false)
.help("If present, will scale to the x scaling but will not honor y scaling to preserve aspect ratio in original file. Defaults to false"))
.get_matches();
let input_filename = arguments.value_of("file").unwrap_or("input.svg");
let output_filename = arguments.value_of("output").unwrap_or("output.gcode");
let printbed_width: f32 = arguments.value_of("width").unwrap_or("16").parse().unwrap_or(16.0);
let printbed_height: f32 = arguments.value_of("height").unwrap_or("16").parse().unwrap_or(16.0);
let scale_x: f32 = arguments.value_of("x_scaling").unwrap_or("1").parse().unwrap_or(1.0);
let scale_y: f32 = arguments.value_of("y_scaling").unwrap_or("1").parse().unwrap_or(1.0);
let preserve_aspect_ratio: bool = arguments.is_present("preserve_aspect");
return Some(ProgramArgs {
input_file: String::from(input_filename),
output_file: String::from(output_filename),
printbed_width: printbed_width,
printbed_height: printbed_height,
scaling_x: scale_x,
scaling_y: scale_y,
preserve_aspect: preserve_aspect_ratio
})
}
}
pub fn dump(&self, path: &str) {
let arg_dump = serde_json::to_string(&self);
match arg_dump {
Err(e) => {
println!("Error: Failed to dump arguments to file. ");
return;
},
_ => { }
}
let raw_arg_file = File::create(path);
let mut arg_file;
match raw_arg_file {
Err(e) => {
println!("Failed to create/open argument file: {:?}", path);
return;
},
Ok(val) => arg_file = val
}
arg_file.write_all(arg_dump.unwrap().as_bytes()).unwrap();
}
} |
use async_std::io;
use async_trait::async_trait;
use crate::Request;
#[async_trait]
pub trait Middleware: Send + Sync {
async fn call(&self, request: &mut Request<'_>) -> io::Result<()>;
}
/// Log all requests.
pub struct Logger {}
impl Default for Logger {
fn default() -> Self {
femme::pretty::Logger::new()
.start(log::LevelFilter::Info)
.unwrap();
Logger {}
}
}
#[async_trait]
impl Middleware for Logger {
async fn call(&self, request: &mut Request<'_>) -> io::Result<()> {
log::info!("[{}] {}", request.method(), request.path());
Ok(())
}
}
|
pub use crate::{
db::HirDatabase,
error::HirError,
expressions::{
AscriptionExprData, AssignmentData, BlockExprData, CallExprData, ExpressionData,
FieldExprData, IfExprData, LiteralData, LiteralKind, MatchExprData, RecordExprData,
StatementData,
},
ident::{IdentifierData, ScopedIdentifierData},
ids::{
AscriptionExpr, AscriptionPat, Assignment, BlockExpr, CallExpr, Constant, Export,
Expression, ExternalModule, FieldExpr, Function, FunctionType, Identifier, IfExpr, Import,
Item, Literal, MatchExpr, Module, Path, Pattern, RecordExpr, RecordPat, RecordType,
RenamePat, ScopedIdentifier, Statement, Type, TypeDecl,
},
items::{
ConstantData, ExportData, ExternalModuleData, FunctionData, ImportData, ItemData, ItemKind,
ModuleData, TypeDeclData,
},
path::{PathComponent, PathData},
patterns::{AscriptionPatData, PatternData, RecordPatData, RenamePatData},
types::{FunctionTypeData, RecordTypeData, TypeData},
};
|
//! Things related to making VapourSynth plugins.
use anyhow::Error;
use crate::api::API;
use crate::core::CoreRef;
use crate::frame::FrameRef;
use crate::function::Function;
use crate::map::{self, Map, Value, ValueIter};
use crate::node::Node;
use crate::video_info::VideoInfo;
mod frame_context;
pub use self::frame_context::FrameContext;
pub mod ffi;
/// Plugin metadata.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct Metadata {
/// A "reverse" URL, unique among all plugins.
///
/// For example, `com.example.invert`.
pub identifier: &'static str,
/// Namespace where the plugin's filters will go, unique among all plugins.
///
/// Only lowercase letters and the underscore should be used, and it shouldn't be too long.
/// Additionally, words that are special to Python, e.g. `del`, should be avoided.
///
/// For example, `invert`.
pub namespace: &'static str,
/// Plugin name in readable form.
///
/// For example, `Invert Example Plugin`.
pub name: &'static str,
/// Whether new filters can be registered at runtime.
///
/// This should generally be set to `false`. It's used for the built-in AviSynth compat plugin.
pub read_only: bool,
}
/// A filter function interface.
///
/// See the `make_filter_function!` macro that generates types implementing this automatically.
pub trait FilterFunction: Send + Sync {
/// Returns the name of the function.
///
/// The characters allowed are letters, numbers, and the underscore. The first character must
/// be a letter. In other words: `^[a-zA-Z][a-zA-Z0-9_]*$`.
///
/// For example, `Invert`.
fn name(&self) -> &str;
/// Returns the argument string.
///
/// Arguments are separated by a semicolon. Each argument is made of several fields separated
/// by a colon. Donโt insert additional whitespace characters, or VapourSynth will die.
///
/// Fields:
/// - The argument name. The same characters are allowed as for the filter's name. Argument
/// names should be all lowercase and use only letters and the underscore.
///
/// - The type. One of `int`, `float`, `data`, `clip`, `frame`, `func`. They correspond to the
/// `Map::get_*()` functions (`clip` is `get_node()`). It's possible to declare an array by
/// appending `[]` to the type.
///
/// - `opt` if the parameter is optional.
///
/// - `empty` if the array is allowed to be empty.
///
/// The following example declares the arguments "blah", "moo", and "asdf":
/// `blah:clip;moo:int[]:opt;asdf:float:opt;`
fn args(&self) -> &str;
/// The callback for this filter function.
///
/// In most cases this is where you should create a new instance of the filter and return it.
/// However, a filter function like AviSynth compat's `LoadPlugin()` which isn't actually a
/// filter, can return `None`.
///
/// `args` contains the filter arguments, as specified by the argument string from
/// `FilterFunction::args()`. Their presence and types are validated by VapourSynth so it's
/// safe to `unwrap()`.
///
/// In this function you should take all input nodes for your filter and store them somewhere
/// so that you can request their frames in `get_frame_initial()`.
// TODO: with generic associated types it'll be possible to make Filter<'core> an associated
// type of this trait and get rid of this Box.
fn create<'core>(
&self,
api: API,
core: CoreRef<'core>,
args: &Map<'core>,
) -> Result<Option<Box<dyn Filter<'core> + 'core>>, Error>;
}
/// A filter interface.
// TODO: perhaps it's possible to figure something out about Send + Sync with specialization? Since
// there are Node flags which say that the filter will be called strictly by one thread, in which
// case Sync shouldn't be required.
pub trait Filter<'core>: Send + Sync {
/// Returns the parameters of this filter's output node.
///
/// The returned vector should contain one entry for each node output index.
fn video_info(&self, api: API, core: CoreRef<'core>) -> Vec<VideoInfo<'core>>;
/// Requests the necessary frames from downstream nodes.
///
/// This is always the first function to get called for a given frame `n`.
///
/// In this function you should call `request_frame_filter()` on any input nodes that you need
/// and return `None`. If you do not need any input frames, you should generate the output
/// frame and return it here.
///
/// Do not call `Node::get_frame()` from within this function.
fn get_frame_initial(
&self,
api: API,
core: CoreRef<'core>,
context: FrameContext,
n: usize,
) -> Result<Option<FrameRef<'core>>, Error>;
/// Returns the requested frame.
///
/// This is always the second function to get called for a given frame `n`. If the frame was
/// retrned from `get_frame_initial()`, this function is not called.
///
/// In this function you should call `get_frame_filter()` on the input nodes to retrieve the
/// frames you requested in `get_frame_initial()`.
///
/// Do not call `Node::get_frame()` from within this function.
fn get_frame(
&self,
api: API,
core: CoreRef<'core>,
context: FrameContext,
n: usize,
) -> Result<FrameRef<'core>, Error>;
}
/// An internal trait representing a filter argument type.
pub trait FilterArgument<'map, 'elem: 'map>: Value<'map, 'elem> + private::Sealed {
/// Returns the VapourSynth type name for this argument type.
fn type_name() -> &'static str;
}
/// An internal trait representing a filter parameter type (argument type + whether it's an array
/// or optional).
pub trait FilterParameter<'map, 'elem: 'map>: private::Sealed {
/// The underlying argument type for this parameter type.
type Argument: FilterArgument<'map, 'elem>;
/// Returns whether this parameter is an array.
fn is_array() -> bool;
/// Returns whether this parameter is optional.
fn is_optional() -> bool;
/// Retrieves this parameter from the given map.
fn get_from_map(map: &'map Map<'elem>, key: &str) -> Self;
}
impl<'map, 'elem: 'map> FilterArgument<'map, 'elem> for i64 {
#[inline]
fn type_name() -> &'static str {
"int"
}
}
impl<'map, 'elem: 'map> FilterArgument<'map, 'elem> for f64 {
#[inline]
fn type_name() -> &'static str {
"float"
}
}
impl<'map, 'elem: 'map> FilterArgument<'map, 'elem> for &'map [u8] {
#[inline]
fn type_name() -> &'static str {
"data"
}
}
impl<'map, 'elem: 'map> FilterArgument<'map, 'elem> for Node<'elem> {
#[inline]
fn type_name() -> &'static str {
"clip"
}
}
impl<'map, 'elem: 'map> FilterArgument<'map, 'elem> for FrameRef<'elem> {
#[inline]
fn type_name() -> &'static str {
"frame"
}
}
impl<'map, 'elem: 'map> FilterArgument<'map, 'elem> for Function<'elem> {
#[inline]
fn type_name() -> &'static str {
"func"
}
}
impl<'map, 'elem: 'map, T> FilterParameter<'map, 'elem> for T
where
T: FilterArgument<'map, 'elem>,
{
type Argument = Self;
#[inline]
fn is_array() -> bool {
false
}
#[inline]
fn is_optional() -> bool {
false
}
#[inline]
fn get_from_map(map: &'map Map<'elem>, key: &str) -> Self {
Self::get_from_map(map, key).unwrap()
}
}
impl<'map, 'elem: 'map, T> FilterParameter<'map, 'elem> for Option<T>
where
T: FilterArgument<'map, 'elem>,
{
type Argument = T;
#[inline]
fn is_array() -> bool {
false
}
#[inline]
fn is_optional() -> bool {
true
}
#[inline]
fn get_from_map(map: &'map Map<'elem>, key: &str) -> Self {
match <Self::Argument as Value>::get_from_map(map, key) {
Ok(x) => Some(x),
Err(map::Error::KeyNotFound) => None,
_ => unreachable!(),
}
}
}
impl<'map, 'elem: 'map, T> FilterParameter<'map, 'elem> for ValueIter<'map, 'elem, T>
where
T: FilterArgument<'map, 'elem>,
{
type Argument = T;
#[inline]
fn is_array() -> bool {
true
}
#[inline]
fn is_optional() -> bool {
false
}
#[inline]
fn get_from_map(map: &'map Map<'elem>, key: &str) -> Self {
<Self::Argument>::get_iter_from_map(map, key).unwrap()
}
}
impl<'map, 'elem: 'map, T> FilterParameter<'map, 'elem> for Option<ValueIter<'map, 'elem, T>>
where
T: FilterArgument<'map, 'elem>,
{
type Argument = T;
#[inline]
fn is_array() -> bool {
true
}
#[inline]
fn is_optional() -> bool {
true
}
#[inline]
fn get_from_map(map: &'map Map<'elem>, key: &str) -> Self {
match <Self::Argument as Value>::get_iter_from_map(map, key) {
Ok(x) => Some(x),
Err(map::Error::KeyNotFound) => None,
_ => unreachable!(),
}
}
}
mod private {
use super::{FilterArgument, FrameRef, Function, Node, ValueIter};
pub trait Sealed {}
impl Sealed for i64 {}
impl Sealed for f64 {}
impl<'map> Sealed for &'map [u8] {}
impl<'elem> Sealed for Node<'elem> {}
impl<'elem> Sealed for FrameRef<'elem> {}
impl<'elem> Sealed for Function<'elem> {}
impl<'map, 'elem: 'map, T> Sealed for Option<T> where T: FilterArgument<'map, 'elem> {}
impl<'map, 'elem: 'map, T> Sealed for ValueIter<'map, 'elem, T> where T: FilterArgument<'map, 'elem> {}
impl<'map, 'elem: 'map, T> Sealed for Option<ValueIter<'map, 'elem, T>> where
T: FilterArgument<'map, 'elem>
{
}
}
/// Make a filter function easily and avoid boilerplate.
///
/// This macro accepts the name of the filter function type, the name of the filter and the create
/// function.
///
/// The macro generates a type implementing `FilterFunction` with the correct `args()` string
/// derived from the function parameters of the specified create function. The generated
/// `FilterFunction::create()` extracts all parameters from the argument map received from
/// VapourSynth and passes them into the specified create function.
///
/// The create function should look like:
///
/// ```ignore
/// fn create<'core>(
/// api: API,
/// core: CoreRef<'core>,
/// /* filter arguments */
/// ) -> Result<Option<Box<Filter<'core> + 'core>>, Error> {
/// /* ... */
/// }
/// ```
///
/// All VapourSynth-supported types can be used, as well as `Option<T>` for optional parameters and
/// `ValueIter<T>` for array parameters. Array parameters can be empty.
///
/// Caveat: the macro doesn't currently allow specifying mutable parameters, so to do that they
/// have to be reassigned to a mutable variable in the function body. This is mainly a problem for
/// array parameters. See how the example below handles it.
///
/// Another caveat: underscore lifetimes are required for receiving `ValueIter<T>`.
///
/// # Example
/// ```ignore
/// make_filter_function! {
/// MyFilterFunction, "MyFilter"
///
/// fn create_my_filter<'core>(
/// _api: API,
/// _core: CoreRef<'core>,
/// int_parameter: i64,
/// some_data: &[u8],
/// optional_parameter: Option<f64>,
/// array_parameter: ValueIter<'_, 'core, Node<'core>>,
/// optional_array_parameter: Option<ValueIter<'_, 'core, FrameRef<'core>>>,
/// ) -> Result<Option<Box<Filter<'core> + 'core>>, Error> {
/// let mut array_parameter = array_parameter;
/// Ok(Some(Box::new(MyFilter::new(/* ... */))));
/// }
/// }
/// ```
#[macro_export]
macro_rules! make_filter_function {
(
$struct_name:ident, $function_name:tt
$(#[$attr:meta])*
fn $create_fn_name:ident<$lifetime:tt>(
$api_arg_name:ident : $api_arg_type:ty,
$core_arg_name:ident : $core_arg_type:ty,
$($arg_name:ident : $arg_type:ty),* $(,)*
) -> $return_type:ty {
$($body:tt)*
}
) => (
struct $struct_name {
args: String,
}
impl $struct_name {
fn new<'core>() -> Self {
let mut args = String::new();
$(
// Don't use format!() for better constant propagation.
args += stringify!($arg_name); // TODO: allow using a different name.
args += ":";
args
+= <<$arg_type as $crate::plugins::FilterParameter>::Argument>::type_name();
if <$arg_type as $crate::plugins::FilterParameter>::is_array() {
args += "[]";
}
if <$arg_type as $crate::plugins::FilterParameter>::is_optional() {
args += ":opt";
}
// TODO: allow specifying this.
if <$arg_type as $crate::plugins::FilterParameter>::is_array() {
args += ":empty";
}
args += ";";
)*
Self { args }
}
}
impl $crate::plugins::FilterFunction for $struct_name {
#[inline]
fn name(&self) -> &str {
$function_name
}
#[inline]
fn args(&self) -> &str {
&self.args
}
#[inline]
fn create<'core>(
&self,
api: API,
core: CoreRef<'core>,
args: &Map<'core>,
) -> Result<Option<Box<dyn $crate::plugins::Filter<'core> + 'core>>, Error> {
$create_fn_name(
api,
core,
$(
<$arg_type as $crate::plugins::FilterParameter>::get_from_map(
args,
stringify!($arg_name),
)
),*
)
}
}
$(#[$attr])*
fn $create_fn_name<$lifetime>(
$api_arg_name : $api_arg_type,
$core_arg_name : $core_arg_type,
$($arg_name : $arg_type),*
) -> $return_type {
$($body)*
}
)
}
|
use sudo_test::{Command, Env, TextFile};
use crate::{Result, USERNAME};
#[test]
fn signal_sent_by_child_process_is_ignored() -> Result<()> {
let script = include_str!("kill-su-parent.sh");
let script_path = "/tmp/script.sh";
let env = Env("")
.user(USERNAME)
.file(script_path, TextFile(script).chmod("777"))
.build()?;
let output = Command::new("su")
.arg("-c")
.arg(format!("sh {script_path}"))
.arg("root")
.output(&env)?;
assert!(output.status().success());
assert!(output.stderr().is_empty());
Ok(())
}
#[test]
fn signal_is_forwarded_to_child() -> Result<()> {
let expected = "got signal";
let signal = "TERM";
let expects_signal = "/root/expects-signal.sh";
let kill_su = "/root/kill-su.sh";
let env = Env("")
.file(expects_signal, include_str!("expects-signal.sh"))
.file(kill_su, include_str!("kill-su.sh"))
.build()?;
let child = Command::new("su")
.arg("-c")
.arg(format!("sh {expects_signal} {signal}"))
.spawn(&env)?;
Command::new("sh")
.arg(kill_su)
.arg(format!("-{signal}"))
.output(&env)?
.assert_success()?;
let actual = child.wait()?.stdout()?;
assert_eq!(expected, actual);
Ok(())
}
#[test]
fn child_terminated_by_signal() -> Result<()> {
let env = Env("").build()?;
// child process sends SIGTERM to itself
let output = Command::new("su")
.arg("-c")
.arg("sh -c 'kill $$'")
.output(&env)?;
assert_eq!(Some(143), output.status().code());
assert!(output.stderr().is_empty());
Ok(())
}
#[test]
fn sigstp_works() -> Result<()> {
const STOP_DELAY: u64 = 5;
const NUM_ITERATIONS: usize = 5;
let script_path = "/tmp/script.sh";
let env = Env("")
.file(script_path, include_str!("sigtstp.bash"))
.build()?;
let output = Command::new("bash")
.arg(script_path)
.output(&env)?
.stdout()?;
let timestamps = output
.lines()
.filter_map(|line| line.parse::<u64>().ok())
.collect::<Vec<_>>();
dbg!(×tamps);
assert_eq!(NUM_ITERATIONS, timestamps.len());
let suspended_iterations = timestamps
.windows(2)
.filter(|window| {
let prev_timestamp = window[0];
let curr_timestamp = window[1];
let delta = curr_timestamp - prev_timestamp;
delta >= STOP_DELAY
})
.count();
let did_suspend = suspended_iterations == 1;
assert!(did_suspend);
Ok(())
}
#[test]
fn sigalrm_terminates_command() -> Result<()> {
let expected = "got signal";
let expects_signal = "/root/expects-signal.sh";
let kill_su = "/root/kill-su.sh";
let env = Env("")
.file(expects_signal, include_str!("expects-signal.sh"))
.file(kill_su, include_str!("kill-su.sh"))
.build()?;
let child = Command::new("su")
.arg("-c")
.arg(format!("sh {expects_signal} HUP TERM"))
.spawn(&env)?;
Command::new("sh")
.args([kill_su, "-ALRM"])
.output(&env)?
.assert_success()?;
let actual = child.wait()?.stdout()?;
assert_eq!(expected, actual);
Ok(())
}
|
struct Node {
val: i32,
next: Option<Box<Node>>,
}
impl Node {
fn new(val: i32) -> Self {
Node {
val,
next: None
}
}
fn insert(&mut self, val: i32) {
match &mut self.next {
Some(n) => {
n.insert(val)
},
None => {
self.next = Some(Box::new(Node {
val,
next: None,
}));
},
}
}
fn print(&self) {
println!("{}", self.val);
match &self.next {
Some(n) => {
n.print();
},
None => {
println!("Reached end of linked list");
},
};
}
}
|
pub fn rand(min: i32, max: i32) -> i32 {
Rando
} |
use crate::network::message::{GameState, PaddleState};
#[cfg(not(target_arch = "wasm32"))]
use log::*;
use nalgebra::{Isometry2, Point2, Vector2};
use ncollide2d::query::Proximity;
use ncollide2d::shape::Cuboid;
use ncollide2d::{query, shape};
#[cfg(target_arch = "wasm32")]
use quicksilver::log::*;
#[derive(Debug)]
pub struct SimplePong {
left_paddle: Paddle,
right_paddle: Paddle,
ball: Ball,
server_ball: Ball,
paused: bool,
}
#[derive(Debug)]
pub struct Ball {
pub position: Point2<f64>,
pub shape: shape::Ball<f64>,
velocity: Vector2<f64>,
}
impl Ball {
fn new() -> Self {
Ball {
position: Point2::new(500., 50.),
shape: shape::Ball::new(5.),
velocity: Vector2::new(-5., 5.),
}
}
}
#[derive(Debug, Clone)]
pub struct Paddle {
pub position: Point2<f64>,
pub shape: Cuboid<f64>,
pub player_name: String,
state: PaddleState,
}
impl Paddle {
fn left() -> Self {
Paddle {
position: Point2::new(20., 50.),
shape: Cuboid::new(Vector2::new(10., 100.)),
player_name: String::new(),
state: PaddleState::Still,
}
}
fn right() -> Self {
Paddle {
position: Point2::new(770., 50.),
shape: Cuboid::new(Vector2::new(10., 100.)),
player_name: String::new(),
state: PaddleState::Still,
}
}
}
impl SimplePong {
pub fn new() -> Self {
SimplePong {
left_paddle: Paddle::left(),
right_paddle: Paddle::right(),
ball: Ball::new(),
server_ball: Ball::new(),
paused: true,
}
}
pub fn tick(&mut self) {
// info!("Tick: states {:?} {:?}", self.left_paddle.state, self.right_paddle.state);
let mov = match self.right_paddle.state {
PaddleState::Up => -8.,
PaddleState::Down => 8.,
PaddleState::Still => 0.,
};
self.right_paddle.position.y += mov;
let mov = match self.left_paddle.state {
PaddleState::Up => -8.,
PaddleState::Down => 8.,
PaddleState::Still => 0.,
};
self.left_paddle.position.y += mov;
if self.paused {
return;
}
self.ball.position += self.ball.velocity.clone();
if self.ball.position.x < 10. || self.ball.position.x > 790. {
// self.ball.velocity = Vector2::new(0., 0.);
self.ball.velocity.x *= -1.;
}
if self.ball.position.y < 10. || self.ball.position.y > 590. {
self.ball.velocity.y *= -1.;
}
self.server_ball.position += self.server_ball.velocity.clone();
// if self.server_ball.position.x < 10. || self.server_ball.position.x > 790. {
// // self.server_ball.velocity = Vector2::new(0., 0.);
// self.server_ball.velocity.x *= -1.;
// }
// if self.server_ball.position.y < 10. || self.server_ball.position.y > 590. {
// self.server_ball.velocity.y *= -1.;
// }
let ball_isometry = Isometry2::new(self.ball.position.clone().coords, nalgebra::zero());
let left_paddle_isometry =
Isometry2::new(self.left_paddle.position.clone().coords, nalgebra::zero());
let right_paddle_isometry =
Isometry2::new(self.right_paddle.position.clone().coords, nalgebra::zero());
let proximity = query::proximity(
&ball_isometry,
&self.ball.shape,
&left_paddle_isometry,
&self.left_paddle.shape,
0.,
);
if let Proximity::Intersecting = proximity {
self.ball.velocity.x *= -1.;
}
let proximity = query::proximity(
&ball_isometry,
&self.ball.shape,
&right_paddle_isometry,
&self.right_paddle.shape,
0.,
);
if let Proximity::Intersecting = proximity {
self.ball.velocity.x *= -1.;
}
}
pub fn update_state(&mut self, state: &GameState) {
self.left_paddle.position.y = state.left_paddle_y;
self.right_paddle.position.y = state.right_paddle_y;
self.left_paddle.player_name = state.left_player_name.clone();
self.left_paddle.state = state.left_paddle_state;
self.right_paddle.state = state.right_paddle_state;
self.right_paddle.player_name = state.right_player_name.clone();
self.server_ball.position = state.ball_position.clone();
self.server_ball.velocity = state.ball_velocity.clone();
self.ball.position = state.ball_position.clone();
self.ball.velocity = state.ball_velocity.clone();
self.paused = state.paused;
}
pub fn set_paddle_state(&mut self, left_paddle: bool, stop_moving: bool, up: bool) {
if left_paddle {
if stop_moving {
self.left_paddle.state = PaddleState::Still;
} else if up {
self.left_paddle.state = PaddleState::Up;
} else {
self.left_paddle.state = PaddleState::Down;
}
} else {
if stop_moving {
self.right_paddle.state = PaddleState::Still;
} else if up {
self.right_paddle.state = PaddleState::Up;
} else {
self.right_paddle.state = PaddleState::Down;
}
}
info!(
"Paddle states: {:?} {:?}",
self.left_paddle.state, self.right_paddle.state
);
}
pub fn get_drawables(&self) -> (Paddle, Paddle, Point2<f64>, Point2<f64>, bool) {
(
self.left_paddle.clone(), //todo investigate lifetime reference instead of clone
self.right_paddle.clone(),
self.ball.position.clone(),
self.server_ball.position.clone(),
self.paused,
)
}
}
|
use crate::helpers::{Fd, Shell};
use crate::lexer::Token::{self, *};
use crate::lexer::{
Action,
Expand::{self, *},
Op,
};
use nix::unistd::User;
use os_pipe::pipe;
use std::cell::RefCell;
use std::collections::HashMap;
use std::env;
use std::io::Write;
use std::iter::Peekable;
use std::process::exit;
use std::rc::Rc;
use crate::runner::Runner;
#[derive(Debug, PartialEq)]
pub enum Cmd {
Simple(Simple),
Pipeline(Box<Cmd>, Box<Cmd>),
And(Box<Cmd>, Box<Cmd>),
Or(Box<Cmd>, Box<Cmd>),
Not(Box<Cmd>),
Empty,
}
// Keeps track of io in one spot before it's put into a command
pub struct Io {
stdin: Rc<RefCell<Fd>>,
stdout: Rc<RefCell<Fd>>,
stderr: Rc<RefCell<Fd>>,
}
impl Io {
fn new() -> Io {
Io {
stdin: Rc::new(RefCell::new(Fd::Stdin)),
stdout: Rc::new(RefCell::new(Fd::Stdout)),
stderr: Rc::new(RefCell::new(Fd::Stderr)),
}
}
fn set_stdin(&mut self, fd: Rc<RefCell<Fd>>) {
self.stdin = fd;
}
fn set_stdout(&mut self, fd: Rc<RefCell<Fd>>) {
self.stdout = fd;
}
fn set_stderr(&mut self, fd: Rc<RefCell<Fd>>) {
self.stderr = fd;
}
}
// The most basic command - it, its arguments, and its redirections.
#[derive(Debug, PartialEq)]
pub struct Simple {
pub cmd: String,
pub args: Vec<String>,
pub env: Option<HashMap<String, String>>,
pub stdin: Rc<RefCell<Fd>>,
pub stdout: Rc<RefCell<Fd>>,
pub stderr: Rc<RefCell<Fd>>,
}
impl Simple {
fn new(cmd: String, args: Vec<String>, io: Io) -> Simple {
Simple {
cmd,
args,
env: None,
stdin: io.stdin,
stdout: io.stdout,
stderr: io.stderr,
}
}
fn add_env(&mut self, map: HashMap<String, String>) {
self.env = Some(map);
}
}
// The parser struct. Keeps track of current location in a peekable iter of tokens
pub struct Parser<I>
where
I: Iterator<Item = Token>
{
shell: Rc<RefCell<Shell>>,
lexer: Peekable<I>,
}
impl<I> Parser<I>
where
I: Iterator<Item = Token>
{
pub fn new(lexer: I, shell: Rc<RefCell<Shell>>) -> Parser<I> {
Parser {
shell,
lexer: lexer.peekable(),
}
}
pub fn get(&mut self) -> Result<Cmd, String> {
self.get_and()
}
pub fn get_and(&mut self) -> Result<Cmd, String> {
let mut node = self.get_pipe()?;
while let Some(Op(Op::And)) | Some(Op(Op::Or)) = self.lexer.peek() {
if let Some(Op(Op::And)) = self.lexer.next() {
node = Cmd::And(Box::new(node), Box::new(self.get_pipe()?));
} else {
node = Cmd::Or(Box::new(node), Box::new(self.get_pipe()?));
}
}
Ok(node)
}
pub fn get_pipe(&mut self) -> Result<Cmd, String> {
let mut node = self.get_simple()?;
while let Some(Op(Op::Pipe)) = self.lexer.peek() {
self.lexer.next();
node = Cmd::Pipeline(Box::new(node), Box::new(self.get_simple()?));
}
Ok(node)
}
pub fn get_simple(&mut self) -> Result<Cmd, String> {
if let Some(Op(Op::Bang)) = self.lexer.peek() {
self.lexer.next();
Ok(Cmd::Not(Box::new(self.get_simple()?)))
} else {
let mut result = Vec::new();
let mut io = Io::new();
let mut map = HashMap::new();
loop {
match self.lexer.peek() {
Some(Word(_)) => {
if let Some(Word(mut expansions)) = self.lexer.next() {
if let [Literal(_)] = &expansions[..] {
result.push(expansions.pop().unwrap().get_name())
} else {
let word = self.expand_word(expansions);
if !word.is_empty() {
result.push(word)
}
}
}
}
Some(Assign(_, _)) => {
if let Some(Assign(key, var)) = self.lexer.next() {
map.insert(key, self.expand_word(var));
}
}
Some(Op(Op::Less)) => {
self.lexer.next();
io.set_stdin(self.token_to_fd(&io)?);
}
Some(Op(Op::More)) => {
self.lexer.next();
io.set_stdout(self.token_to_fd(&io)?);
}
Some(Integer(_)) => {
if let Some(Integer(int)) = self.lexer.next() {
if let Some(Op(_)) = self.lexer.peek() {
self.lexer.next();
match int {
0 => io.set_stdin(self.token_to_fd(&io)?),
1 => io.set_stdout(self.token_to_fd(&io)?),
2 => io.set_stderr(self.token_to_fd(&io)?),
_ => todo!(),
}
} else {
result.push(int.to_string());
}
}
}
_ => break,
}
}
if result.is_empty() {
if map.is_empty() {
Err(String::from("rush: expected command but found none"))
} else {
map = map
.into_iter()
.filter_map(|(k, v)| {
if env::var_os(&k).is_some() {
env::set_var(k, v);
None
} else {
Some((k, v))
}
})
.collect();
self.shell.borrow_mut().vars.extend(map);
Ok(Cmd::Empty)
}
} else {
let mut cmd = Simple::new(result.remove(0), result, io);
if !map.is_empty() {
cmd.add_env(map);
}
Ok(Cmd::Simple(cmd))
}
}
}
fn expand_word(&mut self, expansions: Vec<Expand>) -> String {
let mut phrase = String::new();
for word in expansions {
match word {
Literal(s) => phrase.push_str(&s),
Tilde(word) => {
let s = self.expand_word(word);
if s.is_empty() || s.starts_with('/') {
phrase.push_str(&env::var("HOME").unwrap());
phrase.push_str(&s);
} else {
let mut strings = s.splitn(1, '/');
let name = strings.next().unwrap();
if let Some(user) = User::from_name(name).unwrap() {
phrase.push_str(user.dir.as_os_str().to_str().unwrap());
if let Some(path) = strings.next() {
phrase.push_str(path);
}
} else {
phrase.push('~');
phrase.push_str(name);
}
}
}
Var(s) => {
phrase.push_str(
&self.shell
.borrow()
.get_var(&s)
.unwrap_or_default()
);
}
Brace(key, action, word) => {
let val = self.shell.borrow().get_var(&key);
match action {
Action::UseDefault(null) => {
if let Some(s) = val {
if s == "" && null {
phrase.push_str(&self.expand_word(word))
} else {
phrase.push_str(&s)
}
} else {
phrase.push_str(&self.expand_word(word))
}
}
Action::AssignDefault(null) => {
if let Some(s) = val {
if s == "" && null {
let expanded = self.expand_word(word);
phrase.push_str(&expanded);
self.shell.borrow_mut().set_var(key, expanded);
} else {
phrase.push_str(&s)
}
} else {
let expanded = self.expand_word(word);
phrase.push_str(&expanded);
self.shell.borrow_mut().set_var(key, expanded);
}
}
Action::IndicateError(null) => {
if let Some(s) = val {
if s == "" && null {
let message = self.expand_word(word);
if message.is_empty() {
eprintln!("rush: {}: parameter null", key);
} else {
eprintln!("rush: {}: {}", key, message);
}
if !self.shell.borrow().is_interactive() {
exit(1);
}
} else {
phrase.push_str(&s)
}
} else {
let message = self.expand_word(word);
if message.is_empty() {
eprintln!("rush: {}: parameter not set", key);
} else {
eprintln!("rush: {}: {}", key, message);
}
if !self.shell.borrow().is_interactive() {
exit(1);
}
}
}
Action::UseAlternate(null) => {
if let Some(s) = val {
if s != "" || !null {
phrase.push_str(&self.expand_word(word))
}
}
}
Action::RmSmallestSuffix => todo!(),
Action::RmLargestSuffix => todo!(),
Action::RmSmallestPrefix => todo!(),
Action::RmLargestPrefix => todo!(),
Action::StringLength => todo!(),
}
}
Sub(e) => {
// FIXME: `$(ls something)`, commands with params don't work atm
// for some reason
let mut parser = Parser::new(vec!(Word(e)).into_iter(), Rc::clone(&self.shell));
// This setup here allows me to do a surprisingly easy subshell.
// Though subshells typically seem to inherit everything I'm keeping in my
// `shell` variable at the moment?
if let Ok(command) = parser.get() {
#[cfg(debug_assertions)] // Only include when not built with `--release` flag
println!("\u{001b}[33m{:#?}\u{001b}[0m", command);
let mut output = Runner::new(Rc::clone(&parser.shell)).execute(command, true).unwrap();
output = output.replace(char::is_whitespace, " ");
phrase.push_str(output.trim());
}
}
}
}
phrase
}
fn token_to_fd(&mut self, io: &Io) -> Result<Rc<RefCell<Fd>>, String> {
let error = String::from("rush: expected redirection location but found none");
if let Some(token) = self.lexer.next() {
match token {
Op(Op::Ampersand) => {
if let Some(Integer(i)) = self.lexer.next() {
Ok(Rc::clone(match i {
0 => &io.stdin,
1 => &io.stdout,
2 => &io.stderr,
_ => todo!(),
}))
} else {
Err(error)
}
}
Op(Op::More) => {
if let Some(Word(s)) = self.lexer.next() {
Ok(Rc::new(RefCell::new(Fd::FileNameAppend(
self.expand_word(s),
))))
} else {
Err(error)
}
}
Op(Op::Less) => {
if let Some(Word(s)) = self.lexer.next() {
let mut s = self.expand_word(s);
s = format!("{}\n", s);
let (reader, mut writer) = pipe().unwrap();
while let Some(input) = self.shell.borrow_mut().next_prompt("> ") {
if input == s {
break;
} else {
writer.write_all(input.as_bytes()).unwrap();
}
}
Ok(Rc::new(RefCell::new(Fd::PipeIn(reader))))
} else {
Err(error)
}
}
Word(s) => Ok(Rc::new(RefCell::new(Fd::FileName(self.expand_word(s))))),
Integer(i) => Ok(Rc::new(RefCell::new(Fd::FileName(i.to_string())))),
_ => Err(error),
}
} else {
Err(error)
}
}
}
// TODO: Tests for redirection
#[cfg(test)]
mod parser_tests {
use super::{Cmd, Io, Parser, Simple};
use crate::helpers::Shell;
use crate::lexer::Lexer;
use std::cell::RefCell;
use std::rc::Rc;
#[test]
fn test_and() {
let shell = Rc::new(RefCell::new(Shell::new(None)));
let lexer = Lexer::new("ls | grep cargo && pwd", Rc::clone(&shell));
let mut parser = Parser::new(lexer, Rc::clone(&shell));
let expected = Cmd::And(
Box::new(Cmd::Pipeline(
Box::new(Cmd::Simple(Simple::new(
String::from("ls"),
vec![],
Io::new(),
))),
Box::new(Cmd::Simple(Simple::new(
String::from("grep"),
vec![String::from("cargo")],
Io::new(),
))),
)),
Box::new(Cmd::Simple(Simple::new(
String::from("pwd"),
vec![],
Io::new(),
))),
);
assert_eq!(expected, parser.get().unwrap())
}
#[test]
fn test_pipes() {
let shell = Rc::new(RefCell::new(Shell::new(None)));
let lexer = Lexer::new("ls | grep cargo", Rc::clone(&shell));
let mut parser = Parser::new(lexer, Rc::clone(&shell));
let expected = Cmd::Pipeline(
Box::new(Cmd::Simple(Simple::new(
String::from("ls"),
vec![],
Io::new(),
))),
Box::new(Cmd::Simple(Simple::new(
String::from("grep"),
vec![String::from("cargo")],
Io::new(),
))),
);
assert_eq!(expected, parser.get().unwrap())
}
#[test]
fn test_simple() {
let shell = Rc::new(RefCell::new(Shell::new(None)));
let lexer = Lexer::new("ls -ltr", Rc::clone(&shell));
let mut parser = Parser::new(lexer, Rc::clone(&shell));
let expected = Cmd::Simple(Simple::new(
String::from("ls"),
vec![String::from("-ltr")],
Io::new(),
));
assert_eq!(expected, parser.get().unwrap())
}
}
|
use std::collections::HashMap;
use amethyst::assets::{AssetStorage, Handle, Loader};
use amethyst::ecs::World;
use amethyst::renderer::{
ImageFormat, SpriteRender, SpriteSheet,
SpriteSheetFormat, Texture};
use amethyst::prelude::WorldExt;
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub enum SpriteSheets {
Character,
Dungeon,
Mobs
}
#[derive(Copy, Clone)]
pub enum Sprite {
Player,
Blob,
Wall,
Floor,
Full
}
#[derive(Default)]
pub struct SpriteHandler {
sprite_sheets: HashMap<SpriteSheets, Handle<SpriteSheet>>
}
impl SpriteHandler {
pub fn add_sprite_sheet(&mut self, the_world: &mut World,
sheet: SpriteSheets,
file: &str, config: &str) {
let handle = load_sprite_sheet(the_world, file, config);
self.sprite_sheets.insert(sheet, handle);
}
pub fn get_sprite(&self, sprite: Sprite) -> SpriteRender {
match sprite {
Sprite::Player => {
SpriteRender {
sprite_sheet: self.sprite_sheets[&SpriteSheets::Character].clone(),
sprite_number: 1
}
},
Sprite::Blob => {
SpriteRender {
sprite_sheet: self.sprite_sheets[&SpriteSheets::Mobs].clone(),
sprite_number: 0
}
},
Sprite::Wall => {
SpriteRender {
sprite_sheet: self.sprite_sheets[&SpriteSheets::Dungeon].clone(),
sprite_number: 1
}
},
Sprite::Floor => {
SpriteRender {
sprite_sheet: self.sprite_sheets[&SpriteSheets::Dungeon].clone(),
sprite_number: 2
}
},
Sprite::Full => {
SpriteRender {
sprite_sheet: self.sprite_sheets[&SpriteSheets::Dungeon].clone(),
sprite_number: 0
}
}
}
}
}
fn load_sprite_sheet(world: &mut World, file: &str, config: &str)
-> Handle<SpriteSheet> {
let loader = world.read_resource::<Loader>();
let texture_handle = {
let texture_storage = world.read_resource::<AssetStorage<Texture>>();
loader.load(
file,
ImageFormat::default(),
(),
&texture_storage
)
};
let sprite_sheet_store = world.read_resource::<AssetStorage<SpriteSheet>>();
loader.load(
config,
SpriteSheetFormat(texture_handle),
(),
&sprite_sheet_store
)
}
|
use libc::{c_void, c_char};
use super::ObsData;
pub enum ObsSource {}
extern {
pub fn rust_obs_register_input_source(
id: *const c_char,
new: extern fn(settings: *mut ObsData, source: *mut ObsSource) -> *mut c_void,
width: unsafe extern fn(this: *mut c_void) -> u32,
height: unsafe extern fn(this: *mut c_void) -> u32,
render: unsafe extern fn(this: *mut c_void, effect: *mut super::Effect),
destroy: unsafe extern fn(this: *mut c_void),
);
}
|
//! This module contains basic methods to manipulate the contents of local directories.
//! All methods in this module represent cross-platform filesystem operations.
use std::fs;
use error::Error;
use operation::Operation;
use super::Result;
use super::exists as exists;
/// Recursively creates the directory indicated by the provided path if it
/// does not exist, otherwise it short circuits and returns immediately.
///
/// # Failures
/// Fails if the directory cannot be created for any reason.
pub fn create(path: &str) -> Result<()> {
if exists(path) { return Ok(()); }
match fs::create_dir_all(path) {
Ok(_) => {
debug!("Successfully created '{}'", path);
Ok(())
},
Err(error) => {
if exists(path) {
Ok(())
} else {
Err(Error::with_cause(&Operation::Create, path, error)) }
}
}
}
/// Idempotently deletes the file indicated by the provided path.
///
/// # Failures
/// Fails if the directory cannot be deleted for any reason.
pub fn delete(path: &str) -> Result<()> {
if !exists(path) { return Ok(()); }
match fs::remove_dir_all(path) {
Ok(_) => {
debug!("Successfully deleted '{}'", path);
Ok(())
},
Err(error) => {
if !exists(path) {
Ok(())
} else {
Err(Error::with_cause(&Operation::Delete, path, error))
}
}
}
}
|
use std::f32;
use std::f32::consts as math_consts;
use modulator::foc_modulator as foc;
use platform_traits::pwm_inverter as pwm;
use platform_traits::current_sensor as cs;
use platform_traits::rotor_position_sensor as encoder;
use platform_traits::blocking_delay as delay;
use foc_types::types as t;
use pid_controller::pid as pid;
use foc_math_utils::math_utils as utils;
#[derive(PartialEq)]
pub enum AlignedState {
NotAligned,
Aligned
}
#[derive(PartialEq)]
pub enum FocResult {
FocNotAligned,
FocInternalFault,
}
pub struct FocController <'a, E : encoder::RotorPositionSensor,
C : cs::CurrentSensor,
P : pwm::PWMInverter,
D : delay::BlockingDelay > {
/// Commands:
iq : t::Amperes,
id : t::Amperes,
iq_controller : pid::PidController,
id_controller : pid::PidController,
///Limits:
supply_voltage : t::Volts,
motor_pole_pairs : t::PolePairs,
///States:
aligned : AlignedState,
///Timestamp:
last_t : f32,
///Drivers:
position_sensor : &'a mut E,
phase_current_sensor: &'a C,
inverter : &'a mut P,
delay : &'a D,
}
impl <'a,E,C,P,D> FocController <'a, E,C,P,D>
where
E : encoder::RotorPositionSensor,
C : cs::CurrentSensor,
P : pwm::PWMInverter,
D : delay::BlockingDelay
{
pub fn new(encoder_driver : &'a mut E,
current_sensor_driver : & 'a C,
inverter_driver : & 'a mut P,
delay_driver : & 'a D,
voltage_supply : t::Volts,
pole_pairs : t::PolePairs) -> Self {
let i_settings = pid::PidControlSettings{
p_gain: 50.0,
i_gain: 0.05,
d_gain: 0.0,
out_max: voltage_supply.0,
out_min: -voltage_supply.0,
max_integrator_value: 40.0,
};
FocController {
id : t::Amperes(0.0),
iq : t::Amperes(0.0),
supply_voltage : voltage_supply,
position_sensor : encoder_driver,
phase_current_sensor : current_sensor_driver,
inverter : inverter_driver,
delay : delay_driver,
aligned : AlignedState::NotAligned,
iq_controller : pid::PidController::new(&i_settings),
id_controller : pid::PidController::new(&i_settings),
last_t : 0.0,
motor_pole_pairs : pole_pairs,
}
}
pub fn initialize_foc(&mut self, initial_time : f32) -> Result<(), FocResult>{
let align_command_q = t::VoltageQ(self.supply_voltage.0 * 0.1);
let align_command_d = t::VoltageD(0.0);
let zeroq_voltage = t::VoltageQ(0.0);
let zerod_voltage = t::VoltageD(0.0);
let mut phase_voltages = foc::modulate_dq_voltages(zeroq_voltage,
zerod_voltage,
t::RotorAngleRadians(0.0));
self.inverter.set_inverter_voltages(phase_voltages, self.supply_voltage);
self.delay.blocking_delay_ms(1000);
for i in 0 .. 5 {
let align_angle = math_consts::FRAC_PI_2 - ((2.0 * math_consts::PI) * i as f32 ) / 6.0;
let phase_voltages = foc::modulate_dq_voltages(align_command_q,
align_command_d,
utils::convert_to_electric_angle(
t::RotorAngleRadians(align_angle),
self.motor_pole_pairs));
self.inverter.set_inverter_voltages(phase_voltages, self.supply_voltage);
self.delay.blocking_delay_ms(250);
}
for i in 5 .. 0 {
let align_angle = math_consts::FRAC_PI_2 - ((2.0 * math_consts::PI) * i as f32 ) / 6.0;
let phase_voltages = foc::modulate_dq_voltages(align_command_q,
align_command_d,
utils::convert_to_electric_angle(
t::RotorAngleRadians(align_angle),
self.motor_pole_pairs));
self.inverter.set_inverter_voltages(phase_voltages, self.supply_voltage);
self.delay.blocking_delay_ms(150);
}
self.delay.blocking_delay_ms(2000);
self.position_sensor.set_count_to_zero();
self.delay.blocking_delay_ms(100);
phase_voltages = foc::modulate_dq_voltages(zeroq_voltage,
zerod_voltage,
t::RotorAngleRadians(0.0));
self.inverter.set_inverter_voltages(phase_voltages, self.supply_voltage);
self.delay.blocking_delay_ms(100);
self.aligned = AlignedState::Aligned;
self.last_t = initial_time;
Ok(())
}
pub fn set_target_current(&mut self, current : t::Amperes) -> Result<(), FocResult> {
if self.aligned != AlignedState::Aligned {
Err(FocResult::FocNotAligned)
} else {
self.iq = current;
Ok(())
}
}
pub fn get_rotor_position_ticks(&mut self) -> t::ShaftTicks {
self.position_sensor.read_counts()
}
pub fn get_rotor_sensor_cpr(&mut self) -> t::ShaftTicks {
self.position_sensor.get_cpr()
}
pub fn execute_foc_loop(&mut self, now : f32) -> Result<(), FocResult>{
if self.aligned != AlignedState::Aligned {
Err(FocResult::FocNotAligned)
} else {
let ia = self.phase_current_sensor.read_phase_current(cs::Phases::PhaseA);
let ib = self.phase_current_sensor.read_phase_current(cs::Phases::PhaseB);
let ic = self.phase_current_sensor.read_phase_current(cs::Phases::PhaseC);
let phase_currents = t::PhaseCurrents(ia.0, ib.0, ic.0);
let rotor_angle = self.position_sensor.read_rotor_position();
let dq_state = foc::get_dq_currents(phase_currents,
utils::convert_to_electric_angle(
rotor_angle,
self.motor_pole_pairs)
);
let vq_command = self.iq_controller.update(self.iq.0, dq_state.1, now - self.last_t);
let vd_command = self.id_controller.update(self.id.0, dq_state.0, now - self.last_t);
self.last_t = now;
let phase_voltages = foc::modulate_dq_voltages(t::VoltageQ(vq_command),
t::VoltageD(vd_command),
utils::convert_to_electric_angle(
rotor_angle,
self.motor_pole_pairs));
self.inverter.set_inverter_voltages(phase_voltages, self.supply_voltage);
Ok(())
}
}
}
|
use super::*;
//#[test]
fn show_circles() {
println!("CIRCLES ");
for (circle, span) in CIRCLES_SPAN.iter() {
println!("diameter: {}", circle.radius * 2.0);
println!();
println!("{}", span);
println!();
println!();
}
println!("QUARTER ARCS:");
for (diameter, (arc, span)) in FLATTENED_QUARTER_ARC_SPAN.iter() {
println!("diameter: {}", diameter.diameter);
println!();
println!("{}", span);
println!();
println!();
}
println!("HALF ARCS:");
for (diameter, (arc, span)) in FLATTENED_HALF_ARC_SPAN.iter() {
println!("diameter: {}", diameter.diameter);
println!();
println!("{}", span);
println!();
println!();
}
println!("THREE QUARTERS ARCS:");
for (diameter, (arc, span)) in FLATTENED_THREE_QUARTERS_ARC_SPAN.iter() {
println!("diameter: {}", diameter.diameter);
println!();
println!("{}", span);
println!();
println!();
}
panic!();
}
#[test]
fn test_circle1() {
let art = r#"
_.-'''''''-._
,' `.
/ \
. .
| |
| |
| |
\ /
`._ _.'
'-.......-'
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let groups: Vec<Contacts> = span1.into();
for (i, group) in groups.iter().enumerate() {
println!("group{}\n{}", i, group);
}
assert_eq!(11, groups.len());
}
#[test]
fn test_half_arc_span5_top() {
let art = r#"
___
,' `.
/ \
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_half_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 4.5);
}
#[test]
fn test_half_arc_span5_bottom() {
let art = r#"
\ /
`.___.'
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_half_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 4.5);
}
#[test]
fn test_half_arc_span5_left() {
let art = r#"
__
,'
/
\
`.__
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let result = endorse_half_arc_span(&span1);
assert!(result.is_some());
let (arc, _) = result.unwrap();
assert_eq!(arc.radius, 5.0);
}
#[test]
fn test_half_arc_span5_right() {
let art = r#"
__
`.
\
/
__.'
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let result = endorse_half_arc_span(&span1);
assert!(result.is_some());
let (arc, _) = result.unwrap();
assert_eq!(arc.radius, 5.0);
}
#[test]
fn test_arc9_top_right() {
let art = r#"
__
`.
\
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 5.0);
}
#[test]
fn test_arc5_top_right() {
let art = r#"
-.
)
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 2.5);
}
#[test]
fn test_arc5_top_left() {
let art = r#"
.-
(
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 2.5);
}
#[test]
fn test_arc5_bottom_left() {
let art = r#"
(
`-
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 2.5);
}
#[test]
fn test_arc5_bottom_right() {
let art = r#"
)
-'
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 2.5);
}
#[test]
fn test_arc20_top_right() {
let art = r#"
''''-._
`.
\
.
|
|
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 10.5); //also matched the arc21 radius and since larger it will matched it instead of arc20
}
#[test]
fn test_arc20_top_left() {
let art = r#"
_.-''''
,'
/
.
|
|
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 10.5); //also matched the arc21 radius and since larger it will matched it instead of arc20
}
#[test]
fn test_arc20_bottom_left() {
let art = r#"
|
|
\
`._
'-....
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 10.0);
}
#[test]
fn test_arc20_bottom_right() {
let art = r#"
|
|
/
_.'
....-'
"#;
let cell_buffer = CellBuffer::from(art);
let mut spans: Vec<Span> = cell_buffer.into();
assert_eq!(spans.len(), 1);
let span1 = spans.remove(0);
let (arc, _) = endorse_quarter_arc_span(&span1).unwrap();
assert_eq!(arc.radius, 10.0);
}
|
/// An enum to represent all characters in the VariationSelectorsSupplement block.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum VariationSelectorsSupplement {
/// \u{e0100}: '๓ '
VariationSelectorDash17,
/// \u{e0101}: '๓ '
VariationSelectorDash18,
/// \u{e0102}: '๓ '
VariationSelectorDash19,
/// \u{e0103}: '๓ '
VariationSelectorDash20,
/// \u{e0104}: '๓ '
VariationSelectorDash21,
/// \u{e0105}: '๓
'
VariationSelectorDash22,
/// \u{e0106}: '๓ '
VariationSelectorDash23,
/// \u{e0107}: '๓ '
VariationSelectorDash24,
/// \u{e0108}: '๓ '
VariationSelectorDash25,
/// \u{e0109}: '๓ '
VariationSelectorDash26,
/// \u{e010a}: '๓ '
VariationSelectorDash27,
/// \u{e010b}: '๓ '
VariationSelectorDash28,
/// \u{e010c}: '๓ '
VariationSelectorDash29,
/// \u{e010d}: '๓ '
VariationSelectorDash30,
/// \u{e010e}: '๓ '
VariationSelectorDash31,
/// \u{e010f}: '๓ '
VariationSelectorDash32,
/// \u{e0110}: '๓ '
VariationSelectorDash33,
/// \u{e0111}: '๓ '
VariationSelectorDash34,
/// \u{e0112}: '๓ '
VariationSelectorDash35,
/// \u{e0113}: '๓ '
VariationSelectorDash36,
/// \u{e0114}: '๓ '
VariationSelectorDash37,
/// \u{e0115}: '๓ '
VariationSelectorDash38,
/// \u{e0116}: '๓ '
VariationSelectorDash39,
/// \u{e0117}: '๓ '
VariationSelectorDash40,
/// \u{e0118}: '๓ '
VariationSelectorDash41,
/// \u{e0119}: '๓ '
VariationSelectorDash42,
/// \u{e011a}: '๓ '
VariationSelectorDash43,
/// \u{e011b}: '๓ '
VariationSelectorDash44,
/// \u{e011c}: '๓ '
VariationSelectorDash45,
/// \u{e011d}: '๓ '
VariationSelectorDash46,
/// \u{e011e}: '๓ '
VariationSelectorDash47,
/// \u{e011f}: '๓ '
VariationSelectorDash48,
/// \u{e0120}: '๓ '
VariationSelectorDash49,
/// \u{e0121}: '๓ ก'
VariationSelectorDash50,
/// \u{e0122}: '๓ ข'
VariationSelectorDash51,
/// \u{e0123}: '๓ ฃ'
VariationSelectorDash52,
/// \u{e0124}: '๓ ค'
VariationSelectorDash53,
/// \u{e0125}: '๓ ฅ'
VariationSelectorDash54,
/// \u{e0126}: '๓ ฆ'
VariationSelectorDash55,
/// \u{e0127}: '๓ ง'
VariationSelectorDash56,
/// \u{e0128}: '๓ จ'
VariationSelectorDash57,
/// \u{e0129}: '๓ ฉ'
VariationSelectorDash58,
/// \u{e012a}: '๓ ช'
VariationSelectorDash59,
/// \u{e012b}: '๓ ซ'
VariationSelectorDash60,
/// \u{e012c}: '๓ ฌ'
VariationSelectorDash61,
/// \u{e012d}: '๓ ญ'
VariationSelectorDash62,
/// \u{e012e}: '๓ ฎ'
VariationSelectorDash63,
/// \u{e012f}: '๓ ฏ'
VariationSelectorDash64,
/// \u{e0130}: '๓ ฐ'
VariationSelectorDash65,
/// \u{e0131}: '๓ ฑ'
VariationSelectorDash66,
/// \u{e0132}: '๓ ฒ'
VariationSelectorDash67,
/// \u{e0133}: '๓ ณ'
VariationSelectorDash68,
/// \u{e0134}: '๓ ด'
VariationSelectorDash69,
/// \u{e0135}: '๓ ต'
VariationSelectorDash70,
/// \u{e0136}: '๓ ถ'
VariationSelectorDash71,
/// \u{e0137}: '๓ ท'
VariationSelectorDash72,
/// \u{e0138}: '๓ ธ'
VariationSelectorDash73,
/// \u{e0139}: '๓ น'
VariationSelectorDash74,
/// \u{e013a}: '๓ บ'
VariationSelectorDash75,
/// \u{e013b}: '๓ ป'
VariationSelectorDash76,
/// \u{e013c}: '๓ ผ'
VariationSelectorDash77,
/// \u{e013d}: '๓ ฝ'
VariationSelectorDash78,
/// \u{e013e}: '๓ พ'
VariationSelectorDash79,
/// \u{e013f}: '๓ ฟ'
VariationSelectorDash80,
/// \u{e0140}: '๓
'
VariationSelectorDash81,
/// \u{e0141}: '๓
'
VariationSelectorDash82,
/// \u{e0142}: '๓
'
VariationSelectorDash83,
/// \u{e0143}: '๓
'
VariationSelectorDash84,
/// \u{e0144}: '๓
'
VariationSelectorDash85,
/// \u{e0145}: '๓
'
VariationSelectorDash86,
/// \u{e0146}: '๓
'
VariationSelectorDash87,
/// \u{e0147}: '๓
'
VariationSelectorDash88,
/// \u{e0148}: '๓
'
VariationSelectorDash89,
/// \u{e0149}: '๓
'
VariationSelectorDash90,
/// \u{e014a}: '๓
'
VariationSelectorDash91,
/// \u{e014b}: '๓
'
VariationSelectorDash92,
/// \u{e014c}: '๓
'
VariationSelectorDash93,
/// \u{e014d}: '๓
'
VariationSelectorDash94,
/// \u{e014e}: '๓
'
VariationSelectorDash95,
/// \u{e014f}: '๓
'
VariationSelectorDash96,
/// \u{e0150}: '๓
'
VariationSelectorDash97,
/// \u{e0151}: '๓
'
VariationSelectorDash98,
/// \u{e0152}: '๓
'
VariationSelectorDash99,
/// \u{e0153}: '๓
'
VariationSelectorDash100,
/// \u{e0154}: '๓
'
VariationSelectorDash101,
/// \u{e0155}: '๓
'
VariationSelectorDash102,
/// \u{e0156}: '๓
'
VariationSelectorDash103,
/// \u{e0157}: '๓
'
VariationSelectorDash104,
/// \u{e0158}: '๓
'
VariationSelectorDash105,
/// \u{e0159}: '๓
'
VariationSelectorDash106,
/// \u{e015a}: '๓
'
VariationSelectorDash107,
/// \u{e015b}: '๓
'
VariationSelectorDash108,
/// \u{e015c}: '๓
'
VariationSelectorDash109,
/// \u{e015d}: '๓
'
VariationSelectorDash110,
/// \u{e015e}: '๓
'
VariationSelectorDash111,
/// \u{e015f}: '๓
'
VariationSelectorDash112,
/// \u{e0160}: '๓
'
VariationSelectorDash113,
/// \u{e0161}: '๓
ก'
VariationSelectorDash114,
/// \u{e0162}: '๓
ข'
VariationSelectorDash115,
/// \u{e0163}: '๓
ฃ'
VariationSelectorDash116,
/// \u{e0164}: '๓
ค'
VariationSelectorDash117,
/// \u{e0165}: '๓
ฅ'
VariationSelectorDash118,
/// \u{e0166}: '๓
ฆ'
VariationSelectorDash119,
/// \u{e0167}: '๓
ง'
VariationSelectorDash120,
/// \u{e0168}: '๓
จ'
VariationSelectorDash121,
/// \u{e0169}: '๓
ฉ'
VariationSelectorDash122,
/// \u{e016a}: '๓
ช'
VariationSelectorDash123,
/// \u{e016b}: '๓
ซ'
VariationSelectorDash124,
/// \u{e016c}: '๓
ฌ'
VariationSelectorDash125,
/// \u{e016d}: '๓
ญ'
VariationSelectorDash126,
/// \u{e016e}: '๓
ฎ'
VariationSelectorDash127,
/// \u{e016f}: '๓
ฏ'
VariationSelectorDash128,
/// \u{e0170}: '๓
ฐ'
VariationSelectorDash129,
/// \u{e0171}: '๓
ฑ'
VariationSelectorDash130,
/// \u{e0172}: '๓
ฒ'
VariationSelectorDash131,
/// \u{e0173}: '๓
ณ'
VariationSelectorDash132,
/// \u{e0174}: '๓
ด'
VariationSelectorDash133,
/// \u{e0175}: '๓
ต'
VariationSelectorDash134,
/// \u{e0176}: '๓
ถ'
VariationSelectorDash135,
/// \u{e0177}: '๓
ท'
VariationSelectorDash136,
/// \u{e0178}: '๓
ธ'
VariationSelectorDash137,
/// \u{e0179}: '๓
น'
VariationSelectorDash138,
/// \u{e017a}: '๓
บ'
VariationSelectorDash139,
/// \u{e017b}: '๓
ป'
VariationSelectorDash140,
/// \u{e017c}: '๓
ผ'
VariationSelectorDash141,
/// \u{e017d}: '๓
ฝ'
VariationSelectorDash142,
/// \u{e017e}: '๓
พ'
VariationSelectorDash143,
/// \u{e017f}: '๓
ฟ'
VariationSelectorDash144,
/// \u{e0180}: '๓ '
VariationSelectorDash145,
/// \u{e0181}: '๓ '
VariationSelectorDash146,
/// \u{e0182}: '๓ '
VariationSelectorDash147,
/// \u{e0183}: '๓ '
VariationSelectorDash148,
/// \u{e0184}: '๓ '
VariationSelectorDash149,
/// \u{e0185}: '๓
'
VariationSelectorDash150,
/// \u{e0186}: '๓ '
VariationSelectorDash151,
/// \u{e0187}: '๓ '
VariationSelectorDash152,
/// \u{e0188}: '๓ '
VariationSelectorDash153,
/// \u{e0189}: '๓ '
VariationSelectorDash154,
/// \u{e018a}: '๓ '
VariationSelectorDash155,
/// \u{e018b}: '๓ '
VariationSelectorDash156,
/// \u{e018c}: '๓ '
VariationSelectorDash157,
/// \u{e018d}: '๓ '
VariationSelectorDash158,
/// \u{e018e}: '๓ '
VariationSelectorDash159,
/// \u{e018f}: '๓ '
VariationSelectorDash160,
/// \u{e0190}: '๓ '
VariationSelectorDash161,
/// \u{e0191}: '๓ '
VariationSelectorDash162,
/// \u{e0192}: '๓ '
VariationSelectorDash163,
/// \u{e0193}: '๓ '
VariationSelectorDash164,
/// \u{e0194}: '๓ '
VariationSelectorDash165,
/// \u{e0195}: '๓ '
VariationSelectorDash166,
/// \u{e0196}: '๓ '
VariationSelectorDash167,
/// \u{e0197}: '๓ '
VariationSelectorDash168,
/// \u{e0198}: '๓ '
VariationSelectorDash169,
/// \u{e0199}: '๓ '
VariationSelectorDash170,
/// \u{e019a}: '๓ '
VariationSelectorDash171,
/// \u{e019b}: '๓ '
VariationSelectorDash172,
/// \u{e019c}: '๓ '
VariationSelectorDash173,
/// \u{e019d}: '๓ '
VariationSelectorDash174,
/// \u{e019e}: '๓ '
VariationSelectorDash175,
/// \u{e019f}: '๓ '
VariationSelectorDash176,
/// \u{e01a0}: '๓ '
VariationSelectorDash177,
/// \u{e01a1}: '๓ ก'
VariationSelectorDash178,
/// \u{e01a2}: '๓ ข'
VariationSelectorDash179,
/// \u{e01a3}: '๓ ฃ'
VariationSelectorDash180,
/// \u{e01a4}: '๓ ค'
VariationSelectorDash181,
/// \u{e01a5}: '๓ ฅ'
VariationSelectorDash182,
/// \u{e01a6}: '๓ ฆ'
VariationSelectorDash183,
/// \u{e01a7}: '๓ ง'
VariationSelectorDash184,
/// \u{e01a8}: '๓ จ'
VariationSelectorDash185,
/// \u{e01a9}: '๓ ฉ'
VariationSelectorDash186,
/// \u{e01aa}: '๓ ช'
VariationSelectorDash187,
/// \u{e01ab}: '๓ ซ'
VariationSelectorDash188,
/// \u{e01ac}: '๓ ฌ'
VariationSelectorDash189,
/// \u{e01ad}: '๓ ญ'
VariationSelectorDash190,
/// \u{e01ae}: '๓ ฎ'
VariationSelectorDash191,
/// \u{e01af}: '๓ ฏ'
VariationSelectorDash192,
/// \u{e01b0}: '๓ ฐ'
VariationSelectorDash193,
/// \u{e01b1}: '๓ ฑ'
VariationSelectorDash194,
/// \u{e01b2}: '๓ ฒ'
VariationSelectorDash195,
/// \u{e01b3}: '๓ ณ'
VariationSelectorDash196,
/// \u{e01b4}: '๓ ด'
VariationSelectorDash197,
/// \u{e01b5}: '๓ ต'
VariationSelectorDash198,
/// \u{e01b6}: '๓ ถ'
VariationSelectorDash199,
/// \u{e01b7}: '๓ ท'
VariationSelectorDash200,
/// \u{e01b8}: '๓ ธ'
VariationSelectorDash201,
/// \u{e01b9}: '๓ น'
VariationSelectorDash202,
/// \u{e01ba}: '๓ บ'
VariationSelectorDash203,
/// \u{e01bb}: '๓ ป'
VariationSelectorDash204,
/// \u{e01bc}: '๓ ผ'
VariationSelectorDash205,
/// \u{e01bd}: '๓ ฝ'
VariationSelectorDash206,
/// \u{e01be}: '๓ พ'
VariationSelectorDash207,
/// \u{e01bf}: '๓ ฟ'
VariationSelectorDash208,
/// \u{e01c0}: '๓ '
VariationSelectorDash209,
/// \u{e01c1}: '๓ '
VariationSelectorDash210,
/// \u{e01c2}: '๓ '
VariationSelectorDash211,
/// \u{e01c3}: '๓ '
VariationSelectorDash212,
/// \u{e01c4}: '๓ '
VariationSelectorDash213,
/// \u{e01c5}: '๓
'
VariationSelectorDash214,
/// \u{e01c6}: '๓ '
VariationSelectorDash215,
/// \u{e01c7}: '๓ '
VariationSelectorDash216,
/// \u{e01c8}: '๓ '
VariationSelectorDash217,
/// \u{e01c9}: '๓ '
VariationSelectorDash218,
/// \u{e01ca}: '๓ '
VariationSelectorDash219,
/// \u{e01cb}: '๓ '
VariationSelectorDash220,
/// \u{e01cc}: '๓ '
VariationSelectorDash221,
/// \u{e01cd}: '๓ '
VariationSelectorDash222,
/// \u{e01ce}: '๓ '
VariationSelectorDash223,
/// \u{e01cf}: '๓ '
VariationSelectorDash224,
/// \u{e01d0}: '๓ '
VariationSelectorDash225,
/// \u{e01d1}: '๓ '
VariationSelectorDash226,
/// \u{e01d2}: '๓ '
VariationSelectorDash227,
/// \u{e01d3}: '๓ '
VariationSelectorDash228,
/// \u{e01d4}: '๓ '
VariationSelectorDash229,
/// \u{e01d5}: '๓ '
VariationSelectorDash230,
/// \u{e01d6}: '๓ '
VariationSelectorDash231,
/// \u{e01d7}: '๓ '
VariationSelectorDash232,
/// \u{e01d8}: '๓ '
VariationSelectorDash233,
/// \u{e01d9}: '๓ '
VariationSelectorDash234,
/// \u{e01da}: '๓ '
VariationSelectorDash235,
/// \u{e01db}: '๓ '
VariationSelectorDash236,
/// \u{e01dc}: '๓ '
VariationSelectorDash237,
/// \u{e01dd}: '๓ '
VariationSelectorDash238,
/// \u{e01de}: '๓ '
VariationSelectorDash239,
/// \u{e01df}: '๓ '
VariationSelectorDash240,
/// \u{e01e0}: '๓ '
VariationSelectorDash241,
/// \u{e01e1}: '๓ ก'
VariationSelectorDash242,
/// \u{e01e2}: '๓ ข'
VariationSelectorDash243,
/// \u{e01e3}: '๓ ฃ'
VariationSelectorDash244,
/// \u{e01e4}: '๓ ค'
VariationSelectorDash245,
/// \u{e01e5}: '๓ ฅ'
VariationSelectorDash246,
/// \u{e01e6}: '๓ ฆ'
VariationSelectorDash247,
/// \u{e01e7}: '๓ ง'
VariationSelectorDash248,
/// \u{e01e8}: '๓ จ'
VariationSelectorDash249,
/// \u{e01e9}: '๓ ฉ'
VariationSelectorDash250,
/// \u{e01ea}: '๓ ช'
VariationSelectorDash251,
/// \u{e01eb}: '๓ ซ'
VariationSelectorDash252,
/// \u{e01ec}: '๓ ฌ'
VariationSelectorDash253,
/// \u{e01ed}: '๓ ญ'
VariationSelectorDash254,
/// \u{e01ee}: '๓ ฎ'
VariationSelectorDash255,
}
impl Into<char> for VariationSelectorsSupplement {
fn into(self) -> char {
match self {
VariationSelectorsSupplement::VariationSelectorDash17 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash18 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash19 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash20 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash21 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash22 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash23 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash24 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash25 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash26 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash27 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash28 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash29 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash30 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash31 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash32 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash33 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash34 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash35 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash36 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash37 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash38 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash39 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash40 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash41 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash42 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash43 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash44 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash45 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash46 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash47 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash48 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash49 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash50 => '๓ ก',
VariationSelectorsSupplement::VariationSelectorDash51 => '๓ ข',
VariationSelectorsSupplement::VariationSelectorDash52 => '๓ ฃ',
VariationSelectorsSupplement::VariationSelectorDash53 => '๓ ค',
VariationSelectorsSupplement::VariationSelectorDash54 => '๓ ฅ',
VariationSelectorsSupplement::VariationSelectorDash55 => '๓ ฆ',
VariationSelectorsSupplement::VariationSelectorDash56 => '๓ ง',
VariationSelectorsSupplement::VariationSelectorDash57 => '๓ จ',
VariationSelectorsSupplement::VariationSelectorDash58 => '๓ ฉ',
VariationSelectorsSupplement::VariationSelectorDash59 => '๓ ช',
VariationSelectorsSupplement::VariationSelectorDash60 => '๓ ซ',
VariationSelectorsSupplement::VariationSelectorDash61 => '๓ ฌ',
VariationSelectorsSupplement::VariationSelectorDash62 => '๓ ญ',
VariationSelectorsSupplement::VariationSelectorDash63 => '๓ ฎ',
VariationSelectorsSupplement::VariationSelectorDash64 => '๓ ฏ',
VariationSelectorsSupplement::VariationSelectorDash65 => '๓ ฐ',
VariationSelectorsSupplement::VariationSelectorDash66 => '๓ ฑ',
VariationSelectorsSupplement::VariationSelectorDash67 => '๓ ฒ',
VariationSelectorsSupplement::VariationSelectorDash68 => '๓ ณ',
VariationSelectorsSupplement::VariationSelectorDash69 => '๓ ด',
VariationSelectorsSupplement::VariationSelectorDash70 => '๓ ต',
VariationSelectorsSupplement::VariationSelectorDash71 => '๓ ถ',
VariationSelectorsSupplement::VariationSelectorDash72 => '๓ ท',
VariationSelectorsSupplement::VariationSelectorDash73 => '๓ ธ',
VariationSelectorsSupplement::VariationSelectorDash74 => '๓ น',
VariationSelectorsSupplement::VariationSelectorDash75 => '๓ บ',
VariationSelectorsSupplement::VariationSelectorDash76 => '๓ ป',
VariationSelectorsSupplement::VariationSelectorDash77 => '๓ ผ',
VariationSelectorsSupplement::VariationSelectorDash78 => '๓ ฝ',
VariationSelectorsSupplement::VariationSelectorDash79 => '๓ พ',
VariationSelectorsSupplement::VariationSelectorDash80 => '๓ ฟ',
VariationSelectorsSupplement::VariationSelectorDash81 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash82 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash83 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash84 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash85 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash86 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash87 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash88 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash89 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash90 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash91 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash92 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash93 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash94 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash95 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash96 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash97 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash98 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash99 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash100 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash101 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash102 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash103 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash104 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash105 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash106 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash107 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash108 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash109 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash110 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash111 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash112 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash113 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash114 => '๓
ก',
VariationSelectorsSupplement::VariationSelectorDash115 => '๓
ข',
VariationSelectorsSupplement::VariationSelectorDash116 => '๓
ฃ',
VariationSelectorsSupplement::VariationSelectorDash117 => '๓
ค',
VariationSelectorsSupplement::VariationSelectorDash118 => '๓
ฅ',
VariationSelectorsSupplement::VariationSelectorDash119 => '๓
ฆ',
VariationSelectorsSupplement::VariationSelectorDash120 => '๓
ง',
VariationSelectorsSupplement::VariationSelectorDash121 => '๓
จ',
VariationSelectorsSupplement::VariationSelectorDash122 => '๓
ฉ',
VariationSelectorsSupplement::VariationSelectorDash123 => '๓
ช',
VariationSelectorsSupplement::VariationSelectorDash124 => '๓
ซ',
VariationSelectorsSupplement::VariationSelectorDash125 => '๓
ฌ',
VariationSelectorsSupplement::VariationSelectorDash126 => '๓
ญ',
VariationSelectorsSupplement::VariationSelectorDash127 => '๓
ฎ',
VariationSelectorsSupplement::VariationSelectorDash128 => '๓
ฏ',
VariationSelectorsSupplement::VariationSelectorDash129 => '๓
ฐ',
VariationSelectorsSupplement::VariationSelectorDash130 => '๓
ฑ',
VariationSelectorsSupplement::VariationSelectorDash131 => '๓
ฒ',
VariationSelectorsSupplement::VariationSelectorDash132 => '๓
ณ',
VariationSelectorsSupplement::VariationSelectorDash133 => '๓
ด',
VariationSelectorsSupplement::VariationSelectorDash134 => '๓
ต',
VariationSelectorsSupplement::VariationSelectorDash135 => '๓
ถ',
VariationSelectorsSupplement::VariationSelectorDash136 => '๓
ท',
VariationSelectorsSupplement::VariationSelectorDash137 => '๓
ธ',
VariationSelectorsSupplement::VariationSelectorDash138 => '๓
น',
VariationSelectorsSupplement::VariationSelectorDash139 => '๓
บ',
VariationSelectorsSupplement::VariationSelectorDash140 => '๓
ป',
VariationSelectorsSupplement::VariationSelectorDash141 => '๓
ผ',
VariationSelectorsSupplement::VariationSelectorDash142 => '๓
ฝ',
VariationSelectorsSupplement::VariationSelectorDash143 => '๓
พ',
VariationSelectorsSupplement::VariationSelectorDash144 => '๓
ฟ',
VariationSelectorsSupplement::VariationSelectorDash145 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash146 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash147 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash148 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash149 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash150 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash151 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash152 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash153 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash154 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash155 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash156 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash157 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash158 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash159 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash160 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash161 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash162 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash163 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash164 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash165 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash166 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash167 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash168 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash169 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash170 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash171 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash172 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash173 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash174 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash175 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash176 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash177 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash178 => '๓ ก',
VariationSelectorsSupplement::VariationSelectorDash179 => '๓ ข',
VariationSelectorsSupplement::VariationSelectorDash180 => '๓ ฃ',
VariationSelectorsSupplement::VariationSelectorDash181 => '๓ ค',
VariationSelectorsSupplement::VariationSelectorDash182 => '๓ ฅ',
VariationSelectorsSupplement::VariationSelectorDash183 => '๓ ฆ',
VariationSelectorsSupplement::VariationSelectorDash184 => '๓ ง',
VariationSelectorsSupplement::VariationSelectorDash185 => '๓ จ',
VariationSelectorsSupplement::VariationSelectorDash186 => '๓ ฉ',
VariationSelectorsSupplement::VariationSelectorDash187 => '๓ ช',
VariationSelectorsSupplement::VariationSelectorDash188 => '๓ ซ',
VariationSelectorsSupplement::VariationSelectorDash189 => '๓ ฌ',
VariationSelectorsSupplement::VariationSelectorDash190 => '๓ ญ',
VariationSelectorsSupplement::VariationSelectorDash191 => '๓ ฎ',
VariationSelectorsSupplement::VariationSelectorDash192 => '๓ ฏ',
VariationSelectorsSupplement::VariationSelectorDash193 => '๓ ฐ',
VariationSelectorsSupplement::VariationSelectorDash194 => '๓ ฑ',
VariationSelectorsSupplement::VariationSelectorDash195 => '๓ ฒ',
VariationSelectorsSupplement::VariationSelectorDash196 => '๓ ณ',
VariationSelectorsSupplement::VariationSelectorDash197 => '๓ ด',
VariationSelectorsSupplement::VariationSelectorDash198 => '๓ ต',
VariationSelectorsSupplement::VariationSelectorDash199 => '๓ ถ',
VariationSelectorsSupplement::VariationSelectorDash200 => '๓ ท',
VariationSelectorsSupplement::VariationSelectorDash201 => '๓ ธ',
VariationSelectorsSupplement::VariationSelectorDash202 => '๓ น',
VariationSelectorsSupplement::VariationSelectorDash203 => '๓ บ',
VariationSelectorsSupplement::VariationSelectorDash204 => '๓ ป',
VariationSelectorsSupplement::VariationSelectorDash205 => '๓ ผ',
VariationSelectorsSupplement::VariationSelectorDash206 => '๓ ฝ',
VariationSelectorsSupplement::VariationSelectorDash207 => '๓ พ',
VariationSelectorsSupplement::VariationSelectorDash208 => '๓ ฟ',
VariationSelectorsSupplement::VariationSelectorDash209 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash210 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash211 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash212 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash213 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash214 => '๓
',
VariationSelectorsSupplement::VariationSelectorDash215 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash216 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash217 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash218 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash219 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash220 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash221 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash222 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash223 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash224 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash225 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash226 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash227 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash228 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash229 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash230 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash231 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash232 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash233 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash234 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash235 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash236 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash237 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash238 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash239 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash240 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash241 => '๓ ',
VariationSelectorsSupplement::VariationSelectorDash242 => '๓ ก',
VariationSelectorsSupplement::VariationSelectorDash243 => '๓ ข',
VariationSelectorsSupplement::VariationSelectorDash244 => '๓ ฃ',
VariationSelectorsSupplement::VariationSelectorDash245 => '๓ ค',
VariationSelectorsSupplement::VariationSelectorDash246 => '๓ ฅ',
VariationSelectorsSupplement::VariationSelectorDash247 => '๓ ฆ',
VariationSelectorsSupplement::VariationSelectorDash248 => '๓ ง',
VariationSelectorsSupplement::VariationSelectorDash249 => '๓ จ',
VariationSelectorsSupplement::VariationSelectorDash250 => '๓ ฉ',
VariationSelectorsSupplement::VariationSelectorDash251 => '๓ ช',
VariationSelectorsSupplement::VariationSelectorDash252 => '๓ ซ',
VariationSelectorsSupplement::VariationSelectorDash253 => '๓ ฌ',
VariationSelectorsSupplement::VariationSelectorDash254 => '๓ ญ',
VariationSelectorsSupplement::VariationSelectorDash255 => '๓ ฎ',
}
}
}
impl std::convert::TryFrom<char> for VariationSelectorsSupplement {
type Error = ();
fn try_from(c: char) -> Result<Self, Self::Error> {
match c {
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash17),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash18),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash19),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash20),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash21),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash22),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash23),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash24),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash25),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash26),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash27),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash28),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash29),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash30),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash31),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash32),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash33),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash34),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash35),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash36),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash37),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash38),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash39),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash40),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash41),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash42),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash43),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash44),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash45),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash46),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash47),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash48),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash49),
'๓ ก' => Ok(VariationSelectorsSupplement::VariationSelectorDash50),
'๓ ข' => Ok(VariationSelectorsSupplement::VariationSelectorDash51),
'๓ ฃ' => Ok(VariationSelectorsSupplement::VariationSelectorDash52),
'๓ ค' => Ok(VariationSelectorsSupplement::VariationSelectorDash53),
'๓ ฅ' => Ok(VariationSelectorsSupplement::VariationSelectorDash54),
'๓ ฆ' => Ok(VariationSelectorsSupplement::VariationSelectorDash55),
'๓ ง' => Ok(VariationSelectorsSupplement::VariationSelectorDash56),
'๓ จ' => Ok(VariationSelectorsSupplement::VariationSelectorDash57),
'๓ ฉ' => Ok(VariationSelectorsSupplement::VariationSelectorDash58),
'๓ ช' => Ok(VariationSelectorsSupplement::VariationSelectorDash59),
'๓ ซ' => Ok(VariationSelectorsSupplement::VariationSelectorDash60),
'๓ ฌ' => Ok(VariationSelectorsSupplement::VariationSelectorDash61),
'๓ ญ' => Ok(VariationSelectorsSupplement::VariationSelectorDash62),
'๓ ฎ' => Ok(VariationSelectorsSupplement::VariationSelectorDash63),
'๓ ฏ' => Ok(VariationSelectorsSupplement::VariationSelectorDash64),
'๓ ฐ' => Ok(VariationSelectorsSupplement::VariationSelectorDash65),
'๓ ฑ' => Ok(VariationSelectorsSupplement::VariationSelectorDash66),
'๓ ฒ' => Ok(VariationSelectorsSupplement::VariationSelectorDash67),
'๓ ณ' => Ok(VariationSelectorsSupplement::VariationSelectorDash68),
'๓ ด' => Ok(VariationSelectorsSupplement::VariationSelectorDash69),
'๓ ต' => Ok(VariationSelectorsSupplement::VariationSelectorDash70),
'๓ ถ' => Ok(VariationSelectorsSupplement::VariationSelectorDash71),
'๓ ท' => Ok(VariationSelectorsSupplement::VariationSelectorDash72),
'๓ ธ' => Ok(VariationSelectorsSupplement::VariationSelectorDash73),
'๓ น' => Ok(VariationSelectorsSupplement::VariationSelectorDash74),
'๓ บ' => Ok(VariationSelectorsSupplement::VariationSelectorDash75),
'๓ ป' => Ok(VariationSelectorsSupplement::VariationSelectorDash76),
'๓ ผ' => Ok(VariationSelectorsSupplement::VariationSelectorDash77),
'๓ ฝ' => Ok(VariationSelectorsSupplement::VariationSelectorDash78),
'๓ พ' => Ok(VariationSelectorsSupplement::VariationSelectorDash79),
'๓ ฟ' => Ok(VariationSelectorsSupplement::VariationSelectorDash80),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash81),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash82),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash83),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash84),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash85),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash86),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash87),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash88),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash89),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash90),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash91),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash92),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash93),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash94),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash95),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash96),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash97),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash98),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash99),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash100),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash101),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash102),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash103),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash104),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash105),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash106),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash107),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash108),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash109),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash110),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash111),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash112),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash113),
'๓
ก' => Ok(VariationSelectorsSupplement::VariationSelectorDash114),
'๓
ข' => Ok(VariationSelectorsSupplement::VariationSelectorDash115),
'๓
ฃ' => Ok(VariationSelectorsSupplement::VariationSelectorDash116),
'๓
ค' => Ok(VariationSelectorsSupplement::VariationSelectorDash117),
'๓
ฅ' => Ok(VariationSelectorsSupplement::VariationSelectorDash118),
'๓
ฆ' => Ok(VariationSelectorsSupplement::VariationSelectorDash119),
'๓
ง' => Ok(VariationSelectorsSupplement::VariationSelectorDash120),
'๓
จ' => Ok(VariationSelectorsSupplement::VariationSelectorDash121),
'๓
ฉ' => Ok(VariationSelectorsSupplement::VariationSelectorDash122),
'๓
ช' => Ok(VariationSelectorsSupplement::VariationSelectorDash123),
'๓
ซ' => Ok(VariationSelectorsSupplement::VariationSelectorDash124),
'๓
ฌ' => Ok(VariationSelectorsSupplement::VariationSelectorDash125),
'๓
ญ' => Ok(VariationSelectorsSupplement::VariationSelectorDash126),
'๓
ฎ' => Ok(VariationSelectorsSupplement::VariationSelectorDash127),
'๓
ฏ' => Ok(VariationSelectorsSupplement::VariationSelectorDash128),
'๓
ฐ' => Ok(VariationSelectorsSupplement::VariationSelectorDash129),
'๓
ฑ' => Ok(VariationSelectorsSupplement::VariationSelectorDash130),
'๓
ฒ' => Ok(VariationSelectorsSupplement::VariationSelectorDash131),
'๓
ณ' => Ok(VariationSelectorsSupplement::VariationSelectorDash132),
'๓
ด' => Ok(VariationSelectorsSupplement::VariationSelectorDash133),
'๓
ต' => Ok(VariationSelectorsSupplement::VariationSelectorDash134),
'๓
ถ' => Ok(VariationSelectorsSupplement::VariationSelectorDash135),
'๓
ท' => Ok(VariationSelectorsSupplement::VariationSelectorDash136),
'๓
ธ' => Ok(VariationSelectorsSupplement::VariationSelectorDash137),
'๓
น' => Ok(VariationSelectorsSupplement::VariationSelectorDash138),
'๓
บ' => Ok(VariationSelectorsSupplement::VariationSelectorDash139),
'๓
ป' => Ok(VariationSelectorsSupplement::VariationSelectorDash140),
'๓
ผ' => Ok(VariationSelectorsSupplement::VariationSelectorDash141),
'๓
ฝ' => Ok(VariationSelectorsSupplement::VariationSelectorDash142),
'๓
พ' => Ok(VariationSelectorsSupplement::VariationSelectorDash143),
'๓
ฟ' => Ok(VariationSelectorsSupplement::VariationSelectorDash144),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash145),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash146),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash147),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash148),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash149),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash150),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash151),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash152),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash153),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash154),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash155),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash156),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash157),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash158),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash159),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash160),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash161),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash162),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash163),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash164),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash165),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash166),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash167),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash168),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash169),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash170),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash171),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash172),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash173),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash174),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash175),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash176),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash177),
'๓ ก' => Ok(VariationSelectorsSupplement::VariationSelectorDash178),
'๓ ข' => Ok(VariationSelectorsSupplement::VariationSelectorDash179),
'๓ ฃ' => Ok(VariationSelectorsSupplement::VariationSelectorDash180),
'๓ ค' => Ok(VariationSelectorsSupplement::VariationSelectorDash181),
'๓ ฅ' => Ok(VariationSelectorsSupplement::VariationSelectorDash182),
'๓ ฆ' => Ok(VariationSelectorsSupplement::VariationSelectorDash183),
'๓ ง' => Ok(VariationSelectorsSupplement::VariationSelectorDash184),
'๓ จ' => Ok(VariationSelectorsSupplement::VariationSelectorDash185),
'๓ ฉ' => Ok(VariationSelectorsSupplement::VariationSelectorDash186),
'๓ ช' => Ok(VariationSelectorsSupplement::VariationSelectorDash187),
'๓ ซ' => Ok(VariationSelectorsSupplement::VariationSelectorDash188),
'๓ ฌ' => Ok(VariationSelectorsSupplement::VariationSelectorDash189),
'๓ ญ' => Ok(VariationSelectorsSupplement::VariationSelectorDash190),
'๓ ฎ' => Ok(VariationSelectorsSupplement::VariationSelectorDash191),
'๓ ฏ' => Ok(VariationSelectorsSupplement::VariationSelectorDash192),
'๓ ฐ' => Ok(VariationSelectorsSupplement::VariationSelectorDash193),
'๓ ฑ' => Ok(VariationSelectorsSupplement::VariationSelectorDash194),
'๓ ฒ' => Ok(VariationSelectorsSupplement::VariationSelectorDash195),
'๓ ณ' => Ok(VariationSelectorsSupplement::VariationSelectorDash196),
'๓ ด' => Ok(VariationSelectorsSupplement::VariationSelectorDash197),
'๓ ต' => Ok(VariationSelectorsSupplement::VariationSelectorDash198),
'๓ ถ' => Ok(VariationSelectorsSupplement::VariationSelectorDash199),
'๓ ท' => Ok(VariationSelectorsSupplement::VariationSelectorDash200),
'๓ ธ' => Ok(VariationSelectorsSupplement::VariationSelectorDash201),
'๓ น' => Ok(VariationSelectorsSupplement::VariationSelectorDash202),
'๓ บ' => Ok(VariationSelectorsSupplement::VariationSelectorDash203),
'๓ ป' => Ok(VariationSelectorsSupplement::VariationSelectorDash204),
'๓ ผ' => Ok(VariationSelectorsSupplement::VariationSelectorDash205),
'๓ ฝ' => Ok(VariationSelectorsSupplement::VariationSelectorDash206),
'๓ พ' => Ok(VariationSelectorsSupplement::VariationSelectorDash207),
'๓ ฟ' => Ok(VariationSelectorsSupplement::VariationSelectorDash208),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash209),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash210),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash211),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash212),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash213),
'๓
' => Ok(VariationSelectorsSupplement::VariationSelectorDash214),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash215),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash216),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash217),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash218),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash219),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash220),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash221),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash222),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash223),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash224),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash225),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash226),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash227),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash228),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash229),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash230),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash231),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash232),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash233),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash234),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash235),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash236),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash237),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash238),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash239),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash240),
'๓ ' => Ok(VariationSelectorsSupplement::VariationSelectorDash241),
'๓ ก' => Ok(VariationSelectorsSupplement::VariationSelectorDash242),
'๓ ข' => Ok(VariationSelectorsSupplement::VariationSelectorDash243),
'๓ ฃ' => Ok(VariationSelectorsSupplement::VariationSelectorDash244),
'๓ ค' => Ok(VariationSelectorsSupplement::VariationSelectorDash245),
'๓ ฅ' => Ok(VariationSelectorsSupplement::VariationSelectorDash246),
'๓ ฆ' => Ok(VariationSelectorsSupplement::VariationSelectorDash247),
'๓ ง' => Ok(VariationSelectorsSupplement::VariationSelectorDash248),
'๓ จ' => Ok(VariationSelectorsSupplement::VariationSelectorDash249),
'๓ ฉ' => Ok(VariationSelectorsSupplement::VariationSelectorDash250),
'๓ ช' => Ok(VariationSelectorsSupplement::VariationSelectorDash251),
'๓ ซ' => Ok(VariationSelectorsSupplement::VariationSelectorDash252),
'๓ ฌ' => Ok(VariationSelectorsSupplement::VariationSelectorDash253),
'๓ ญ' => Ok(VariationSelectorsSupplement::VariationSelectorDash254),
'๓ ฎ' => Ok(VariationSelectorsSupplement::VariationSelectorDash255),
_ => Err(()),
}
}
}
impl Into<u32> for VariationSelectorsSupplement {
fn into(self) -> u32 {
let c: char = self.into();
let hex = c
.escape_unicode()
.to_string()
.replace("\\u{", "")
.replace("}", "");
u32::from_str_radix(&hex, 16).unwrap()
}
}
impl std::convert::TryFrom<u32> for VariationSelectorsSupplement {
type Error = ();
fn try_from(u: u32) -> Result<Self, Self::Error> {
if let Ok(c) = char::try_from(u) {
Self::try_from(c)
} else {
Err(())
}
}
}
impl Iterator for VariationSelectorsSupplement {
type Item = Self;
fn next(&mut self) -> Option<Self> {
let index: u32 = (*self).into();
use std::convert::TryFrom;
Self::try_from(index + 1).ok()
}
}
impl VariationSelectorsSupplement {
/// The character with the lowest index in this unicode block
pub fn new() -> Self {
VariationSelectorsSupplement::VariationSelectorDash17
}
/// The character's name, in sentence case
pub fn name(&self) -> String {
let s = std::format!("VariationSelectorsSupplement{:#?}", self);
string_morph::to_sentence_case(&s)
}
}
|
mod deck;
fn main() {
//let mut st: deck::Deck = deck::new();
let mut deck = deck::Deck::new();
loop {
let card = deck.pop();
match card {
None => break,
Some(card) => println!("{}", card)
}
}
}
// fn main_loop(st: &mut deck::Deck) {
// main_loop(st);
// }
|
// cross module macros go here
#[macro_export]
macro_rules! vm_panic {
($s: expr, $err: expr) => {
println!("!! Lua VM crash");
// TODO unwind the entire frame stack here for more information
let f = &$s.current_frame;
let (line_no, lines) = f.code.sourcemap.get_lines_for_bytecode(f.pc);
println!("!! failed on line {} of {}", line_no, $s.file_path);
println!("--> {}", lines);
println!("With:");
dbg!($err);
panic!("VM CRASH");
};
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.