migrating to protobuf-codegen

Signed-off-by: Matt Wrock <matt@mattwrock.com>

Author: mwrock

Cargo.lock

@@ -27,7 +27,7 @@ memcache = "*"
 num_cpus = "*"
 openssl = "*"
 percent-encoding = "*"
-protobuf = "2"
+protobuf = "3"
 reqwest = { version = "*", features = ["blocking", "json"] }
 serde = "*"
 serde_derive = "*"

components/builder-api/Cargo.toml

@@ -36,12 +36,12 @@ pub fn authorize_session(req: &HttpRequest,
         let extensions = req.extensions();
         match extensions.get::<originsrv::Session>() {
             Some(session) => {
-                let flags = FeatureFlags::from_bits(session.get_flags()).unwrap(); // unwrap Ok
+                let flags = FeatureFlags::from_bits(session.flags()).unwrap(); // unwrap Ok
                 if flags.contains(FeatureFlags::BUILD_WORKER) {
                     debug!("authorize_session: detected allowed BUILD_WORKER");
                     return Ok(session.clone());
                 }
-                debug!("authorize_session: found session {}", session.get_id());
+                debug!("authorize_session: found session {}", session.id());
                 session.clone()
             }
             None => {
@@ -61,18 +61,18 @@ pub fn authorize_session(req: &HttpRequest,
                 r
             }
         };
-        match check_origin_member_role(req, origin, session.get_id()) {
+        match check_origin_member_role(req, origin, session.id()) {
             Some(member_role) => {
                 if member_role >= minimum_req_role {
                     debug!("authorize_session: account {} has {} permissions in origin {}",
-                           session.get_id(),
+                           session.id(),
                            minimum_req_role,
                            origin);
                     return Ok(session);
                 } else {
                     debug!("authorize_session: account {} does not have {} permissions in origin \
                             {}. Current role: {}",
-                           session.get_id(),
+                           session.id(),
                            minimum_req_role,
                            origin,
                            member_role);
@@ -81,7 +81,7 @@ pub fn authorize_session(req: &HttpRequest,
             }
             None => {
                 debug!("authorize_session: account {} is not a member of the origin {}",
-                       session.get_id(),
+                       session.id(),
                        origin);
                 return Err(Error::Authorization);
             }

components/builder-api/src/server/authorize.rs

@@ -66,7 +66,7 @@ pub enum Error {
     PackageUpload(Box<SdkError<PutObjectError>>),
     PartialUpload(Box<SdkError<UploadPartError>>),
     PayloadError(actix_web::error::PayloadError),
-    Protobuf(protobuf::ProtobufError),
+    Protobuf(protobuf::Error),
     SerdeJson(serde_json::Error),
     System,
     TLSError(openssl::error::ErrorStack),
@@ -224,8 +224,8 @@ impl From<actix_web::error::PayloadError> for Error {
     fn from(err: actix_web::error::PayloadError) -> Error { Error::PayloadError(err) }
 }
 
-impl From<protobuf::ProtobufError> for Error {
-    fn from(err: protobuf::ProtobufError) -> Error { Error::Protobuf(err) }
+impl From<protobuf::Error> for Error {
+    fn from(err: protobuf::Error) -> Error { Error::Protobuf(err) }
 }
 
 impl From<db::error::Error> for Error {

components/builder-api/src/server/error.rs

@@ -111,7 +111,7 @@ fn validate_token_and_create_session(token: &str,
 
     trace!("Found valid session for {} tied to account {}",
            token,
-           session.get_id());
+           session.id());
 
     // Handle special builder account case
     if let Some(builder_session) = handle_builder_account(&mut session, token, state) {
@@ -126,7 +126,7 @@ fn handle_builder_account(session: &mut originsrv::Session,
                           token: &str,
                           state: &AppState)
                           -> Option<originsrv::Session> {
-    if session.get_id() == BUILDER_ACCOUNT_ID {
+    if session.id() == BUILDER_ACCOUNT_ID {
         trace!("Builder token identified");
         session.set_name(BUILDER_ACCOUNT_NAME.to_owned());
         state.memcache
@@ -146,11 +146,11 @@ fn validate_database_token(token: &str,
     let mut conn = state.db.get_conn().map_err(error::Error::DbError)?;
 
     let access_tokens =
-        match AccountToken::list(session.get_id(), &mut conn).map_err(error::Error::DieselError) {
+        match AccountToken::list(session.id(), &mut conn).map_err(error::Error::DieselError) {
             Ok(tokens) => tokens,
             Err(e) => {
                 trace!("Failed to list access tokens for user {}: {:?}",
-                       session.get_id(),
+                       session.id(),
                        e);
                 return Err(error::Error::Authorization);
             }
@@ -168,7 +168,7 @@ fn validate_token_count_and_match(token: &str,
     if access_tokens.len() > 1 {
         error!("Found {} tokens for user {} but there should only be one",
                access_tokens.len(),
-               session.get_id());
+               session.id());
         return Err(error::Error::Authorization);
     }
 
@@ -183,7 +183,7 @@ fn validate_token_count_and_match(token: &str,
         trace!("Different token {} found for user {}. Token is valid but revoked or otherwise \
                 expired",
                new_token,
-               session.get_id());
+               session.id());
         return Err(error::Error::Authorization);
     }
 
@@ -196,11 +196,11 @@ fn finalize_session_with_account(_token: &str,
                                  conn: &mut diesel::PgConnection,
                                  state: &AppState)
                                  -> error::Result<originsrv::Session> {
-    let account = Account::get_by_id(session.get_id() as i64, conn).map_err(|e| {
+    let account = Account::get_by_id(session.id() as i64, conn).map_err(|e| {
                                                                        trace!("Failed to find \
                                                                                account for id \
                                                                                {}: {:?}",
-                                                                              session.get_id(),
+                                                                              session.id(),
                                                                               e);
                                                                        error::Error::Authorization
                                                                    })?;
@@ -260,7 +260,7 @@ pub fn session_create_oauth(oauth_token: &str,
             debug!("issuing session, {:?}", session);
             state.memcache
                  .borrow_mut()
-                 .set_session(session.get_token(), &session, Some(*SESSION_DURATION));
+                 .set_session(session.token(), &session, Some(*SESSION_DURATION));
             Ok(session)
         }
         Err(e) => {

components/builder-api/src/server/framework/middleware.rs

@@ -144,7 +144,7 @@ async fn create_channel(req: HttpRequest,
 
     let session_id =
         match authorize_session(&req, Some(&origin), Some(OriginMemberRole::Maintainer)) {
-            Ok(session) => session.get_id(),
+            Ok(session) => session.id(),
             Err(_) => return HttpResponse::new(StatusCode::UNAUTHORIZED),
         };
 
@@ -229,7 +229,7 @@ async fn promote_channel_packages(req: HttpRequest,
                                                 &ch_target,
                                                 &origin,
                                                 true,
-                                                session.get_id() as i64)
+                                                session.id() as i64)
     {
         Ok(pkg_ids) => {
             match PackageGroupChannelAudit::audit(
@@ -239,8 +239,8 @@ async fn promote_channel_packages(req: HttpRequest,
                     package_ids: pkg_ids,
                     operation: PackageChannelOperation::Promote,
                     trigger: helpers::trigger_from_request_model(&req),
-                    requester_id: session.get_id() as i64,
-                    requester_name: session.get_name(),
+                    requester_id: session.id() as i64,
+                    requester_name: session.name(),
                     group_id: 0_i64,
                 },
                 &mut conn,
@@ -282,7 +282,7 @@ async fn demote_channel_packages(req: HttpRequest,
                                                 &ch_target,
                                                 &origin,
                                                 false,
-                                                session.get_id() as i64)
+                                                session.id() as i64)
     {
         Ok(pkg_ids) => {
             match PackageGroupChannelAudit::audit(
@@ -292,8 +292,8 @@ async fn demote_channel_packages(req: HttpRequest,
                     package_ids: pkg_ids,
                     operation: PackageChannelOperation::Demote,
                     trigger: helpers::trigger_from_request_model(&req),
-                    requester_id: session.get_id() as i64,
-                    requester_name: session.get_name(),
+                    requester_id: session.id() as i64,
+                    requester_name: session.name(),
                     group_id: 0_i64,
                 },
                 &mut conn,
@@ -426,8 +426,8 @@ async fn promote_package(req: HttpRequest,
                                            operation:      PackageChannelOperation::Promote,
                                            trigger:
                                                helpers::trigger_from_request_model(&req),
-                                           requester_id:   session.get_id() as i64,
-                                           requester_name: session.get_name(),
+                                           requester_id:   session.id() as i64,
+                                           requester_name: session.name(),
                                            origin:         &origin, };
 
     match OriginChannelPackage::promote(
@@ -520,8 +520,8 @@ async fn demote_package(req: HttpRequest,
                     channel: channel.as_str(),
                     operation: PackageChannelOperation::Demote,
                     trigger: helpers::trigger_from_request_model(&req),
-                    requester_id: session.get_id() as i64,
-                    requester_name: session.get_name(),
+                    requester_id: session.id() as i64,
+                    requester_name: session.name(),
                     origin: &origin,
                 },
                 &mut conn,
@@ -725,7 +725,7 @@ fn do_get_latest_channel_packages(req: &HttpRequest,
                                   channel: &ChannelIdent)
                                   -> Result<(String, String, Vec<BuilderPackageIdent>)> {
     let opt_session_id = match authorize_session(req, None, None) {
-        Ok(session) => Some(session.get_id()),
+        Ok(session) => Some(session.id()),
         Err(_) => None,
     };
 
@@ -758,7 +758,7 @@ fn do_get_channel_packages(req: &HttpRequest,
                            channel: &ChannelIdent)
                            -> Result<(Vec<BuilderPackageIdent>, i64)> {
     let opt_session_id = match authorize_session(req, None, None) {
-        Ok(session) => Some(session.get_id()),
+        Ok(session) => Some(session.id()),
         Err(_) => None,
     };
     let (page, per_page) = helpers::extract_pagination_in_pages(pagination);
@@ -801,7 +801,7 @@ fn do_get_channel_package(req: &HttpRequest,
                           channel: &ChannelIdent)
                           -> Result<String> {
     let opt_session_id = match authorize_session(req, None, None) {
-        Ok(session) => Some(session.get_id()),
+        Ok(session) => Some(session.id()),
         Err(_) => None,
     };
     Counter::GetChannelPackage.increment();
@@ -913,7 +913,7 @@ pub fn channels_for_package_ident(req: &HttpRequest,
                                   conn: &mut PgConnection)
                                   -> Result<Option<Vec<String>>> {
     let opt_session_id = match authorize_session(req, None, None) {
-        Ok(session) => Some(session.get_id()),
+        Ok(session) => Some(session.id()),
         Err(_) => None,
     };
 

components/builder-api/src/server/resources/channels.rs

@@ -125,7 +125,7 @@ fn do_get_events(req: &HttpRequest,
                  search_query: &Query<SearchQuery>)
                  -> Result<(Vec<AuditPackageEvent>, i64)> {
     let opt_session_id = match authorize_session(req, None, None) {
-        Ok(session) => Some(session.get_id() as i64),
+        Ok(session) => Some(session.id() as i64),
         Err(_) => None,
     };
     let (page, per_page) = helpers::extract_pagination_in_pages(pagination);

components/builder-api/src/server/resources/events.rs

@@ -90,7 +90,7 @@ fn filtered_rdeps(req: &HttpRequest,
 
     for rdep in reverse_dependencies.rdeps.iter() {
         let ident = OriginPackageIdent::from_str(rdep)?;
-        let origin_name = ident.get_origin();
+        let origin_name = ident.origin();
         let pv = if !origin_map.contains_key(origin_name) {
             let mut conn = req_state(req).db.get_conn().map_err(Error::DbError)?;
             let origin = Origin::get(origin_name, &mut conn)?;