shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2024-12-23 17:33:56 +03:00
Code Releases Wiki Activity

Merge branch 'master' of git.opennebula.org:one

Browse Source
This commit is contained in:
Ruben S. Montero 2011-10-15 00:07:32 +02:00
commit 1122f2f2d3
36 changed files with 261 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/AclManager.h
View File

@ -99,8 +99,9 @@ public:
/**
* Bootstraps the database table(s) associated to the ACL Manager
* @return 0 on success
*/
static void bootstrap(SqlDB * _db);
static int bootstrap(SqlDB * _db);
/**
* Dumps the rule set in XML format.

5
include/Group.h
View File

@ -103,12 +103,13 @@ private:
/**
* Bootstraps the database table(s) associated to the Group
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
ostringstream oss(Group::db_bootstrap);
db->exec(oss);
return db->exec(oss);
};
/**

5
include/GroupPool.h
View File

@ -119,10 +119,11 @@ public:
/**
* Bootstraps the database table(s) associated to the Group pool
* @return 0 on success
*/
static void bootstrap(SqlDB * _db)
static int bootstrap(SqlDB * _db)
{
Group::bootstrap(_db);
return Group::bootstrap(_db);
};
/**

5
include/Host.h
View File

@ -362,12 +362,13 @@ private:
/**
* Bootstraps the database table(s) associated to the Host
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
ostringstream oss_host(Host::db_bootstrap);
db->exec(oss_host);
return db->exec(oss_host);
};
/**

5
include/HostPool.h
View File

@ -82,10 +82,11 @@ public:
/**
* Bootstraps the database table(s) associated to the Host pool
* @return 0 on success
*/
static void bootstrap(SqlDB *_db)
static int bootstrap(SqlDB *_db)
{
Host::bootstrap(_db);
return Host::bootstrap(_db);
};
/**

5
include/Image.h
View File

@ -338,12 +338,13 @@ private:
/**
* Bootstraps the database table(s) associated to the Image
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
ostringstream oss_image(Image::db_bootstrap);
db->exec(oss_image);
return db->exec(oss_image);
};
/**

5
include/ImagePool.h
View File

@ -104,10 +104,11 @@ public:
/**
* Bootstraps the database table(s) associated to the Image pool
* @return 0 on success
*/
static void bootstrap(SqlDB *_db)
static int bootstrap(SqlDB *_db)
{
Image::bootstrap(_db);
return Image::bootstrap(_db);
};
/**

4
include/Nebula.h
View File

@ -445,8 +445,10 @@ private:
/**
* Bootstraps the database control tables
*
* @return 0 on success
*/
void bootstrap();
int bootstrap();
/**
* Callback function for the check_db_version method. Stores the read

5
include/User.h
View File

@ -174,12 +174,13 @@ private:
/**
* Bootstraps the database table(s) associated to the User
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
ostringstream oss_user(User::db_bootstrap);
db->exec(oss_user);
return db->exec(oss_user);
};
/**

5
include/UserPool.h
View File

@ -92,10 +92,11 @@ public:
/**
* Bootstraps the database table(s) associated to the User pool
* @return 0 on success
*/
static void bootstrap(SqlDB * _db)
static int bootstrap(SqlDB * _db)
{
User::bootstrap(_db);
return User::bootstrap(_db);
};
/**

5
include/VMTemplate.h
View File

@ -108,12 +108,13 @@ private:
/**
* Bootstraps the database table(s) associated to the VMTemplate
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
ostringstream oss(VMTemplate::db_bootstrap);
db->exec(oss);
return db->exec(oss);
};
/**

5
include/VMTemplatePool.h
View File

@ -104,10 +104,11 @@ public:
/**
* Bootstraps the database table(s) associated to the pool
* @return 0 on success
*/
static void bootstrap(SqlDB *_db)
static int bootstrap(SqlDB *_db)
{
VMTemplate::bootstrap(_db);
return VMTemplate::bootstrap(_db);
};
private:

11
include/VirtualMachine.h
View File

@ -784,14 +784,19 @@ private:
/**
* Bootstraps the database table(s) associated to the VirtualMachine
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
int rc;
ostringstream oss_vm(VirtualMachine::db_bootstrap);
ostringstream oss_hist(History::db_bootstrap);
db->exec(oss_vm);
db->exec(oss_hist);
rc = db->exec(oss_vm);
rc += db->exec(oss_hist);
return rc;
};
/**

5
include/VirtualMachinePool.h
View File

@ -122,10 +122,11 @@ public:
/**
* Bootstraps the database table(s) associated to the VirtualMachine pool
* @return 0 on success
*/
static void bootstrap(SqlDB * _db)
static int bootstrap(SqlDB * _db)
{
VirtualMachine::bootstrap(_db);
return VirtualMachine::bootstrap(_db);
};
/**

11
include/VirtualNetwork.h
View File

@ -236,14 +236,19 @@ private:
/**
* Bootstraps the database table(s) associated to the Virtual Network
* @return 0 on success
*/
static void bootstrap(SqlDB * db)
static int bootstrap(SqlDB * db)
{
int rc;
ostringstream oss_vnet(VirtualNetwork::db_bootstrap);
ostringstream oss_lease(Leases::db_bootstrap);
db->exec(oss_vnet);
db->exec(oss_lease);
rc = db->exec(oss_vnet);
rc += db->exec(oss_lease);
return rc;
};
/**

5
include/VirtualNetworkPool.h
View File

@ -108,10 +108,11 @@ public:
/**
* Bootstraps the database table(s) associated to the VirtualNetwork pool
* @return 0 on success
*/
static void bootstrap(SqlDB * _db)
static int bootstrap(SqlDB * _db)
{
VirtualNetwork::bootstrap(_db);
return VirtualNetwork::bootstrap(_db);
};
/**

1
install.sh
View File

@ -654,6 +654,7 @@ ONEDB_MIGRATOR_FILES="src/onedb/2.0_to_2.9.80.rb \
src/onedb/2.9.80_to_2.9.85.rb \
src/onedb/2.9.85_to_2.9.90.rb \
src/onedb/2.9.90_to_3.0.rb \
src/onedb/3.0_to_3.1.0.rb \
src/onedb/onedb.rb \
src/onedb/onedb_backend.rb"

2
share/install_gems/install_gems
View File

@ -14,7 +14,7 @@ if defined?(RUBY_VERSION) && RUBY_VERSION>="1.8.7"
OPTIONAL=%w{nokogiri}
else
SQLITE='sqlite3-ruby --version 1.2.0'
OPTIONAL=%w{nokogir xmlparser}
OPTIONAL=%w{nokogiri xmlparser}
end
GROUPS={

4
src/acl/AclManager.cc
View File

@ -474,11 +474,11 @@ int AclManager::del_rule(int oid, string& error_str)
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void AclManager::bootstrap(SqlDB * _db)
int AclManager::bootstrap(SqlDB * _db)
{
ostringstream oss(db_bootstrap);
_db->exec(oss);
return _db->exec(oss);
}
/* -------------------------------------------------------------------------- */

2
src/group/Group.cc
View File

@ -27,7 +27,7 @@ const char * Group::table = "group_pool";
const char * Group::db_names = "oid, name, body";
const char * Group::db_bootstrap = "CREATE TABLE IF NOT EXISTS group_pool ("
"oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, "
"oid INTEGER PRIMARY KEY, name VARCHAR(128), body TEXT, "
"UNIQUE(name))";
/* ************************************************************************ */

9
src/group/GroupPool.cc
View File

@ -91,6 +91,11 @@ int GroupPool::allocate(string name, int * oid, string& error_str)
goto error_name;
}
if ( name.length() > 128 )
{
goto error_name_length;
}
// Check for duplicates
group = get(name, false);
@ -111,6 +116,10 @@ error_name:
oss << "NAME cannot be empty.";
goto error_common;
error_name_length:
oss << "NAME is too long; max length is 128 chars.";
goto error_common;
error_duplicated:
oss << "NAME is already taken by GROUP " << group->get_oid() << ".";

2
src/host/Host.cc
View File

@ -61,7 +61,7 @@ const char * Host::table = "host_pool";
const char * Host::db_names = "oid, name, body, state, last_mon_time";
const char * Host::db_bootstrap = "CREATE TABLE IF NOT EXISTS host_pool ("
"oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, state INTEGER, "
"oid INTEGER PRIMARY KEY, name VARCHAR(128), body TEXT, state INTEGER, "
"last_mon_time INTEGER, UNIQUE(name))";
/* ------------------------------------------------------------------------ */

9
src/host/HostPool.cc
View File

@ -150,6 +150,11 @@ int HostPool::allocate (
goto error_name;
}
if ( hostname.length() > 128 )
{
goto error_name_length;
}
if ( im_mad_name.empty() )
{
goto error_im;
@ -187,6 +192,10 @@ error_name:
oss << "NAME cannot be empty.";
goto error_common;
error_name_length:
oss << "NAME is too long; max length is 128 chars.";
goto error_common;
error_im:
oss << "IM_MAD_NAME cannot be empty.";
goto error_common;

4
src/image/Image.cc
View File

@ -74,7 +74,7 @@ const char * Image::table = "image_pool";
const char * Image::db_names = "oid, name, body, uid, gid, public";
const char * Image::db_bootstrap = "CREATE TABLE IF NOT EXISTS image_pool ("
"oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, uid INTEGER, "
"oid INTEGER PRIMARY KEY, name VARCHAR(128), body TEXT, uid INTEGER, "
"gid INTEGER, public INTEGER, UNIQUE(name,uid) )";
/* ------------------------------------------------------------------------ */
@ -235,7 +235,7 @@ error_size_format:
goto error_common;
error_path_and_source:
error_str = "Template malformed, PATH and SOURCE are mutuallly exclusive.";
error_str = "Template malformed, PATH and SOURCE are mutually exclusive.";
goto error_common;
error_common:

9
src/image/ImagePool.cc
View File

@ -78,6 +78,11 @@ int ImagePool::allocate (
goto error_name;
}
if ( name.length() > 128 )
{
goto error_name_length;
}
// Check for duplicates
img_aux = get(name,uid,false);
@ -111,6 +116,10 @@ error_name:
goto error_common;
error_name_length:
oss << "NAME is too long; max length is 128 chars.";
goto error_common;
error_duplicated:
oss << "NAME is already taken by IMAGE "
<< img_aux->get_oid() << ".";

43
src/nebula/Nebula.cc
View File

@ -236,17 +236,29 @@ void Nebula::start()
if( rc == -2 )
{
NebulaLog::log("ONE",Log::INFO,"Bootstraping OpenNebula database.");
rc = 0;
bootstrap();
VirtualMachinePool::bootstrap(db);
HostPool::bootstrap(db);
VirtualNetworkPool::bootstrap(db);
GroupPool::bootstrap(db);
UserPool::bootstrap(db);
ImagePool::bootstrap(db);
VMTemplatePool::bootstrap(db);
AclManager::bootstrap(db);
NebulaLog::log("ONE",Log::INFO,"Bootstrapping OpenNebula database.");
rc += VirtualMachinePool::bootstrap(db);
rc += HostPool::bootstrap(db);
rc += VirtualNetworkPool::bootstrap(db);
rc += GroupPool::bootstrap(db);
rc += UserPool::bootstrap(db);
rc += ImagePool::bootstrap(db);
rc += VMTemplatePool::bootstrap(db);
rc += AclManager::bootstrap(db);
// Create the versioning table only if bootstrap went well
if ( rc == 0 )
{
rc += bootstrap();
}
if ( rc != 0 )
{
throw runtime_error("Error bootstrapping database.");
}
}
}
catch (exception&)
@ -627,27 +639,30 @@ void Nebula::start()
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void Nebula::bootstrap()
int Nebula::bootstrap()
{
int rc;
ostringstream oss;
oss << "CREATE TABLE pool_control (tablename VARCHAR(32) PRIMARY KEY, "
"last_oid BIGINT UNSIGNED)";
db->exec(oss);
rc = db->exec(oss);
oss.str("");
oss << "CREATE TABLE db_versioning (oid INTEGER PRIMARY KEY, "
"version VARCHAR(256), timestamp INTEGER, comment VARCHAR(256))";
db->exec(oss);
rc += db->exec(oss);
oss.str("");
oss << "INSERT INTO db_versioning (oid, version, timestamp, comment) "
<< "VALUES (0, '" << db_version() << "', " << time(0)
<< ", '" << version() << " daemon bootstrap')";
db->exec(oss);
rc += db->exec(oss);
return rc;
}
/* -------------------------------------------------------------------------- */

16
src/onedb/2.9.80_to_2.9.85.rb
View File

@ -32,7 +32,10 @@ module Migrator
# Image pool table:
# CREATE TABLE image_pool (oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, uid INTEGER, gid INTEGER, public INTEGER, UNIQUE(name,uid) );
@db.fetch("SELECT * FROM image_pool") do |row|
@db.run "ALTER TABLE image_pool RENAME TO old_image_pool;"
@db.run "CREATE TABLE image_pool (oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, uid INTEGER, gid INTEGER, public INTEGER, UNIQUE(name,uid) );"
@db.fetch("SELECT * FROM old_image_pool") do |row|
doc = Document.new(row[:body])
source = nil
@ -48,10 +51,17 @@ module Migrator
size_elem = doc.root.add_element("SIZE")
size_elem.text = size
@db[:image_pool].filter(:oid => row[:oid]).update(
:body => doc.root.to_s)
@db[:image_pool].insert(
:oid => row[:oid],
:name => row[:name],
:body => doc.root.to_s,
:uid => row[:uid],
:gid => row[:gid],
:public => row[:public])
end
@db.run "DROP TABLE old_image_pool;"
return true
end
end

8
src/onedb/2.9.90_to_3.0.rb
View File

@ -29,7 +29,11 @@ module Migrator
# The tm_nfs driver has been renamed to tm_shared
# CREATE TABLE host_pool (oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, state INTEGER, last_mon_time INTEGER, UNIQUE(name));
@db.fetch("SELECT * FROM host_pool") do |row|
@db.run "ALTER TABLE host_pool RENAME TO old_host_pool;"
@db.run "CREATE TABLE host_pool (oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, state INTEGER, last_mon_time INTEGER, UNIQUE(name));"
@db.run "INSERT INTO host_pool SELECT * FROM old_host_pool;"
@db.fetch("SELECT * FROM old_host_pool") do |row|
doc = Document.new(row[:body])
source = nil
@ -43,6 +47,8 @@ module Migrator
}
end
@db.run "DROP TABLE old_host_pool;"
return true
end
end

82
src/onedb/3.0_to_3.1.0.rb Normal file
View File

@ -0,0 +1,82 @@
# -------------------------------------------------------------------------- *
# Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org) #
# 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. *
# -------------------------------------------------------------------------- *
require "rexml/document"
include REXML
module Migrator
def db_version
"3.1.0"
end
def one_version
"OpenNebula 3.1.0"
end
def up
[ [:group_pool, "group"],
[:host_pool, "host"],
[:image_pool, "image"],
[:network_pool, "network"],
[:template_pool,"template"],
[:user_pool, "user"],
[:vm_pool, "vm"]
].each { |pair|
# Check that all objects have names shorter that 128
check_names(pair[0], pair[1])
# Change the name column to 128 chars. In SQLite, ALTER COLUMN is
# not supported, but since the char limit is ignored,
# VARCHAR(128) and VARCHAR(256) are the same type
if ( self.class == BackEndMySQL )
@db.run "ALTER TABLE #{pair[0]} CHANGE name name VARCHAR(128);"
end
}
return true
end
def check_names(table, elem)
@db.run "CREATE TABLE migrator_tmp (oid INTEGER PRIMARY KEY, name VARCHAR(128), body TEXT);"
@db.fetch("SELECT * FROM #{table}") do |row|
if ( row[:name].length > 128 )
# Element name is bigger than 128 chars
new_name = "#{elem}-#{row[:oid]}-#{row[:name][0..99]}"
doc = Document.new(row[:body])
doc.root.each_element("NAME") { |e|
e.text = new_name
}
@db[:migrator_tmp].insert(
:oid => row[:oid],
:name => new_name,
:body => doc.root.to_s)
puts " > #{elem} ##{row[:oid]} had a name bigger than 128 chars and has been renamed to #{new_name[0..10]}..."
end
end
@db.fetch("SELECT * FROM migrator_tmp") do |row|
@db[table].filter(:oid => row[:oid]).update(
:name => row[:name],
:body => row[:body])
end
@db.run "DROP TABLE migrator_tmp"
end
end

5
src/onedb/test/test_sqlite.sh
View File

@ -80,7 +80,10 @@ sort results/one.db.3.0.tmpschema > results/one.db.3.0.schema
rm results/one.db.upgraded.tmpschema
rm results/one.db.3.0.tmpschema
# Small cheat: the 3.0 schema had some columns with type VARCHAR(256), now it
# has changed to VARCHAR(128); but sqlite ignores the char limit
sed -i "s/name VARCHAR(256)/name VARCHAR(128)/" results/one.db.upgraded.schema
sed -i "s/name TEXT/name VARCHAR(128)/" results/one.db.upgraded.schema
# Perform a diff
FILE=results/schema.diff

4
src/test/Nebula.cc
View File

@ -529,11 +529,11 @@ void Nebula::start()
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void Nebula::bootstrap()
int Nebula::bootstrap()
{
ostringstream oss;
oss << "CREATE TABLE pool_control (tablename VARCHAR(32) PRIMARY KEY, "
"last_oid BIGINT UNSIGNED)";
db->exec(oss);
return db->exec(oss);
}

2
src/um/User.cc
View File

@ -38,7 +38,7 @@ const char * User::table = "user_pool";
const char * User::db_names = "oid,name,body";
const char * User::db_bootstrap = "CREATE TABLE IF NOT EXISTS user_pool ("
"oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, UNIQUE(name))";
"oid INTEGER PRIMARY KEY, name VARCHAR(128), body TEXT, UNIQUE(name))";
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */

6
src/um/UserPool.cc
View File

@ -146,6 +146,12 @@ int UserPool::allocate (
goto error_name;
}
if ( uname.length() > 128 )
{
error_str = "max length is 128 chars";
goto error_name;
}
user = get(uname,false);
if ( user !=0 )

12
src/vm/VirtualMachine.cc
View File

@ -96,7 +96,7 @@ const char * VirtualMachine::db_names =
"oid, name, body, uid, gid, last_poll, state, lcm_state";
const char * VirtualMachine::db_bootstrap = "CREATE TABLE IF NOT EXISTS "
"vm_pool (oid INTEGER PRIMARY KEY, name TEXT, body TEXT, uid INTEGER, "
"vm_pool (oid INTEGER PRIMARY KEY, name VARCHAR(128), body TEXT, uid INTEGER, "
"gid INTEGER, last_poll INTEGER, state INTEGER, lcm_state INTEGER)";
/* -------------------------------------------------------------------------- */
@ -209,6 +209,10 @@ int VirtualMachine::insert(SqlDB * db, string& error_str)
replace_template_attribute("NAME", name);
}
else if ( name.length() > 128 )
{
goto error_name_length;
}
this->name = name;
@ -284,7 +288,11 @@ error_rollback:
error_leases_rollback:
release_network_leases();
goto error_common; // just to avoid compilation warnings
goto error_common;
error_name_length:
oss << "NAME is too long; max length is 128 chars.";
goto error_common;
error_common:
NebulaLog::log("ONE",Log::ERROR, error_str);

7
src/vm_template/VMTemplate.cc
View File

@ -63,7 +63,7 @@ const char * VMTemplate::db_names = "oid, name, body, uid, gid, public";
const char * VMTemplate::db_bootstrap =
"CREATE TABLE IF NOT EXISTS template_pool (oid INTEGER PRIMARY KEY, "
"name VARCHAR(256), body TEXT, uid INTEGER, gid INTEGER, public INTEGER)";
"name VARCHAR(128), body TEXT, uid INTEGER, gid INTEGER, public INTEGER)";
/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */
@ -92,6 +92,11 @@ int VMTemplate::insert(SqlDB *db, string& error_str)
oss << "template-" << oid;
name = oss.str();
}
else if ( name.length() > 128 )
{
error_str = "NAME is too long; max length is 128 chars.";
return -1;
}
// ------------ PUBLIC --------------------

9
src/vnm/VirtualNetworkPool.cc
View File

@ -93,6 +93,11 @@ int VirtualNetworkPool::allocate (
goto error_name;
}
if ( name.length() > 128 )
{
goto error_name_length;
}
// Check for duplicates
vn_aux = get(name,uid,false);
@ -112,6 +117,10 @@ error_name:
goto error_common;
error_name_length:
oss << "NAME is too long; max length is 128 chars.";
goto error_common;
error_duplicated:
oss << "NAME is already taken by NET "
<< vn_aux->get_oid() << ".";