use crate::api::cache_config::{
CacheCreateWithConfigReq, CacheCreateWithNameReq, CacheDestroyReq, CacheGetConfigReq,
CacheGetConfigResp, CacheGetNamesReq, CacheGetNamesResp, CacheGetOrCreateWithConfigReq,
CacheGetOrCreateWithNameReq,
};
use crate::api::OpCode;
use crate::cache::{Cache, CacheConfiguration};
use crate::connection::Connection;
use crate::error::IgniteResult;
use crate::protocol::{read_wrapped_data, TypeCode};
use crate::utils::string_to_java_hashcode;
use std::io;
use std::io::{Read, Write};
use std::sync::Arc;
#[cfg(feature = "ssl")]
use rustls;
use std::time::Duration;
mod api;
pub mod cache;
mod connection;
pub mod error;
mod handshake;
pub mod protocol;
pub mod utils;
pub(crate) trait WriteableReq {
fn write(&self, writer: &mut dyn Write) -> io::Result<()>;
fn size(&self) -> usize;
}
pub(crate) trait ReadableReq: Sized {
fn read(reader: &mut impl Read) -> IgniteResult<Self>;
}
pub trait WritableType {
fn write(&self, writer: &mut dyn Write) -> io::Result<()>;
fn size(&self) -> usize;
}
pub trait ReadableType: Sized {
fn read_unwrapped(type_code: TypeCode, reader: &mut impl Read) -> IgniteResult<Option<Self>>;
fn read(reader: &mut impl Read) -> IgniteResult<Option<Self>> {
read_wrapped_data(reader)
}
}
pub trait IgniteObj: WritableType + ReadableType {}
#[derive(Clone)]
pub struct ClientConfig {
pub addr: String,
pub username: Option<String>,
pub password: Option<String>,
pub tcp_nodelay: Option<bool>,
pub tcp_nonblocking: Option<bool>,
pub tcp_read_timeout: Option<Duration>,
pub tcp_write_timeout: Option<Duration>,
pub tcp_ttl: Option<u32>,
pub tcp_read_buff_size: Option<usize>,
pub tcp_write_buff_size: Option<usize>,
#[cfg(feature = "ssl")]
pub tls_conf: (rustls::ClientConfig, String),
}
impl ClientConfig {
#[cfg(not(feature = "ssl"))]
pub fn new(addr: &str) -> ClientConfig {
ClientConfig {
addr: addr.into(),
username: None,
password: None,
tcp_nodelay: None,
tcp_nonblocking: None,
tcp_read_timeout: None,
tcp_write_timeout: None,
tcp_ttl: None,
tcp_read_buff_size: None,
tcp_write_buff_size: None,
}
}
#[cfg(feature = "ssl")]
pub fn new(addr: &str, client_conf: rustls::ClientConfig, hostname: String) -> ClientConfig {
ClientConfig {
addr: addr.into(),
username: None,
password: None,
tcp_nodelay: None,
tcp_nonblocking: None,
tcp_read_timeout: None,
tcp_write_timeout: None,
tcp_ttl: None,
tcp_read_buff_size: None,
tcp_write_buff_size: None,
tls_conf: (client_conf, hostname),
}
}
}
pub fn new_client(conf: ClientConfig) -> IgniteResult<Client> {
Client::new(conf)
}
pub trait Ignite {
fn get_cache_names(&mut self) -> IgniteResult<Vec<String>>;
fn create_cache<K: WritableType + ReadableType, V: WritableType + ReadableType>(
&mut self,
name: &str,
) -> IgniteResult<Cache<K, V>>;
fn get_or_create_cache<K: WritableType + ReadableType, V: WritableType + ReadableType>(
&mut self,
name: &str,
) -> IgniteResult<Cache<K, V>>;
fn create_cache_with_config<K: WritableType + ReadableType, V: WritableType + ReadableType>(
&mut self,
config: &CacheConfiguration,
) -> IgniteResult<Cache<K, V>>;
fn get_or_create_cache_with_config<
K: WritableType + ReadableType,
V: WritableType + ReadableType,
>(
&mut self,
config: &CacheConfiguration,
) -> IgniteResult<Cache<K, V>>;
fn get_cache_config(&mut self, name: &str) -> IgniteResult<CacheConfiguration>;
fn destroy_cache(&mut self, name: &str) -> IgniteResult<()>;
}
pub struct Client {
_conf: ClientConfig,
conn: Arc<Connection>,
}
impl Client {
fn new(conf: ClientConfig) -> IgniteResult<Client> {
match Connection::new(&conf) {
Ok(conn) => {
let client = Client {
_conf: conf,
conn: Arc::new(conn),
};
Ok(client)
}
Err(err) => Err(err),
}
}
}
impl Ignite for Client {
fn get_cache_names(&mut self) -> IgniteResult<Vec<String>> {
let resp: CacheGetNamesResp = self
.conn
.send_and_read(OpCode::CacheGetNames, CacheGetNamesReq {})?;
Ok(resp.names)
}
fn create_cache<K: WritableType + ReadableType, V: WritableType + ReadableType>(
&mut self,
name: &str,
) -> IgniteResult<Cache<K, V>> {
self.conn
.send(
OpCode::CacheCreateWithName,
CacheCreateWithNameReq::from(name),
)
.map(|_| {
Cache::new(
string_to_java_hashcode(name),
name.to_owned(),
self.conn.clone(),
)
})
}
fn get_or_create_cache<K: WritableType + ReadableType, V: WritableType + ReadableType>(
&mut self,
name: &str,
) -> IgniteResult<Cache<K, V>> {
self.conn
.send(
OpCode::CacheGetOrCreateWithName,
CacheGetOrCreateWithNameReq::from(name),
)
.map(|_| {
Cache::new(
string_to_java_hashcode(name),
name.to_owned(),
self.conn.clone(),
)
})
}
fn create_cache_with_config<K: WritableType + ReadableType, V: WritableType + ReadableType>(
&mut self,
config: &CacheConfiguration,
) -> IgniteResult<Cache<K, V>> {
self.conn
.send(
OpCode::CacheCreateWithConfiguration,
CacheCreateWithConfigReq { config },
)
.map(|_| {
Cache::new(
string_to_java_hashcode(config.name.as_str()),
config.name.clone(),
self.conn.clone(),
)
})
}
fn get_or_create_cache_with_config<
K: WritableType + ReadableType,
V: WritableType + ReadableType,
>(
&mut self,
config: &CacheConfiguration,
) -> IgniteResult<Cache<K, V>> {
self.conn
.send(
OpCode::CacheGetOrCreateWithConfiguration,
CacheGetOrCreateWithConfigReq { config },
)
.map(|_| {
Cache::new(
string_to_java_hashcode(config.name.as_str()),
config.name.clone(),
self.conn.clone(),
)
})
}
fn get_cache_config(&mut self, name: &str) -> IgniteResult<CacheConfiguration> {
let resp: CacheGetConfigResp = self
.conn
.send_and_read(OpCode::CacheGetConfiguration, CacheGetConfigReq::from(name))?;
Ok(resp.config)
}
fn destroy_cache(&mut self, name: &str) -> IgniteResult<()> {
self.conn
.send(OpCode::CacheDestroy, CacheDestroyReq::from(name))
}
}
#[derive(Debug, Copy, Clone)]
#[allow(dead_code)]
pub struct Enum {
pub type_id: i32,
pub ordinal: i32,
}