526 lines
22 KiB
JavaScript
526 lines
22 KiB
JavaScript
var repoindex = (function() {
|
|
|
|
// a list of all possible connection states
|
|
repoindex.ConnectionStatus = {
|
|
Disconnected: "Disconnected",
|
|
Connecting: "Connecting",
|
|
Connected: "Connected"
|
|
};
|
|
|
|
// a list of all possible request/response types
|
|
repoindex.RequestType = {
|
|
BasicRepoInfo: "basicrepoinfo",
|
|
BasicPackageInfo: "basicpkginfo",
|
|
FullPackageInfo: "fullpkginfo",
|
|
GroupInfo: "groupinfo",
|
|
UpgradeLookup: "upgradelookup",
|
|
Suggestions: "suggestions",
|
|
Postponed: "postponed"
|
|
};
|
|
|
|
repoindex.isLoopback = function(domain) {
|
|
return domain === "localhost" || domain === "127.0.0.1" || domain === "::1";
|
|
};
|
|
|
|
// responsible for the connection to the server; holds all repo/package information returned by the server
|
|
var Client = function(url) {
|
|
// basic initialization
|
|
this.url = url;
|
|
this.socket = undefined;
|
|
this.hasBasicRepoInfo = false;
|
|
this.hasGroupInfo = false;
|
|
this.scheduledRequests = [];
|
|
this.sentRequests = [];
|
|
this.repos = {};
|
|
|
|
// define functions control the connections
|
|
this.resetReconnectTries = function(tries) {
|
|
if(tries !== undefined && tries >= 0) {
|
|
this.remainingReconnectTries = this.reconnectTries = tries;
|
|
} else {
|
|
this.remainingReconnectTries = this.reconnectTries;
|
|
}
|
|
};
|
|
this.resetReconnectTries(2);
|
|
|
|
this.reconnect = function() {
|
|
if(this.remainingReconnectTries > 0) {
|
|
--this.remainingReconnectTries;
|
|
var reconnectTimer = window.setInterval(function() {
|
|
window.clearInterval(reconnectTimer);
|
|
repoindex.client.init();
|
|
}, 5000);
|
|
}
|
|
};
|
|
|
|
this.init = function() {
|
|
repoindex.pageManager.setConnectionStatus(repoindex.ConnectionStatus.Connecting);
|
|
if(typeof WebSocket != 'function' && typeof MozWebSocket == 'function') {
|
|
WebSocket = MozWebSocket;
|
|
}
|
|
if(this.socket && this.socket.readyState === 1) {
|
|
this.socket.onclose = function() {
|
|
this.client.init();
|
|
};
|
|
this.socket.close();
|
|
return;
|
|
}
|
|
this.socket = new WebSocket(this.url);
|
|
this.socket.client = this;
|
|
|
|
this.socket.onopen = function(event) {
|
|
repoindex.pageManager.setConnectionStatus(repoindex.ConnectionStatus.Connected);
|
|
this.client.resetReconnectTries();
|
|
this.client.doScheduledRequests();
|
|
};
|
|
|
|
this.socket.onclose = function(event) {
|
|
repoindex.pageManager.setConnectionStatus(repoindex.ConnectionStatus.Disconnected);
|
|
this.client.reconnect();
|
|
};
|
|
|
|
this.socket.onmessage = function(event) {
|
|
var msg = JSON.parse(event.data);
|
|
switch(msg.class) {
|
|
case "error":
|
|
repoindex.pageManager.addError("Server replied error: " + msg.msg);
|
|
break;
|
|
case "results":
|
|
this.client.parseResults(msg.id, msg.what, msg.values ? msg.values : msg.value);
|
|
break;
|
|
}
|
|
};
|
|
|
|
this.socket.onerror = function(event) {
|
|
repoindex.pageManager.addError("Connecting to server failed: " + event.reason);
|
|
repoindex.pageManager.setConnectionStatus(repoindex.ConnectionStatus.Disconnected);
|
|
};
|
|
};
|
|
|
|
this.isOpen = function() {
|
|
return this.socket.readyState === 1;
|
|
};
|
|
|
|
this.stop = function() {
|
|
if(this.socket) {
|
|
this.socket.close();
|
|
}
|
|
};
|
|
|
|
// define functions to manage requests
|
|
this.requestById = function(id) {
|
|
if(id) {
|
|
var i;
|
|
// check scheduled requests as well as sent requests
|
|
for(i = 0; i < this.scheduledRequests.length; ++i) {
|
|
if(this.scheduledRequests[i].params.id === id) {
|
|
return this.scheduledRequests[i];
|
|
}
|
|
}
|
|
for(i = 0; i < this.sentRequests.length; ++i) {
|
|
if(this.sentRequests[i].params.id === id) {
|
|
return this.sentRequests[i];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
this.scheduleRequest = function(type, params, callback) {
|
|
// add request information to params
|
|
params.class = "query";
|
|
params.what = type;
|
|
// check whether the same kind of request has already been scheduled
|
|
var i = 0;
|
|
switch(type) {
|
|
case repoindex.RequestType.BasicRepoInfo:
|
|
case repoindex.RequestType.GroupInfo:
|
|
// -> upgrade existing reuquest in this case
|
|
for(; i < this.scheduledRequests.length; ++i) {
|
|
if(this.scheduledRequests[i].params.class === "query" && this.scheduledRequests[i].params.what === type) {
|
|
// there is already such a request
|
|
this.scheduledRequests[i].callbacks.push(callback); // add callback
|
|
params.id = this.scheduledRequests[i].params.id; // keep the old ID
|
|
this.scheduledRequests[i].params = params; // upgrade params
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
// -> other request types can't be upgraded
|
|
i = this.scheduledRequests.length;
|
|
}
|
|
if(i >= this.scheduledRequests.length) {
|
|
// a new request is required
|
|
// -> add callback array
|
|
var callbacks = [];
|
|
if(callback) {
|
|
callbacks.push(callback);
|
|
}
|
|
// -> add unique request ID
|
|
while(this.requestById(params.id = repoindex.makeId()));
|
|
// -> schedule request
|
|
this.scheduledRequests.push({params: params, sent: false, callbacks: callbacks});
|
|
}
|
|
// try to send scheduled requests
|
|
this.doScheduledRequests();
|
|
};
|
|
|
|
this.doScheduledRequests = function() {
|
|
// can only send requests if connection is established
|
|
if(this.isOpen()) {
|
|
while(this.scheduledRequests.length > 0) {
|
|
var request = this.scheduledRequests.shift();
|
|
request.sent = true;
|
|
this.sentRequests.push(request);
|
|
this.socket.send(JSON.stringify(request.params));
|
|
}
|
|
}
|
|
};
|
|
|
|
this.parseResults = function(id, what, values) {
|
|
if(!what) {
|
|
repoindex.pageManager.addError("Server replied insufficiant results.");
|
|
} else if(!values) {
|
|
repoindex.pageManager.addError("Server replied \"" + what + "\" with insufficiant data.");
|
|
} else {
|
|
var request = this.requestById(id);
|
|
if(!id || (request && request.sent)) {
|
|
// use the received information
|
|
switch(what) {
|
|
case repoindex.RequestType.BasicRepoInfo:
|
|
this.useBasicRepoInfo(values);
|
|
break;
|
|
case repoindex.RequestType.BasicPackageInfo:
|
|
this.usePackageInfo(values);
|
|
break;
|
|
case repoindex.RequestType.FullPackageInfo:
|
|
this.usePackageInfo(values);
|
|
break;
|
|
case repoindex.RequestType.GroupInfo:
|
|
this.useGroupInfo(values);
|
|
break;
|
|
case repoindex.RequestType.UpgradeLookup:
|
|
// the info is used via the registred callbacks only
|
|
break;
|
|
case repoindex.RequestType.Suggestions:
|
|
this.useSuggestions(values);
|
|
break;
|
|
case repoindex.RequestType.Postponed:
|
|
// server is busy, but will send results later
|
|
pageManager.addError("The server is busy.");
|
|
// -> do not call the callbacks already
|
|
request = undefined;
|
|
break;
|
|
default:
|
|
pageManager.addError("Server replied unknown results: " + what);
|
|
return; // don't invoke callbacks when results are of unknown type
|
|
}
|
|
if(request) {
|
|
// also invoke callbacks registred for this request
|
|
for(var i = 0; i < request.callbacks.length; ++i) {
|
|
request.callbacks[i](values);
|
|
}
|
|
// TODO: remove request object from list of sent requests
|
|
}
|
|
} else {
|
|
repoindex.pageManager.addError("Server replied \"" + what + "\" with unknown ID.");
|
|
}
|
|
}
|
|
};
|
|
|
|
// define functions to perform several requests
|
|
this.requestBasicRepoInfo = function(callback) {
|
|
this.scheduleRequest(repoindex.RequestType.BasicRepoInfo, {updates: true}, callback);
|
|
};
|
|
|
|
this.requestBasicPackagesInfo = function(packageSelection, callback) {
|
|
this.scheduleRequest(repoindex.RequestType.BasicPackageInfo, {sel: packageSelection, updates: true}, callback);
|
|
};
|
|
|
|
this.requestFullPackagesInfo = function(packageSelection, callback) {
|
|
this.scheduleRequest(repoindex.RequestType.FullPackageInfo, {sel: packageSelection}, callback);
|
|
};
|
|
|
|
this.requestGroupInfo = function(callback) {
|
|
this.scheduleRequest(repoindex.RequestType.GroupInfo, {updates: true}, callback);
|
|
};
|
|
|
|
this.requestSuggestions = function(repoNames, searchTerm, callback) {
|
|
this.scheduleRequest(repoindex.RequestType.Suggestions, {repos: repoNames, term: searchTerm});
|
|
};
|
|
|
|
this.requestAurSuggestions = function(term) {
|
|
var xmlhttp = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");
|
|
xmlhttp.onreadystatechange = function() {
|
|
if(xmlhttp.readyState === 4 && xmlhttp.status === 200) {
|
|
repoindex.client.useAurSuggestions(JSON.parse(xmlhttp.responseText));
|
|
}
|
|
};
|
|
xmlhttp.open("GET", "http://aur.archlinux.org/rpc.php?type=suggest&arg=" + encodeURIComponent(term), true);
|
|
xmlhttp.send();
|
|
};
|
|
|
|
this.sendCmd = function(cmd) {
|
|
if(this.isOpen()) {
|
|
this.socket.send(JSON.stringify({class: "cmd", what: cmd}));
|
|
} else {
|
|
repoindex.pageManager.addError("Not connected to a server.");
|
|
}
|
|
};
|
|
|
|
this.stopServer = function() {
|
|
this.sendCmd("stop");
|
|
};
|
|
|
|
this.reinitAlpm = function() {
|
|
this.sendCmd("reinitalpm");
|
|
};
|
|
|
|
this.updateAlpm = function() {
|
|
this.sendCmd("updatealpm");
|
|
};
|
|
|
|
this.checkForUpgrades = function(dbName, syncdbNames, callback) {
|
|
var params = {
|
|
db: dbName
|
|
};
|
|
if(syncdbNames) {
|
|
params.syncdbs = syncdbNames;
|
|
}
|
|
this.scheduleRequest(repoindex.RequestType.UpgradeLookup, params, callback);
|
|
};
|
|
|
|
// define helper functions to access repo/package information
|
|
this.getPackageInfo = function(repoName, packageName) {
|
|
var repoInfo = this.repos[repoName];
|
|
if(!repoInfo) {
|
|
// the repo doesn't exists; might happen when receiving AUR suggestions directly
|
|
// -> just create a new, empty repo
|
|
this.repo[repoName] = (repoInfo = {name: repoName, packages: {}});
|
|
}
|
|
var packageInfo = repoInfo.packages[packageName];
|
|
if(!packageInfo) {
|
|
repoInfo.packages[packageName] = (packageInfo = {repo: repoName});
|
|
}
|
|
return packageInfo;
|
|
};
|
|
|
|
// define functions to use differend kinds of results
|
|
this.useBasicRepoInfo = function(value) {
|
|
if(!value) {
|
|
repoindex.pageManager.addError("Server replied insufficiant basic repo info.");
|
|
return false;
|
|
}
|
|
// upgrade repos and package list
|
|
this.repos = value;
|
|
var repoMgr = repoindex.pageManager.repoManager;
|
|
var pkgMgr = repoindex.pageManager.packageManager;
|
|
repoMgr.removeEntries();
|
|
pkgMgr.removeEntries();
|
|
var incomplete = false;
|
|
var reposInOrder = [];
|
|
for(var repoName in value) {
|
|
if(value.hasOwnProperty(repoName)) {
|
|
var info = value[repoName];
|
|
if(info.incomplete) {
|
|
incomplete = true;
|
|
} else {
|
|
reposInOrder.push({name: repoName, info: info});
|
|
}
|
|
}
|
|
}
|
|
reposInOrder.sort(function(lhs, rhs) {
|
|
if(lhs === rhs) {
|
|
return 1;
|
|
} else if(lhs.info.index !== undefined) {
|
|
if(rhs.info.index !== undefined) {
|
|
return lhs.info.index > rhs.info.index;
|
|
} else {
|
|
return -1;
|
|
}
|
|
} else if(rhs.info.index !== undefined) {
|
|
return 1;
|
|
} else {
|
|
return lhs.name > rhs.name;
|
|
}
|
|
});
|
|
for(var i = 0; i < reposInOrder.length; ++i) {
|
|
var repoName = reposInOrder[i].name;
|
|
var repoInfo = reposInOrder[i].info;
|
|
var repoEntry = repoMgr.addEntry(repoName, repoInfo);
|
|
var packages = repoInfo.packages;
|
|
for(var packageName in packages) {
|
|
if(value.hasOwnProperty(repoName)) {
|
|
var packageInfo = packages[packageName];
|
|
pkgMgr.addEntry(repoEntry, packageName, packageInfo);
|
|
}
|
|
}
|
|
}
|
|
if(incomplete) {
|
|
repoindex.pageManager.addError("Server replied incomplete repository info: Server is busy.");
|
|
}
|
|
this.hasBasicRepoInfo = true;
|
|
pkgMgr.invalidate();
|
|
repoMgr.invalidate();
|
|
repoMgr.applyRepoStatusChange();
|
|
};
|
|
|
|
this.usePackageInfo = function(values) {
|
|
if(!Array.isArray(values)) {
|
|
repoindex.pageManager.addError("Server replied insufficiant package info.");
|
|
return false;
|
|
}
|
|
for(var i = 0; i < values.length; ++i) {
|
|
var value = values[i];
|
|
var repo = repoindex.client.repos[value.repo];
|
|
if(repo) {
|
|
var package = repo.packages[value.name];
|
|
if(package) {
|
|
if(value.basics) {
|
|
package.basics = value.basics;
|
|
}
|
|
if(value.details) {
|
|
package.details = value.details;
|
|
}
|
|
} else {
|
|
repoindex.pageManager.addError("Package info replied by server refers to unknown package.");
|
|
}
|
|
} else {
|
|
repoindex.pageManager.addError("Package info replied by server refers to unknown repository.");
|
|
}
|
|
}
|
|
if(value.error) {
|
|
switch(value.error) {
|
|
case "na":
|
|
if(value.repo) {
|
|
if(value.name) {
|
|
repoindex.pageManager.addError("Server replied error: The package " + value.name + " doesn't exist in the repository " + value.repo + ".");
|
|
} else {
|
|
repoindex.pageManager.addError("Server replied error: The repository " + value.repo + " doesn't exist.");
|
|
}
|
|
} else {
|
|
repoindex.pageManager.addError("Server replied error: The requested info is not available.");
|
|
}
|
|
break;
|
|
case "busy":
|
|
repoindex.pageManager.addError("Server replied error in package info: The server is busy.");
|
|
break;
|
|
default:
|
|
repoindex.pageManager.addError("Server replied unknown error code in package info: " + value.error);
|
|
}
|
|
}
|
|
// updating table rows or any other GUI elements is done via callbacks
|
|
};
|
|
|
|
this.useGroupInfo = function(values) {
|
|
var groupMgr = repoindex.pageManager.groupManager;
|
|
groupMgr.removeEntries();
|
|
var incomplete = false;
|
|
var groupEntries = groupMgr.entries;
|
|
for(var i1 = 0; i1 < values.length; ++i1) {
|
|
var info = values[i1];
|
|
if(info.incomplete) {
|
|
incomplete = true;
|
|
}
|
|
if(info.repo && info.groups) {
|
|
for(var i2 = 0; i2 < info.groups.length; ++i2) {
|
|
var group = info.groups[i2];
|
|
groupMgr.addEntry(info.repo, group.name, group.pkgs);
|
|
}
|
|
}
|
|
}
|
|
if(incomplete) {
|
|
repoindex.pageManager.addError("Server replied incomplete group info: Server is busy.");
|
|
}
|
|
this.hasGroupInfo = true;
|
|
groupMgr.useRequestedData();
|
|
};
|
|
|
|
this.useSuggestions = function(values) {
|
|
if(Array.isArray(values)) {
|
|
for(var i1 = 0; i1 < values.length; ++i1) {
|
|
var value = values[i1];
|
|
var repoName = value.repo;
|
|
var suggestions = value.res;
|
|
if(Array.isArray(suggestions)) {
|
|
if(suggestions.length > 0) {
|
|
var repoEntry = repoindex.pageManager.repoManager.entryByName(repoName);
|
|
if(repoEntry) {
|
|
var pkgMgr = repoindex.pageManager.packageManager;
|
|
for(var i2 = 0; i2 < suggestions.length; ++i2) {
|
|
var packageName = suggestions[i2];
|
|
var entryExists = false;
|
|
for(var i = 0, len = pkgMgr.entries.length; i < len; ++i) {
|
|
var pkgEntry = pkgMgr.entries[i];
|
|
if(pkgEntry.name === packageName && pkgEntry.repoEntry.name === repoName) {
|
|
entryExists = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!entryExists) {
|
|
var packageInfo = this.getPackageInfo(repoName, packageName);
|
|
pkgMgr.addEntry(repoEntry, packageName, packageInfo);
|
|
}
|
|
}
|
|
pkgMgr.invalidate();
|
|
} else {
|
|
repoindex.pageManager.addError("There is no repo entry for the suggestions replied by the server.");
|
|
}
|
|
var entries = pkgMgr.entries;
|
|
entries.sort(function(lhs, rhs) {
|
|
return lhs.name > rhs.name;
|
|
});
|
|
for(var i = 0; i < entries.length; ++i) {
|
|
entries[i].index = i;
|
|
}
|
|
}
|
|
} else {
|
|
// TODO: handle error
|
|
}
|
|
}
|
|
} else if(Array.isArray(values.errors)) {
|
|
for(var i = 0; i < values.errors.length; ++i) {
|
|
repoindex.pageManager.addError("Error replied by server in response of suggestion request: " + value.errors[i]);
|
|
}
|
|
} else {
|
|
repoindex.pageManager.addError("Server replied insufficiant suggestion reply.");
|
|
}
|
|
};
|
|
|
|
this.useAurSuggestions = function(suggestions) {
|
|
if(Array.isArray(suggestions)) {
|
|
if(suggestions.length > 0) {
|
|
var aurEntry = repoindex.pageManager.repoManager.entryByName("AUR");
|
|
if(aurEntry) {
|
|
var pkgMgr = repoindex.pageManager.packageManager;
|
|
for(var i = 0; i < suggestions.length; ++i) {
|
|
var packageName = suggestions[i];
|
|
if(!pkgMgr.entryByName(packageName)) {
|
|
var packageInfo = this.getPackageInfo("AUR", packageName);
|
|
pkgMgr.addEntry(aurEntry, packageName, packageInfo);
|
|
}
|
|
}
|
|
pkgMgr.invalidate();
|
|
} else {
|
|
// there is no AUR entry but we requested AUR suggestions
|
|
// -> shouldn't happen
|
|
}
|
|
}
|
|
} else {
|
|
// TODO: handle error
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
// create a global client used within the entire document
|
|
repoindex.client = new Client((window.location.protocol === "https:" ? "wss://" : "ws://") + document.domain + ":1234");
|
|
if(!repoindex.isLoopback(document.domain)) {
|
|
// hide stop button if server is not on loopback interface
|
|
document.getElementById("nav_server").style.display = "none";
|
|
}
|
|
|
|
return repoindex;
|
|
|
|
})(repoindex || {});
|