6011779781

Committed 29 Aug 2023 11:17AM UTC coverage: 76.528% (-1.5%) from 78.07%

Build # 6011779781

Build Type

push

github

Committed by

web-flow

Commit Message

fix: Include connection type in `GenerateDot`. Fix `AggregationProcessorFactory::type_name` (#1934)

Run Details

170 of 170 new or added lines in 5 files covered. (100.0%)

49017 of 64051 relevant lines covered (76.53%)

48279.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/dozer-cli/src/errors.rs

#![allow(clippy::enum_variant_names)]

use glob::{GlobError, PatternError};
use std::io;
use std::path::PathBuf;
use tonic::Code::NotFound;

use crate::{
    errors::CloudError::{ApplicationNotFound, CloudServiceError},
    live::LiveError,
};
use dozer_api::{
    errors::{ApiInitError, AuthError, GenerationError, GrpcError},
    rest::DOZER_SERVER_NAME_HEADER,
};
use dozer_cache::dozer_log::storage;
use dozer_cache::errors::CacheError;
use dozer_core::errors::ExecutionError;
use dozer_ingestion::errors::ConnectorError;
use dozer_sql::pipeline::errors::PipelineError;
use dozer_types::thiserror::Error;
use dozer_types::{errors::internal::BoxedError, serde_json};
use dozer_types::{serde_yaml, thiserror};

use crate::pipeline::connector_source::ConnectorSourceFactoryError;

pub fn map_tonic_error(e: tonic::Status) -> CloudError {
    if e.code() == NotFound && e.message() == "Failed to find app" {
        ApplicationNotFound
    } else {
        CloudServiceError(e)
    }
}

#[derive(Error, Debug)]
pub enum OrchestrationError {
    #[error("Failed to write config yaml: {0:?}")]
    FailedToWriteConfigYaml(#[source] serde_yaml::Error),
    #[error("File system error {0:?}: {1}")]
    FileSystem(PathBuf, std::io::Error),
    #[error("Failed to find any build")]
    NoBuildFound,
    #[error("Failed to create log: {0}")]
    CreateLog(#[from] dozer_cache::dozer_log::replication::Error),
    #[error("Failed to login: {0}")]
    CloudLoginFailed(#[from] CloudLoginError),
    #[error("Credential Error: {0}")]
    CredentialError(#[from] CloudCredentialError),
    #[error("Failed to build: {0}")]
    BuildFailed(#[from] BuildError),
    #[error("Failed to generate token: {0}")]
    GenerateTokenFailed(#[source] AuthError),
    #[error("Missing api config or security input")]
    MissingSecurityConfig,
    #[error("Cloud service error: {0}")]
    CloudError(#[from] CloudError),
    #[error("Failed to initialize api server: {0}")]
    ApiInitFailed(#[from] ApiInitError),
    #[error("Failed to server REST API: {0}")]
    RestServeFailed(#[source] std::io::Error),
    #[error("Failed to server gRPC API: {0:?}")]
    GrpcServeFailed(#[source] tonic::transport::Error),
    #[error("Failed to initialize internal server: {0}")]
    InternalServerFailed(#[source] GrpcError),
    #[error("{0}: Failed to initialize cache. Have you run `dozer build`?")]
    CacheInitFailed(#[source] CacheError),
    #[error("Failed to build cache {0} from log: {1}")]
    CacheBuildFailed(String, #[source] CacheError),
    #[error("Cache {0} has reached its maximum size. Try to increase `cache_max_map_size` in the config.")]
    CacheFull(String),
    #[error("Internal thread panic: {0}")]
    JoinError(#[source] tokio::task::JoinError),
    #[error("Connector source factory error: {0}")]
    ConnectorSourceFactory(#[from] ConnectorSourceFactoryError),
    #[error(transparent)]
    ExecutionError(#[from] ExecutionError),
    #[error(transparent)]
    ConnectorError(#[from] ConnectorError),
    #[error(transparent)]
    PipelineError(#[from] PipelineError),
    #[error(transparent)]
    CliError(#[from] CliError),
    #[error("table_name: {0:?} not found in any of the connections")]
    SourceValidationError(String),
    #[error("connection: {0:?} not found")]
    ConnectionNotFound(String),
    #[error("Pipeline validation failed")]
    PipelineValidationError,
    #[error("Table name specified in endpoint not found: {0:?}")]
    EndpointTableNotFound(String),
    #[error("Duplicate table name found: {0:?}")]
    DuplicateTable(String),
    #[error("No endpoints initialized in the config provided")]
    EmptyEndpoints,
    #[error(transparent)]
    CloudContextError(#[from] CloudContextError),
    #[error("Failed to read organisation name. Error: {0}")]
    FailedToReadOrganisationName(#[source] io::Error),
    #[error(transparent)]
    LiveError(#[from] LiveError),
}

#[derive(Error, Debug)]
pub enum CliError {
    #[error("Configuration file path not provided")]
    ConfigurationFilePathNotProvided,
    #[error("Can't find the configuration file(s) at: {0:?}")]
    FailedToFindConfigurationFiles(String),
    #[error("Unknown Command: {0:?}")]
    UnknownCommand(String),
    #[error("Failed to parse dozer config: {0:?}")]
    FailedToParseYaml(#[source] BoxedError),
    #[error("Failed to validate dozer config: {0:?}")]
    FailedToParseValidateYaml(#[source] BoxedError),
    #[error("Failed to read line: {0}")]
    ReadlineError(#[from] rustyline::error::ReadlineError),
    #[error("File system error {0:?}: {1}")]
    FileSystem(PathBuf, #[source] std::io::Error),
    #[error("Failed to create tokio runtime: {0}")]
    FailedToCreateTokioRuntime(#[source] std::io::Error),
    #[error("Reqwest error: {0}")]
    Reqwest(#[from] reqwest::Error),
    #[error(transparent)]
    ConfigCombineError(#[from] ConfigCombineError),
    #[error("Failed to serialize config to json: {0}")]
    SerializeConfigToJson(#[source] serde_json::Error),
    #[error("Missing config options to be overridden: {0}")]
    MissingConfigOverride(String),
    #[error("Failed to deserialize config from json: {0}")]
    DeserializeConfigFromJson(#[source] serde_json::Error),
}

#[derive(Error, Debug)]
pub enum CloudError {
    #[error("Connection failed. Error: {0:?}")]
    ConnectionToCloudServiceError(#[from] tonic::transport::Error),

    #[error("Cloud service returned error: {0:?}")]
    CloudServiceError(#[from] tonic::Status),

    #[error("GRPC request failed, error: {} (GRPC status {})", .0.message(), .0.code())]
    GRPCCallError(#[source] tonic::Status),

    #[error(transparent)]
    CloudCredentialError(#[from] CloudCredentialError),

    #[error("Reqwest error: {0}")]
    Reqwest(#[from] reqwest::Error),

    #[error("Response header {DOZER_SERVER_NAME_HEADER} is missing")]
    MissingResponseHeader,

    #[error(transparent)]
    CloudContextError(#[from] CloudContextError),

    #[error(transparent)]
    ConfigCombineError(#[from] ConfigCombineError),

    #[error("Application not found")]
    ApplicationNotFound,
}

#[derive(Debug, Error)]
pub enum ConfigCombineError {
    #[error("Failed to parse yaml file {0}: {1}")]
    ParseYaml(String, #[source] serde_yaml::Error),

    #[error("Cannot merge yaml value {from:?} to {to:?}")]
    CannotMerge {
        from: serde_yaml::Value,
        to: serde_yaml::Value,
    },

    #[error("Failed to parse config: {0}")]
    ParseConfig(#[source] serde_yaml::Error),

    #[error("Cannot read configuration: {0:?}")]
    CannotReadConfig(PathBuf, #[source] std::io::Error),

    #[error("Wrong pattern of config files read glob: {0}")]
    WrongPatternOfConfigFilesGlob(#[from] PatternError),

    #[error("Cannot read file: {0}")]
    CannotReadFile(#[from] GlobError),

    #[error("Cannot serialize config to string: {0}")]
    CannotSerializeToString(#[source] serde_yaml::Error),

    #[error("SQL is not a string type")]
    SqlIsNotStringType,
}

#[derive(Debug, Error)]
pub enum BuildError {
    #[error("Endpoint {0} not found in DAG")]
    MissingEndpoint(String),
    #[error("Connection {0} found in DAG but not in config")]
    MissingConnection(String),
    #[error("Got mismatching primary key for `{endpoint_name}`. Expected: `{expected:?}`, got: `{actual:?}`")]
    MismatchPrimaryKey {
        endpoint_name: String,
        expected: Vec<String>,
        actual: Vec<String>,
    },
    #[error("Field not found at position {0}")]
    FieldNotFound(String),
    #[error("File system error {0:?}: {1}")]
    FileSystem(PathBuf, std::io::Error),
    #[error(
        "Failed to load existing contract: {0}. You have to run a force build: `dozer build --force`."
    )]
    FailedToLoadExistingContract(#[source] serde_json::Error),
    #[error("Serde json error: {0}")]
    SerdeJson(#[source] serde_json::Error),
    #[error("Failed to generate proto files: {0:?}")]
    FailedToGenerateProtoFiles(#[from] GenerationError),
    #[error("Storage error: {0}")]
    Storage(#[from] storage::Error),
}

#[derive(Debug, Error)]
pub enum CloudLoginError {
    #[error("Tonic error: {0}")]
    TonicError(#[from] tonic::Status),

    #[error("Transport error: {0}")]
    Transport(#[from] tonic::transport::Error),

    #[error("HttpRequest error: {0}")]
    HttpRequestError(#[from] reqwest::Error),

    #[error(transparent)]
    SerializationError(#[from] dozer_types::serde_json::Error),

    #[error("Failed to read input: {0}")]
    InputError(#[from] std::io::Error),

    #[error(transparent)]
    CloudCredentialError(#[from] CloudCredentialError),

    #[error("Organisation not found")]
    OrganisationNotFound,
}

#[derive(Debug, Error)]
pub enum CloudCredentialError {
    #[error(transparent)]
    SerializationError(#[from] dozer_types::serde_yaml::Error),

    #[error(transparent)]
    JsonSerializationError(#[from] dozer_types::serde_json::Error),
    #[error("Failed to create home directory: {0}")]
    FailedToCreateDirectory(#[from] std::io::Error),

    #[error("HttpRequest error: {0}")]
    HttpRequestError(#[from] reqwest::Error),

    #[error("Missing credentials.yaml file - Please try to login again")]
    MissingCredentialFile,
    #[error("There's no profile with given name - Please try to login again")]
    MissingProfile,
}

#[derive(Debug, Error)]
pub enum CloudContextError {
    #[error("Failed to create access directory: {0}")]
    FailedToAccessDirectory(#[from] std::io::Error),

    #[error("Failed to get current directory path")]
    FailedToGetDirectoryPath,

    #[error("App id not found in configuration. You need to run \"deploy\" or \"set-app\" first")]
    AppIdNotFound,
}

1	#![allow(clippy::enum_variant_names)]
2
3	use glob::{GlobError, PatternError};
4	use std::io;
5	use std::path::PathBuf;
6	use tonic::Code::NotFound;
7
8	use crate::{
9	errors::CloudError::{ApplicationNotFound, CloudServiceError},
10	live::LiveError,
11	};
12	use dozer_api::{
13	errors::{ApiInitError, AuthError, GenerationError, GrpcError},
14	rest::DOZER_SERVER_NAME_HEADER,
15	};
16	use dozer_cache::dozer_log::storage;
17	use dozer_cache::errors::CacheError;
18	use dozer_core::errors::ExecutionError;
19	use dozer_ingestion::errors::ConnectorError;
20	use dozer_sql::pipeline::errors::PipelineError;
21	use dozer_types::thiserror::Error;
22	use dozer_types::{errors::internal::BoxedError, serde_json};
23	use dozer_types::{serde_yaml, thiserror};
24
25	use crate::pipeline::connector_source::ConnectorSourceFactoryError;
26
27	pub fn map_tonic_error(e: tonic::Status) -> CloudError {	×
28	if e.code() == NotFound && e.message() == "Failed to find app" {	×
29	ApplicationNotFound	×
30	} else {
31	CloudServiceError(e)	×
32	}
33	}	×
34
35	#[derive(Error, Debug)]	×
36	pub enum OrchestrationError {
37	#[error("Failed to write config yaml: {0:?}")]
38	FailedToWriteConfigYaml(#[source] serde_yaml::Error),
39	#[error("File system error {0:?}: {1}")]
40	FileSystem(PathBuf, std::io::Error),
41	#[error("Failed to find any build")]
42	NoBuildFound,
43	#[error("Failed to create log: {0}")]
44	CreateLog(#[from] dozer_cache::dozer_log::replication::Error),
45	#[error("Failed to login: {0}")]
46	CloudLoginFailed(#[from] CloudLoginError),
47	#[error("Credential Error: {0}")]
48	CredentialError(#[from] CloudCredentialError),
49	#[error("Failed to build: {0}")]
50	BuildFailed(#[from] BuildError),
51	#[error("Failed to generate token: {0}")]
52	GenerateTokenFailed(#[source] AuthError),
53	#[error("Missing api config or security input")]
54	MissingSecurityConfig,
55	#[error("Cloud service error: {0}")]
56	CloudError(#[from] CloudError),
57	#[error("Failed to initialize api server: {0}")]
58	ApiInitFailed(#[from] ApiInitError),
59	#[error("Failed to server REST API: {0}")]
60	RestServeFailed(#[source] std::io::Error),
61	#[error("Failed to server gRPC API: {0:?}")]
62	GrpcServeFailed(#[source] tonic::transport::Error),
63	#[error("Failed to initialize internal server: {0}")]
64	InternalServerFailed(#[source] GrpcError),
65	#[error("{0}: Failed to initialize cache. Have you run `dozer build`?")]
66	CacheInitFailed(#[source] CacheError),
67	#[error("Failed to build cache {0} from log: {1}")]
68	CacheBuildFailed(String, #[source] CacheError),
69	#[error("Cache {0} has reached its maximum size. Try to increase `cache_max_map_size` in the config.")]
70	CacheFull(String),
71	#[error("Internal thread panic: {0}")]
72	JoinError(#[source] tokio::task::JoinError),
73	#[error("Connector source factory error: {0}")]
74	ConnectorSourceFactory(#[from] ConnectorSourceFactoryError),
75	#[error(transparent)]
76	ExecutionError(#[from] ExecutionError),
77	#[error(transparent)]
78	ConnectorError(#[from] ConnectorError),
79	#[error(transparent)]
80	PipelineError(#[from] PipelineError),
81	#[error(transparent)]
82	CliError(#[from] CliError),
83	#[error("table_name: {0:?} not found in any of the connections")]
84	SourceValidationError(String),
85	#[error("connection: {0:?} not found")]
86	ConnectionNotFound(String),
87	#[error("Pipeline validation failed")]
88	PipelineValidationError,
89	#[error("Table name specified in endpoint not found: {0:?}")]
90	EndpointTableNotFound(String),
91	#[error("Duplicate table name found: {0:?}")]
92	DuplicateTable(String),
93	#[error("No endpoints initialized in the config provided")]
94	EmptyEndpoints,
95	#[error(transparent)]
96	CloudContextError(#[from] CloudContextError),
97	#[error("Failed to read organisation name. Error: {0}")]
98	FailedToReadOrganisationName(#[source] io::Error),
99	#[error(transparent)]
100	LiveError(#[from] LiveError),
101	}
102
103	#[derive(Error, Debug)]	×
104	pub enum CliError {
105	#[error("Configuration file path not provided")]
106	ConfigurationFilePathNotProvided,
107	#[error("Can't find the configuration file(s) at: {0:?}")]
108	FailedToFindConfigurationFiles(String),
109	#[error("Unknown Command: {0:?}")]
110	UnknownCommand(String),
111	#[error("Failed to parse dozer config: {0:?}")]
112	FailedToParseYaml(#[source] BoxedError),
113	#[error("Failed to validate dozer config: {0:?}")]
114	FailedToParseValidateYaml(#[source] BoxedError),
115	#[error("Failed to read line: {0}")]
116	ReadlineError(#[from] rustyline::error::ReadlineError),
117	#[error("File system error {0:?}: {1}")]
118	FileSystem(PathBuf, #[source] std::io::Error),
119	#[error("Failed to create tokio runtime: {0}")]
120	FailedToCreateTokioRuntime(#[source] std::io::Error),
121	#[error("Reqwest error: {0}")]
122	Reqwest(#[from] reqwest::Error),
123	#[error(transparent)]
124	ConfigCombineError(#[from] ConfigCombineError),
125	#[error("Failed to serialize config to json: {0}")]
126	SerializeConfigToJson(#[source] serde_json::Error),
127	#[error("Missing config options to be overridden: {0}")]
128	MissingConfigOverride(String),
129	#[error("Failed to deserialize config from json: {0}")]
130	DeserializeConfigFromJson(#[source] serde_json::Error),
131	}
132
133	#[derive(Error, Debug)]	×
134	pub enum CloudError {
135	#[error("Connection failed. Error: {0:?}")]
136	ConnectionToCloudServiceError(#[from] tonic::transport::Error),
137
138	#[error("Cloud service returned error: {0:?}")]
139	CloudServiceError(#[from] tonic::Status),
140
141	#[error("GRPC request failed, error: {} (GRPC status {})", .0.message(), .0.code())]
142	GRPCCallError(#[source] tonic::Status),
143
144	#[error(transparent)]
145	CloudCredentialError(#[from] CloudCredentialError),
146
147	#[error("Reqwest error: {0}")]
148	Reqwest(#[from] reqwest::Error),
149
150	#[error("Response header {DOZER_SERVER_NAME_HEADER} is missing")]
151	MissingResponseHeader,
152
153	#[error(transparent)]
154	CloudContextError(#[from] CloudContextError),
155
156	#[error(transparent)]
157	ConfigCombineError(#[from] ConfigCombineError),
158
159	#[error("Application not found")]
160	ApplicationNotFound,
161	}
162
163	#[derive(Debug, Error)]	×
164	pub enum ConfigCombineError {	×
165	#[error("Failed to parse yaml file {0}: {1}")]
166	ParseYaml(String, #[source] serde_yaml::Error),
167
168	#[error("Cannot merge yaml value {from:?} to {to:?}")]
169	CannotMerge {
170	from: serde_yaml::Value,
171	to: serde_yaml::Value,
172	},
173
174	#[error("Failed to parse config: {0}")]
175	ParseConfig(#[source] serde_yaml::Error),
176
177	#[error("Cannot read configuration: {0:?}")]
178	CannotReadConfig(PathBuf, #[source] std::io::Error),
179
180	#[error("Wrong pattern of config files read glob: {0}")]
181	WrongPatternOfConfigFilesGlob(#[from] PatternError),
182
183	#[error("Cannot read file: {0}")]
184	CannotReadFile(#[from] GlobError),
185
186	#[error("Cannot serialize config to string: {0}")]
187	CannotSerializeToString(#[source] serde_yaml::Error),
188
189	#[error("SQL is not a string type")]
190	SqlIsNotStringType,
191	}
192
193	#[derive(Debug, Error)]	×
194	pub enum BuildError {	×
195	#[error("Endpoint {0} not found in DAG")]
196	MissingEndpoint(String),
197	#[error("Connection {0} found in DAG but not in config")]
198	MissingConnection(String),
199	#[error("Got mismatching primary key for `{endpoint_name}`. Expected: `{expected:?}`, got: `{actual:?}`")]
200	MismatchPrimaryKey {
201	endpoint_name: String,
202	expected: Vec<String>,
203	actual: Vec<String>,
204	},
205	#[error("Field not found at position {0}")]
206	FieldNotFound(String),
207	#[error("File system error {0:?}: {1}")]
208	FileSystem(PathBuf, std::io::Error),
209	#[error(
210	"Failed to load existing contract: {0}. You have to run a force build: `dozer build --force`."
211	)]
212	FailedToLoadExistingContract(#[source] serde_json::Error),
213	#[error("Serde json error: {0}")]
214	SerdeJson(#[source] serde_json::Error),
215	#[error("Failed to generate proto files: {0:?}")]
216	FailedToGenerateProtoFiles(#[from] GenerationError),
217	#[error("Storage error: {0}")]
218	Storage(#[from] storage::Error),
219	}	×
220		×
221	#[derive(Debug, Error)]	×
222	pub enum CloudLoginError {	×
223	#[error("Tonic error: {0}")]
224	TonicError(#[from] tonic::Status),
225
226	#[error("Transport error: {0}")]
227	Transport(#[from] tonic::transport::Error),
228
229	#[error("HttpRequest error: {0}")]
230	HttpRequestError(#[from] reqwest::Error),
231
232	#[error(transparent)]
233	SerializationError(#[from] dozer_types::serde_json::Error),
234
235	#[error("Failed to read input: {0}")]
236	InputError(#[from] std::io::Error),
237
238	#[error(transparent)]
239	CloudCredentialError(#[from] CloudCredentialError),
240
241	#[error("Organisation not found")]
242	OrganisationNotFound,
243	}	×
244		×
245	#[derive(Debug, Error)]	×
246	pub enum CloudCredentialError {	×
247	#[error(transparent)]
248	SerializationError(#[from] dozer_types::serde_yaml::Error),
249
250	#[error(transparent)]
251	JsonSerializationError(#[from] dozer_types::serde_json::Error),
252	#[error("Failed to create home directory: {0}")]
253	FailedToCreateDirectory(#[from] std::io::Error),
254
255	#[error("HttpRequest error: {0}")]
256	HttpRequestError(#[from] reqwest::Error),
257
258	#[error("Missing credentials.yaml file - Please try to login again")]
259	MissingCredentialFile,
260	#[error("There's no profile with given name - Please try to login again")]
261	MissingProfile,
262	}	×
263		×
264	#[derive(Debug, Error)]	×
265	pub enum CloudContextError {	×
266	#[error("Failed to create access directory: {0}")]
267	FailedToAccessDirectory(#[from] std::io::Error),
268
269	#[error("Failed to get current directory path")]
270	FailedToGetDirectoryPath,
271
272	#[error("App id not found in configuration. You need to run \"deploy\" or \"set-app\" first")]
273	AppIdNotFound,
274	}

getdozer / dozer / 6011779781

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous