makedrive/lib/syncmessage.js

Webmaker Filesystem

// Constructor
function SyncMessage(type, name, content) {
  if(!SyncMessage.isValidType(type)) {
    throw "Invalid type";
  }
  if(!SyncMessage.isValidName(name)) {
    throw "Invalid name";
  }

  this.type = type;
  this.name = name;
  this.content = content || null;

  // Sugar for testing instance data
  var that = this;
  this.is = {
    // Types
    get request() {
      return that.type === SyncMessage.REQUEST;
    },
    get response() {
      return that.type === SyncMessage.RESPONSE;
    },
    get error() {
      return that.type === SyncMessage.ERROR;
    },

    // Names
    get srclist() {
      return that.name === SyncMessage.SRCLIST;
    },
    get sync() {
      return that.name === SyncMessage.SYNC;
    },
    get chksum() {
      return that.name === SyncMessage.CHKSUM;
    },
    get diffs() {
      return that.name === SyncMessage.DIFFS;
    },
    get patch() {
      return that.name === SyncMessage.PATCH;
    },
    get verification() {
      return that.name === SyncMessage.VERIFICATION;
    },
    get reset() {
      return that.name === SyncMessage.RESET;
    },
    get locked() {
      return that.name === SyncMessage.LOCKED;
    },
    get authz() {
      return that.name === SyncMessage.AUTHZ;
    },
    get impl() {
      return that.name === SyncMessage.IMPL;
    },
    get serverReset() {
      return that.name === SyncMessage.SERVER_RESET;
    },
    get downstreamLocked() {
      return that.name === SyncMessage.DOWNSTREAM_LOCKED;
    },
    get fileSizeError() {
      return that.type === SyncMessage.ERROR && that.name === SyncMessage.MAXSIZE;
    }
  };
}

SyncMessage.isValidName = function(name) {
  return name === SyncMessage.SRCLIST      ||
         name === SyncMessage.CHKSUM       ||
         name === SyncMessage.DIFFS        ||
         name === SyncMessage.LOCKED       ||
         name === SyncMessage.PATCH        ||
         name === SyncMessage.VERIFICATION ||
         name === SyncMessage.SYNC         ||
         name === SyncMessage.RESET        ||
         name === SyncMessage.AUTHZ        ||
         name === SyncMessage.IMPL         ||
         name === SyncMessage.INFRMT       ||
         name === SyncMessage.INCONT       ||
         name === SyncMessage.SERVER_RESET ||
         name === SyncMessage.DOWNSTREAM_LOCKED ||
         name === SyncMessage.MAXSIZE;
};

SyncMessage.isValidType = function(type) {
  return type === SyncMessage.REQUEST  ||
         type === SyncMessage.RESPONSE ||
         type === SyncMessage.ERROR;
};

SyncMessage.prototype.stringify = function() {
  return JSON.stringify({
    type: this.type,
    name: this.name,
    content: this.content
  });
};

// Try to parse data back into a SyncMessage object. If the
// data is invalid, return a format error message instead.
SyncMessage.parse = function(data) {
  if(!data                               ||
     !SyncMessage.isValidType(data.type) ||
     !SyncMessage.isValidName(data.name)) {
    return SyncMessage.error.format;
  }

  return new SyncMessage(data.type, data.name, data.content);
};

// SyncMessage Type constants
SyncMessage.REQUEST = "REQUEST";
SyncMessage.RESPONSE = "RESPONSE";
SyncMessage.ERROR = "ERROR";

// SyncMessage Name constants
SyncMessage.SRCLIST = "SRCLIST";
SyncMessage.SYNC = "SYNC";
SyncMessage.CHKSUM = "CHKSUM";
SyncMessage.DIFFS = "DIFFS";
SyncMessage.PATCH = "PATCH";
SyncMessage.VERIFICATION = "VERIFICATION";
SyncMessage.RESET = "RESET";
SyncMessage.LOCKED = "LOCKED";
SyncMessage.AUTHZ = "AUTHORIZED";
SyncMessage.IMPL = "IMPLEMENTATION";
SyncMessage.SERVER_RESET = "SERVER_RESET";
SyncMessage.DOWNSTREAM_LOCKED = "DOWNSTREAM_LOCKED";
SyncMessage.MAXSIZE = "MAXSIZE";
SyncMessage.INTERRUPTED = "INTERRUPTED";

// SyncMessage Error constants
SyncMessage.INFRMT = "INVALID FORMAT";
SyncMessage.INCONT = "INVALID CONTENT";

// Sugar for getting message instances
SyncMessage.request = {
  get diffs() {
    return new SyncMessage(SyncMessage.REQUEST, SyncMessage.DIFFS);
  },
  get chksum() {
    return new SyncMessage(SyncMessage.REQUEST, SyncMessage.CHKSUM);
  },
  get sync() {
    return new SyncMessage(SyncMessage.REQUEST, SyncMessage.SYNC);
  },
  get reset() {
    return new SyncMessage(SyncMessage.REQUEST, SyncMessage.RESET);
  }
};
SyncMessage.response = {
  get diffs() {
    return new SyncMessage(SyncMessage.RESPONSE, SyncMessage.DIFFS);
  },
  get patch() {
    return new SyncMessage(SyncMessage.RESPONSE, SyncMessage.PATCH);
  },
  get verification() {
    return new SyncMessage(SyncMessage.RESPONSE, SyncMessage.VERIFICATION);
  },
  get authz() {
    return new SyncMessage(SyncMessage.RESPONSE, SyncMessage.AUTHZ);
  },
  get sync() {
    return new SyncMessage(SyncMessage.RESPONSE, SyncMessage.SYNC);
  },
  get reset() {
    return new SyncMessage(SyncMessage.RESPONSE, SyncMessage.RESET);
  }
};
SyncMessage.error = {
  get srclist() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.SRCLIST);
  },
  get diffs() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.DIFFS);
  },
  get locked() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.LOCKED);
  },
  get chksum() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.CHKSUM);
  },
  get patch() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.PATCH);
  },
  get impl() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.IMPL);
  },
  get serverReset() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.SERVER_RESET);
  },
  get downstreamLocked() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.DOWNSTREAM_LOCKED, 'Downstream syncs are locked!');
  },
  get maxsizeExceeded() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.MAXSIZE, 'Maximum file size exceeded');
  },
  get verification() {
    return new SyncMessage(SyncMessage.ERROR,
                           SyncMessage.VERIFICATION,
                           'Patch could not be verified');
  },
  get format() {
    return new SyncMessage(SyncMessage.ERROR,
                           SyncMessage.INFRMT,
                           'Message must be formatted as a sync message');
  },
  get content() {
    return new SyncMessage(SyncMessage.ERROR,
                           SyncMessage.INCONT,
                           'Invalid content provided');
  },
  get interrupted() {
    return new SyncMessage(SyncMessage.ERROR, SyncMessage.INTERRUPTED);
  }
};

module.exports = SyncMessage;