Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tag: r1.8.4-rc0
Fetching contributors…

Cannot retrieve contributors at this time

241 lines (189 sloc) 8.472 kb
// engine.h
/* Copyright 2009 10gen Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "../pch.h"
#include "../db/jsobj.h"
namespace mongo {
struct JSFile {
const char* name;
const StringData& source;
};
namespace JSFiles {
extern const JSFile collection;
extern const JSFile db;
extern const JSFile mongo;
extern const JSFile mr;
extern const JSFile query;
extern const JSFile servers;
extern const JSFile utils;
}
typedef unsigned long long ScriptingFunction;
typedef BSONObj (*NativeFunction) ( const BSONObj &args );
class Scope : boost::noncopyable {
public:
Scope();
virtual ~Scope();
virtual void reset() = 0;
virtual void init( const BSONObj * data ) = 0;
void init( const char * data ) {
BSONObj o( data , 0 );
init( &o );
}
virtual void localConnect( const char * dbName ) = 0;
virtual void externalSetup() = 0;
class NoDBAccess {
Scope * _s;
public:
NoDBAccess( Scope * s ) {
_s = s;
}
~NoDBAccess() {
_s->rename( "____db____" , "db" );
}
};
NoDBAccess disableDBAccess( const char * why ) {
rename( "db" , "____db____" );
return NoDBAccess( this );
}
virtual double getNumber( const char *field ) = 0;
virtual int getNumberInt( const char *field ) { return (int)getNumber( field ); }
virtual long long getNumberLongLong( const char *field ) { return (long long)getNumber( field ); }
virtual string getString( const char *field ) = 0;
virtual bool getBoolean( const char *field ) = 0;
virtual BSONObj getObject( const char *field ) = 0;
virtual int type( const char *field ) = 0;
void append( BSONObjBuilder & builder , const char * fieldName , const char * scopeName );
virtual void setElement( const char *field , const BSONElement& e ) = 0;
virtual void setNumber( const char *field , double val ) = 0;
virtual void setString( const char *field , const char * val ) = 0;
virtual void setObject( const char *field , const BSONObj& obj , bool readOnly=true ) = 0;
virtual void setBoolean( const char *field , bool val ) = 0;
virtual void setThis( const BSONObj * obj ) = 0;
virtual ScriptingFunction createFunction( const char * code );
virtual void rename( const char * from , const char * to ) = 0;
/**
* @return 0 on success
*/
virtual int invoke( ScriptingFunction func , const BSONObj& args, int timeoutMs = 0 , bool ignoreReturn = false ) = 0;
void invokeSafe( ScriptingFunction func , const BSONObj& args, int timeoutMs = 0 ) {
int res = invoke( func , args , timeoutMs );
if ( res == 0 )
return;
throw UserException( 9004 , (string)"invoke failed: " + getError() );
}
virtual string getError() = 0;
int invoke( const char* code , const BSONObj& args, int timeoutMs = 0 );
void invokeSafe( const char* code , const BSONObj& args, int timeoutMs = 0 ) {
if ( invoke( code , args , timeoutMs ) == 0 )
return;
throw UserException( 9005 , (string)"invoke failed: " + getError() );
}
virtual bool exec( const StringData& code , const string& name , bool printResult , bool reportError , bool assertOnError, int timeoutMs = 0 ) = 0;
virtual void execSetup( const StringData& code , const string& name = "setup" ) {
exec( code , name , false , true , true , 0 );
}
void execSetup( const JSFile& file) {
execSetup(file.source, file.name);
}
void execCoreFiles() {
// keeping same order as in SConstruct
execSetup(JSFiles::utils);
execSetup(JSFiles::db);
execSetup(JSFiles::mongo);
execSetup(JSFiles::mr);
execSetup(JSFiles::query);
execSetup(JSFiles::collection);
}
virtual bool execFile( const string& filename , bool printResult , bool reportError , bool assertOnError, int timeoutMs = 0 );
virtual void injectNative( const char *field, NativeFunction func ) = 0;
virtual void gc() = 0;
void loadStored( bool ignoreNotConnected = false );
/**
if any changes are made to .system.js, call this
right now its just global - slightly inefficient, but a lot simpler
*/
static void storedFuncMod();
static int getNumScopes() {
return _numScopes;
}
static void validateObjectIdString( const string &str );
protected:
virtual ScriptingFunction _createFunction( const char * code ) = 0;
string _localDBName;
long long _loadedVersion;
set<string> _storedNames;
static long long _lastVersion;
map<string,ScriptingFunction> _cachedFunctions;
static int _numScopes;
};
void installGlobalUtils( Scope& scope );
class DBClientWithCommands;
class ScriptEngine : boost::noncopyable {
public:
ScriptEngine();
virtual ~ScriptEngine();
virtual Scope * newScope() {
Scope *s = createScope();
if ( s && _scopeInitCallback )
_scopeInitCallback( *s );
installGlobalUtils( *s );
return s;
}
virtual void runTest() = 0;
virtual bool utf8Ok() const = 0;
static void setup();
auto_ptr<Scope> getPooledScope( const string& pool );
void threadDone();
struct Unlocker { virtual ~Unlocker() {} };
virtual auto_ptr<Unlocker> newThreadUnlocker() { return auto_ptr< Unlocker >( new Unlocker ); }
void setScopeInitCallback( void ( *func )( Scope & ) ) { _scopeInitCallback = func; }
static void setConnectCallback( void ( *func )( DBClientWithCommands& ) ) { _connectCallback = func; }
static void runConnectCallback( DBClientWithCommands &c ) {
if ( _connectCallback )
_connectCallback( c );
}
// engine implementation may either respond to interrupt events or
// poll for interrupts
// the interrupt functions must not wait indefinitely on a lock
virtual void interrupt( unsigned opSpec ) {}
virtual void interruptAll() {}
static void setGetInterruptSpecCallback( unsigned ( *func )() ) { _getInterruptSpecCallback = func; }
static bool haveGetInterruptSpecCallback() { return _getInterruptSpecCallback; }
static unsigned getInterruptSpec() {
massert( 13474, "no _getInterruptSpecCallback", _getInterruptSpecCallback );
return _getInterruptSpecCallback();
}
static void setCheckInterruptCallback( const char * ( *func )() ) { _checkInterruptCallback = func; }
static bool haveCheckInterruptCallback() { return _checkInterruptCallback; }
static const char * checkInterrupt() {
return _checkInterruptCallback ? _checkInterruptCallback() : "";
}
static bool interrupted() {
const char *r = checkInterrupt();
return r && r[ 0 ];
}
protected:
virtual Scope * createScope() = 0;
private:
void ( *_scopeInitCallback )( Scope & );
static void ( *_connectCallback )( DBClientWithCommands & );
static const char * ( *_checkInterruptCallback )();
static unsigned ( *_getInterruptSpecCallback )();
};
bool hasJSReturn( const string& s );
const char * jsSkipWhiteSpace( const char * raw );
extern ScriptEngine * globalScriptEngine;
}
Jump to Line
Something went wrong with that request. Please try again.