}).fail( function(){
console.log('pullImage', image);
docker.pull(image, function(err,stream){
var error = false;
if(err){
console.log('err',err);
reject(err);
}
stream.on('data', function(data){
var response = JSON.parse(data.toString());
if(response.errorDetail != undefined){
error = response;
}else{
console.log(response);
}
});
stream.on('end', function(data){
if(error){
reject(error);
}else{
resolve();
}
});
});
})
async.eachSeries(list, function(tag, doneThis) {
docker.pull(tag, function(err, stream) {
if (err) {
doneThis(err);
} else {
stream.pipe(process.stdout);
stream.on('end', doneThis);
}
});
}, callback);
}}, (err) => {
if (err) {
logRed(version + '\t| Something went wrong in copying files...')
callback(err, 1)
}
// TODO remove sync operations like these
fs.writeFileSync(new_directory + '/Dockerfile', DOCKERFILE_TEMPLATE.replace('$VERSION', version))
logMagenta(version + '\t| Pulling base image for version')
docker.pull(`${BASE_IMAGE}:${version}`, (err, stream) => {
// TODO extract error handling
if (err) {
logRed(version + '\t| Something went wrong in pulling image...')
callback(err, 1)
}
docker.modem.followProgress(stream, () => {
const tarStream = tar.pack(new_directory, {
ignoreFiles: ['.gitignore', '.dockerignore']
})
const img_name_with_version = IMAGE_NAME.replace('$VERSION', version)
logYellow(version + '\t| Building image')
docker.buildImage(tarStream, {
t: img_name_with_version
}, (error, output) => {
if (error) {
logRed(version + '\t| Something went wrong in building image...')
callback(error, 1)
}
docker.modem.followProgress(output, () => {
logBlue(version + '\t| finished building, running tests...')
docker.run(img_name_with_version, TEST_COMMAND, show_output ? process.stdout : null, (err, data, container) => {
if (err) {
logRed(version + '\t| Something went wrong in running container...')
callback(err, 1)
}
// TODO implement proper cleanup
// fs.remove(new_directory)
logGreen(version + '\t| Done running tests for version ' + version + '!')
callback(null, {statusCode: data.StatusCode, version: version})
})
}, (chunk) => {
// Building container
if (show_output) {
process.stdout.write(version + '\t| ' + chunk.stream)
}
})
})
}, (chunk) => {
// Pulling image
if (show_output) {
console.log(version + '\t| ' + chunk.status)
}
})
})
})
return new Promise(function (resolve, reject) {
docker.pull(imageName, {
authconfig: auth
}, function (err, stream) {
if (err) return reject(err)
docker.modem.followProgress(stream, function (err, data) {
if (err) return reject(err)
resolve(data)
}, onProgress)
})
})
_pullImage(imageName) {
return this.docker.pull(imageName).then(stream => {
let promise = streamToPromise(stream);
Ora.promise(promise, {
text: chalk.green("Downloading the Docker Image..."),
color: "green",
stream: process.stdout
});
return promise;
});
}
function pullImage(imageName, callback) {
docker.pull(imageName, function(err, stream) {
if (err) {
callback(err);
} else {
stream.pipe(process.stdout);
stream.on('end', function() {
callback(null);
});
}
});
}
/**
* Pull docker image
* @param image
* @param callback
*/
pull(image, callback) {
this.dockerRemoteAPI.pull(image, (err, stream) => {
this.dockerRemoteAPI.modem.followProgress(stream, (err, output) => {
if (err) {
callback.onError(err);
} else {
callback.onFinished();
}
}, (event) => {
callback.onProgress(event);
});
});
}
(callback) => {
docker.pull(question.external_grading_image, (err, stream) => {
if (err) {
logger.warn(`Error pulling "${question.external_grading_image}" image; attempting to fall back to cached version.`);
logger.warn(err);
return callback(null);
}
docker.modem.followProgress(stream, (err) => {
if (ERR(err, callback)) return;
callback(null);
}, (output) => {
logger.info(output);
});
});
},
pull: function(cb) {
docker.pull('sitespeedio/sitespeed.io', function(err, stream) {
docker.modem.followProgress(stream, onFinished, onProgress);
function onFinished(err, output) {
if (err) {
log.error('Error:' + err);
}
cb(err);
}
function onProgress(event) {
log.debug(event.status);
}
});
},
/**
* Download the `mockserver` Docker image, create a new container and start it.
*/
async function start() {
await getStream(await docker.pull(IMAGE));
container = await docker.createContainer({
Tty: true,
Image: IMAGE,
PortBindings: {[`${MOCK_SERVER_PORT}/tcp`]: [{HostPort: `${MOCK_SERVER_PORT}`}]},
});
await container.start();
try {
// Wait for the mock server to be ready
await pRetry(() => got.put(`http://${MOCK_SERVER_HOST}:${MOCK_SERVER_PORT}/status`, {cache: false}), {
retries: 7,
minTimeout: 1000,
factor: 2,
});
} catch (error) {
throw new Error(`Couldn't start mock-server after 2 min`);
}
}
/**
* Download the `npm-registry-docker` Docker image, create a new container and start it.
*/
async function start() {
await getStream(await docker.pull(IMAGE));
container = await docker.createContainer({
Tty: true,
Image: IMAGE,
PortBindings: {[`${COUCHDB_PORT}/tcp`]: [{HostPort: `${SERVER_PORT}`}]},
Env: [`COUCHDB_USER=${COUCHDB_USER}`, `COUCHDB_PASSWORD=${COUCHDB_PASSWORD}`],
});
await container.start();
await delay(4000);
try {
// Wait for the registry to be ready
await pRetry(() => got(`http://${SERVER_HOST}:${SERVER_PORT}/registry/_design/app`, {cache: false}), {
retries: 7,
minTimeout: 1000,
factor: 2,
});
} catch (error) {
throw new Error(`Couldn't start npm-registry-docker after 2 min`);
}
// Create user
await got(`http://${SERVER_HOST}:${SERVER_PORT}/_users/org.couchdb.user:${NPM_USERNAME}`, {
json: true,
auth: `${COUCHDB_USER}:${COUCHDB_PASSWORD}`,
method: 'PUT',
body: {
_id: `org.couchdb.user:${NPM_USERNAME}`,
name: NPM_USERNAME,
roles: [],
type: 'user',
password: NPM_PASSWORD,
email: NPM_EMAIL,
},
});
}