@@ -36,4 +36,9 @@
 <method>com.google.api.services.storage.model.StorageObject queryCompletedResumableUpload(java.lang.String, long)</method>
 <differenceType>7012</differenceType>
 </difference>
+<difference>
+<className>com/google/cloud/storage/BucketInfo$LifecycleRule$LifecycleAction</className>
+<method>BucketInfo$LifecycleRule$LifecycleAction()</method>
+<differenceType>7004</differenceType>
+</difference>
 </differences>

@@ -548,8 +548,13 @@ static LifecycleRule fromPb(Rule rule) {
 StorageClass.valueOf(action.getStorageClass()));
 break;
 default:
-throw new UnsupportedOperationException(
-"The specified lifecycle action " + action.getType() + " is not currently supported");
+log.warning(
+"The lifecycle action "
++ action.getType()
++ " is not supported by this version of the library. "
++ "Attempting to update with this rule may cause errors. Please "
++ "update to the latest version of google-cloud-storage.");
+lifecycleAction = LifecycleAction.newLifecycleAction("Unknown action");
 }
 
 Rule.Condition condition = rule.getCondition();
@@ -799,13 +804,21 @@ public LifecycleCondition build() {
 }
 
 /**
-* Base class for the Action to take when a Lifecycle Condition is met. Specific Actions are
+* Base class for the Action to take when a Lifecycle Condition is met. Supported Actions are
 * expressed as subclasses of this class, accessed by static factory methods.
 */
-public abstract static class LifecycleAction implements Serializable {
+public static class LifecycleAction implements Serializable {
 private static final long serialVersionUID = 5801228724709173284L;
 
-public abstract String getActionType();
+private final String actionType;
+
+public LifecycleAction(String actionType) {
+this.actionType = actionType;
+}
+
+public String getActionType() {
+return actionType;
+}
 
 @Override
 public String toString() {
@@ -830,17 +843,24 @@ public static SetStorageClassLifecycleAction newSetStorageClassAction(
 StorageClass storageClass) {
 return new SetStorageClassLifecycleAction(storageClass);
 }
+
+/**
+* Creates a new {@code LifecycleAction , with no specific supported action associated with it. This
+* is only intended as a "backup" for when the library doesn't recognize the type, and should
+* generally not be used, instead use the supported actions, and upgrade the library if necessary
+* to get new supported actions.
+*/
+public static LifecycleAction newLifecycleAction(String actionType) {
+return new LifecycleAction(actionType);
+}
 }
 
 public static class DeleteLifecycleAction extends LifecycleAction {
 public static final String TYPE = "Delete";
 private static final long serialVersionUID = -2050986302222644873L;
 
-private DeleteLifecycleAction() {}
-
-@Override
-public String getActionType() {
-return TYPE;
+private DeleteLifecycleAction() {
+super(TYPE);
 }
 }
 
@@ -851,14 +871,10 @@ public static class SetStorageClassLifecycleAction extends LifecycleAction {
 private final StorageClass storageClass;
 
 private SetStorageClassLifecycleAction(StorageClass storageClass) {
+super(TYPE);
 this.storageClass = storageClass;
 }
 
-@Override
-public String getActionType() {
-return TYPE;
-}
-
 @Override
 public String toString() {
 return MoreObjects.toStringHelper(this)
@@ -1007,7 +1023,11 @@ static class RawDeleteRule extends DeleteRule {
 
 @Override
 void populateCondition(Rule.Condition condition) {
-throw new UnsupportedOperationException();
+log.warning(
+"The lifecycle condition "
++ condition
++ " is not currently supported. Please update to the latest version of google-cloud-java."
++ " Also, use LifecycleRule rather than the deprecated DeleteRule.");
 }
 
 private void writeObject(ObjectOutputStream out) throws IOException {

@@ -314,6 +314,10 @@ public void testDeleteRules() {
 for (DeleteRule delRule : rules) {
 assertEquals(delRule, DeleteRule.fromPb(delRule.toPb()));
 }
+Rule unsupportedRule =
+new Rule().setAction(new Rule.Action().setType("This action doesn't exist"));
+DeleteRule.fromPb(
+unsupportedRule); // if this doesn't throw an exception, unsupported rules work
 }
 
 @Test
@@ -363,6 +367,17 @@ public void testLifecycleRules() {
 assertEquals(StorageClass.COLDLINE.toString(), lifecycleRule.getAction().getStorageClass());
 assertEquals(30, lifecycleRule.getCondition().getDaysSinceCustomTime().intValue());
 assertNotNull(lifecycleRule.getCondition().getCustomTimeBefore());
+
+Rule unsupportedRule =
+new LifecycleRule(
+LifecycleAction.newLifecycleAction("This action type doesn't exist"),
+LifecycleCondition.newBuilder().setAge(10).build())
+.toPb();
+unsupportedRule.setAction(
+unsupportedRule.getAction().setType("This action type also doesn't exist"));
+
+LifecycleRule.fromPb(
+unsupportedRule); // If this doesn't throw an exception, unsupported rules are working
 }
 
 @Test