Struct goatns::zones::FileZone

pub struct FileZone {
    pub id: Option<i64>,
    pub name: String,
    pub rname: String,
    pub serial: u32,
    pub refresh: u32,
    pub retry: u32,
    pub expire: u32,
    pub minimum: u32,
    pub records: Vec<FileZoneRecord>,
}

A DNS Zone

Fields

id: Option<i64>

Database row ID

name: String

MNAME The domain-name of the name server that was the original or primary source of data for this zone.

rname: String

serial: u32

SERIAL - The unsigned 32 bit version number of the original copy of the zone. Zone transfers preserve this value. This value wraps and should be compared using sequence space arithmetic.

refresh: u32

REFRESH - A 32 bit time interval before the zone should be refreshed.

retry: u32

RETRY - A 32 bit time interval that should elapse before a failed refresh should be retried.

expire: u32

EXPIRE - A 32 bit time value that specifies the upper limit on the time interval that can elapse before the zone is no longer authoritative.

minimum: u32

MINIMUM - The unsigned 32 bit minimum TTL field that should be exported with any RR from this zone.

records: Vec<FileZoneRecord>

Implementations

impl FileZone

pub async fn with_zone_records(self, txn: &mut SqliteConnection) -> Self

pub async fn get_zone_records( &self, txn: &mut SqliteConnection ) -> Result<Vec<FileZoneRecord>, Error>

the records for the zone

pub async fn get_orphans(pool: &SqlitePool) -> Result<Vec<FileZone>, Error>

impl FileZone

pub fn matching_data(&self, cmp: &FileZone) -> bool

Checks if they’re equal, ignores the zone id and records

Trait Implementations

impl APIEntity for FileZone

fn api_create<'async_trait>( __arg0: State<Arc<RwLock<GoatChildState>>>, session: Session, __arg2: Json<Value> ) -> Pin<Box<dyn Future<Output = Result<Json<Box<Self>>, (StatusCode, Json<ErrorResult>)>> + Send + 'async_trait>>

where Self: 'async_trait,

Save the entity to the database

fn api_update<'async_trait>( __arg0: State<Arc<RwLock<GoatChildState>>>, session: Session, __arg2: Json<Value> ) -> Pin<Box<dyn Future<Output = Result<Json<String>, (StatusCode, Json<ErrorResult>)>> + Send + 'async_trait>>

HTTP Put https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT

fn api_delete<'async_trait>( __arg0: State<Arc<RwLock<GoatChildState>>>, session: Session, __arg2: Path<i64> ) -> Pin<Box<dyn Future<Output = Result<StatusCode, (StatusCode, Json<ErrorResult>)>> + Send + 'async_trait>>

Delete an object https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE

fn api_get<'async_trait>( __arg0: State<Arc<RwLock<GoatChildState>>>, session: Session, __arg2: Path<i64> ) -> Pin<Box<dyn Future<Output = Result<Json<Box<Self>>, (StatusCode, Json<ErrorResult>)>> + Send + 'async_trait>>

where Self: 'async_trait,

impl Clone for FileZone

fn clone(&self) -> FileZone

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DBEntity for FileZone

fn get<'life0, 'async_trait>( pool: &'life0 Pool<Sqlite>, id: i64 ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get by id

fn save<'life0, 'life1, 'async_trait>( &'life0 self, pool: &'life1 Pool<Sqlite> ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

save the entity to the database

fn save_with_txn<'t, 'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 mut SqliteConnection ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 't: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

save the entity to the database, but you’re in a transaction

fn create_with_txn<'t, 'life0, 'life1, 'async_trait>( &'life0 self, _txn: &'life1 mut SqliteConnection ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 't: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

create from scratch

fn update_with_txn<'t, 'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 mut SqliteConnection ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 't: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

create from scratch

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, pool: &'life1 Pool<Sqlite> ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

delete the entity from the database

fn delete_with_txn<'life0, 'life1, 'async_trait>( &'life0 self, txn: &'life1 mut SqliteConnection ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete the entity from the database, when you’re in a transaction.

This one happens in the order ownership -> records -> zone because at the very least, if it fails after the ownership thing, then non-admin users can’t see the zone and admins will just have to clean it up manually

const TABLE: &'static str = "zones"

fn create_table<'life0, 'async_trait>( pool: &'life0 SqlitePool ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait,

fn get_with_txn<'t, 'life0, 'life1, 'async_trait>( txn: &'life0 mut SqliteConnection, id: &'life1 i64 ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 't: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_by_name<'t, 'life0, 'life1, 'async_trait>( txn: &'life0 mut SqliteConnection, name: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Box<Self>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 't: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_all_by_name<'t, 'life0, 'life1, 'async_trait>( _txn: &'life0 mut SqliteConnection, _name: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<Vec<Box<Self>>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 't: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_all_user<'life0, 'async_trait>( _pool: &'life0 Pool<Sqlite>, _userid: i64 ) -> Pin<Box<dyn Future<Output = Result<Vec<Arc<Self>>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn json(&self) -> Result<String, String>

where Self: Serialize,

impl Debug for FileZone

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FileZone

fn default() -> FileZone

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FileZone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SqliteRow> for FileZone

fn from(input: SqliteRow) -> Self

Converts to this type from the input type.

impl PartialEq for FileZone

fn eq(&self, other: &FileZone) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FileZone

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for FileZone

impl StructuralEq for FileZone

impl StructuralPartialEq for FileZone