← Back to branch summary

~ubuntu-branches/ubuntu/maverick/eucalyptus/maverick

« back to all changes in this revision

Viewing changes to clc/modules/core/conf/scripts/Import_152.groovy

  • Committer: Bazaar Package Importer
  • Author(s): Dave Walker (Daviey)
  • Date: 2010-07-21 17:27:10 UTC
  • mfrom: (1.1.38 upstream)
  • Revision ID: james.westby@ubuntu.com-20100721172710-7xv07dmdqgivc3t9
Tags: 2.0~bzr1211-0ubuntu1
https://launchpad.net/bugs/597330
https://launchpad.net/bugs/595421
* New major upstream version merge, 2.0 (r1211).
* debian/patches/:
  - 01-wsdl-stubs.patch, debian/wsdl.md5sums: wsdl stubs updated.
  - 02-Makefile.patch: Updated to reflect new code layout.
  - 07-local_support_euca_conf-in.patch: Updated to reflect new code layout.
  - 08-ubuntu-default-networking.patch: Refreshed.
  - 09-small-128-192MB.patch: Updated to point to new location.
  - 10-disable-iscsi.patch: Refreshed.
  - 11-state-cleanup-memleakfix.patch: Removed, fixed upstream.
  - 15-fix-default-ramdisk.patch: Updated to point to new location.
  - 16-kvm_libvirt_xml_default_use_kvm.patch: Updated to reflect changes.
  - 17-fix_walrus_OOM_errors.patch: Removed, fixed upstream.
  - 18-priv_security.patch: Updated to reflect upstream changes.
  - 20-brute-force-webui.patch: Updated to reflect upstream changes. 
  - 21-eucalyptus-1.7-with-gwt-1.6.4.patch: New patch, allows 
    eucalyptus-1.7 to be built against gwt 1.6.4. Based on patch courtesy 
    of Dmitrii Zagorodnov, upstream. (LP: #597330)
* debian/eucalyptus-java-common.links: 
  - Changed symlink for groovy, point to groovy.all.jar, making compatiable 
    with groovy versions >1.7. (LP: #595421)
  - Added ant.jar & jetty-rewrite-handler.jar as they are now required.
* debian/control
  - & debian/build-jars: Added libjavassist-java and libjetty-extra-java as 
    build dependencies.
  - Added libjetty-extra-java as a dependency of eucalyptus-java-common
* The binary resulting jar's have been renamed from eucalyptus-*-1.6.2.jar
  to eucalyptus-*-main.jar:    
  - debian/eucalyptus-cc.upstart
  - debian/eucalyptus-cloud.install
  - debian/eucalyptus-common.eucalyptus.upstart
  - debian/eucalyptus-java-common.install
  - debian/eucalyptus-network.upstart
  - debian/eucalyptus-sc.install
  - debian/eucalyptus-walrus.install
* debian/eucalyptus-java-common.install: New upstream jars that have been
  installed:
  - eucalyptus-db-hsqldb-ext-main.jar
  - eucalyptus-component-main.jar
* debian/control:
  - Updated Standards Version to 3.8.4 (no change)
  - Updated the upstream Homepage to: http://open.eucalyptus.com/
  - Changed Vcs-Bzr to reflect new location of Ubuntu hosted development branch.
  - Made the Build Dependency of groovy and the binary eucalyptus-java-common
    package depend on version >=1.7.

Show diffs side-by-side

added added

removed removed

Lines of Context:
clc/modules/core/conf/scripts/Import_152.groovy
1
 
 
2
 
import java.security.*;
3
 
 
4
 
import javax.crypto.spec.*;
5
 
import org.bouncycastle.jce.provider.BouncyCastleProvider;
6
 
import com.eucalyptus.util.EntityWrapper;
7
 
import com.eucalyptus.util.EucalyptusCloudException;
8
 
import com.eucalyptus.util.EntityWrapper;
9
 
import com.eucalyptus.util.SubDirectory;
10
 
import com.eucalyptus.util.WalrusProperties;
11
 
import com.eucalyptus.auth.CredentialProvider;
12
 
import com.eucalyptus.util.EntityWrapper;
13
 
import com.eucalyptus.util.EucalyptusCloudException;
14
 
import com.eucalyptus.auth.util.Hashes;
15
 
import com.eucalyptus.entities.SshKeyPair;
16
 
import com.eucalyptus.keys.KeyPairUtil;
17
 
import com.eucalyptus.entities.NetworkRule;
18
 
import com.eucalyptus.entities.NetworkRulesGroup;
19
 
import com.eucalyptus.entities.IpRange;
20
 
import com.eucalyptus.entities.NetworkPeer;
21
 
import com.eucalyptus.network.NetworkGroupUtil;
22
 
import com.eucalyptus.auth.util.Hashes;
23
 
import com.eucalyptus.auth.SystemCredentialProvider;
24
 
import com.eucalyptus.auth.Credentials;
25
 
import com.eucalyptus.bootstrap.Component;
26
 
import org.bouncycastle.util.encoders.UrlBase64;
27
 
import groovy.sql.Sql;
28
 
 
29
 
import edu.ucsb.eucalyptus.cloud.entities.SystemConfiguration;
30
 
import edu.ucsb.eucalyptus.cloud.entities.ProductCode;
31
 
import edu.ucsb.eucalyptus.cloud.entities.UserInfo;
32
 
import edu.ucsb.eucalyptus.cloud.entities.VmType;
33
 
import edu.ucsb.eucalyptus.cloud.state.Snapshot;
34
 
import edu.ucsb.eucalyptus.cloud.state.Volume;
35
 
import edu.ucsb.eucalyptus.cloud.state.State;
36
 
import edu.ucsb.eucalyptus.cloud.ws.SnapshotManager;
37
 
import edu.ucsb.eucalyptus.cloud.ws.VolumeManager;
38
 
 
39
 
import edu.ucsb.eucalyptus.cloud.entities.ImageInfo;
40
 
 
41
 
import edu.ucsb.eucalyptus.cloud.entities.UserInfo;
42
 
import edu.ucsb.eucalyptus.cloud.entities.UserGroupInfo;
43
 
import edu.ucsb.eucalyptus.cloud.entities.BucketInfo;
44
 
import edu.ucsb.eucalyptus.cloud.entities.ObjectInfo;
45
 
import edu.ucsb.eucalyptus.cloud.entities.VolumeInfo;
46
 
import edu.ucsb.eucalyptus.cloud.entities.SnapshotInfo;
47
 
import edu.ucsb.eucalyptus.cloud.entities.GrantInfo;
48
 
import edu.ucsb.eucalyptus.cloud.entities.ImageCacheInfo;
49
 
import edu.ucsb.eucalyptus.cloud.entities.MetaDataInfo;
50
 
import edu.ucsb.eucalyptus.cloud.entities.LVMVolumeInfo;
51
 
import edu.ucsb.eucalyptus.cloud.entities.LVMMetaInfo;
52
 
import edu.ucsb.eucalyptus.cloud.ws.WalrusControl;
53
 
import edu.ucsb.eucalyptus.ic.StorageController;
54
 
import com.eucalyptus.util.StorageProperties;
55
 
import com.eucalyptus.config.Configuration;
56
 
import com.eucalyptus.config.ClusterConfiguration;
57
 
import com.eucalyptus.config.WalrusConfiguration;
58
 
import com.eucalyptus.config.StorageControllerConfiguration;
59
 
 
60
 
import java.io.File;
61
 
import java.net.URI;
62
 
import com.eucalyptus.util.DatabaseUtil;
63
 
import edu.ucsb.eucalyptus.cloud.entities.StorageInfo;
64
 
import edu.ucsb.eucalyptus.cloud.entities.WalrusInfo;
65
 
import edu.ucsb.eucalyptus.cloud.ws.WalrusControl;
66
 
import com.eucalyptus.auth.util.EucaKeyStore;
67
 
import com.eucalyptus.auth.util.Hashes.Digest;
68
 
import java.security.cert.X509Certificate;
69
 
import com.eucalyptus.auth.X509Cert;
70
 
import com.eucalyptus.auth.ClusterCredentials;
71
 
 
72
 
baseDir = "${System.getenv('EUCALYPTUS')}/var/lib/eucalyptus/db";
73
 
targetDir = baseDir;
74
 
targetDbPrefix= "eucalyptus"
75
 
 
76
 
def getSql() {
77
 
  source = new org.hsqldb.jdbc.jdbcDataSource();
78
 
  source.database = "jdbc:hsqldb:file:${baseDir}/eucalyptus";
79
 
  source.user = 'sa';
80
 
  source.password = '';
81
 
  return new Sql(source);
82
 
}
83
 
 
84
 
def getSqlVolumes() {
85
 
  source = new org.hsqldb.jdbc.jdbcDataSource();
86
 
  source.database = "jdbc:hsqldb:file:${baseDir}/eucalyptus_volumes";
87
 
  source.user = 'sa';
88
 
  source.password = '';
89
 
  return new Sql(source);
90
 
}
91
 
 
92
 
db = getSql();
93
 
dbVolumes = getSqlVolumes( );
94
 
 
95
 
 
96
 
System.setProperty("euca.home",System.getenv("EUCALYPTUS"))
97
 
System.setProperty("euca.var.dir","${System.getenv('EUCALYPTUS')}/var/lib/eucalyptus/")
98
 
System.setProperty("euca.log.dir", "${System.getenv('EUCALYPTUS')}/var/log/eucalyptus/")
99
 
Component c = Component.db
100
 
System.setProperty("euca.db.host", "jdbc:hsqldb:file:${targetDir}/${targetDbPrefix}")
101
 
 
102
 
def getDbPass() {
103
 
  Credentials.init();
104
 
  EucaKeyStore keyStore = EucaKeyStore.getCleanInstance();
105
 
  KeyPair kp = keyStore.getKeyPair("eucalyptus", "eucalyptus");
106
 
  PrivateKey pk = kp.getPrivate();
107
 
  Signature signer = Signature.getInstance( "SHA256withRSA" );
108
 
  signer.initSign( pk );
109
 
  signer.update( "eucalyptus".getBytes( ) );
110
 
  byte[] sig = signer.sign( );
111
 
  return Hashes.bytesToHex( sig );
112
 
}
113
 
 
114
 
System.setProperty("euca.db.password", "${System.getenv('EUCALYPTUS_DB')}");
115
 
System.setProperty("euca.log.level", 'INFO');
116
 
 
117
 
def vtunPassFile = new File("${System.getenv('EUCALYPTUS')}/var/lib/eucalyptus/keys/vtunpass");
118
 
vtunPassFile.write("${System.getenv('EUCALYPTUS_DB')}");
119
 
 
120
 
["${baseDir}/eucalyptus_general.script","${baseDir}/eucalyptus_images.script","${baseDir}/eucalyptus_auth.script","${baseDir}/eucalyptus_config.script","${baseDir}/eucalyptus_walrus.script","${baseDir}/eucalyptus_storage.script","${baseDir}/eucalyptus_dns.script"].each{
121
 
new File(it).write("CREATE SCHEMA PUBLIC AUTHORIZATION DBA\n" + 
122
 
          "CREATE USER SA PASSWORD \"" + System.getProperty( "euca.db.password" ) + "\"\n" +
123
 
          "GRANT DBA TO SA\n" + 
124
 
          "SET WRITE_DELAY 100 MILLIS\n" +
125
 
          "SET SCHEMA PUBLIC\n");
126
 
}
127
 
 
128
 
UserGroupInfo userGroupInfo = new UserGroupInfo( "all" );
129
 
EntityWrapper<UserGroupInfo> db3 = new EntityWrapper<UserGroupInfo>( );
130
 
try {
131
 
  db3.add( userGroupInfo );
132
 
  db3.commit();
133
 
} catch ( Throwable t ) {
134
 
  t.printStackTrace();
135
 
  db3.rollback();
136
 
}
137
 
 
138
 
 
139
 
db.rows('SELECT * FROM SYSTEM_INFO').each{ 
140
 
  SystemConfiguration config = edu.ucsb.eucalyptus.util.EucalyptusProperties.getSystemConfiguration();
141
 
  EntityWrapper<SystemConfiguration> confDb = new EntityWrapper<SystemConfiguration>();
142
 
  try {
143
 
    config.setDefaultKernel(it.SYSTEM_INFO_DEFAULT_KERNEL);
144
 
    config.setDefaultRamdisk(it.SYSTEM_INFO_DEFAULT_RAMDISK);
145
 
    config.setSystemReservedPublicAddresses(it.SYSTEM_RESERVED_PUBLIC_ADDRESSES);
146
 
    config.setMaxUserPublicAddresses(it.SYSTEM_MAX_USER_PUBLIC_ADDRESSES);
147
 
    config.setDoDynamicPublicAddresses(it.SYSTEM_DO_DYNAMIC_PUBLIC_ADDRESSES);
148
 
    config.setRegistrationId(it.SYSTEM_REGISTRATION_ID);
149
 
    confDb.merge( config );
150
 
    confDb.commit( );
151
 
  } catch (Throwable t) {
152
 
    t.printStackTrace();
153
 
    confDb.commit();
154
 
  }
155
 
}
156
 
 
157
 
 
158
 
db.rows('SELECT * FROM VM_TYPES').each{   
159
 
  EntityWrapper<VmType> dbVm = new EntityWrapper<VmType>( );
160
 
  try {
161
 
    dbVm.add( new VmType( it.VM_TYPE_NAME, it.VM_TYPE_CPU, it.VM_TYPE_DISK, it.VM_TYPE_MEMORY ) );
162
 
    dbVm.commit();
163
 
  } catch (Throwable t) {
164
 
    t.printStackTrace();
165
 
    dbVm.rollback();
166
 
  }
167
 
}
168
 
 
169
 
db.rows('SELECT * FROM USERS').each{   
170
 
  println "Adding user: ${it.USER_NAME}";
171
 
  UserInfo user = new UserInfo( it.USER_NAME, 
172
 
      it.USER_EMAIL, 
173
 
      it.USER_REAL_NAME, 
174
 
      it.USER_RESERVATION_ID, 
175
 
      it.USER_B_CRYPTED_PASSWORD, 
176
 
      it.USER_TELEPHONE_NUMBER, 
177
 
      it.USER_AFFILIATION, 
178
 
      it.USER_PROJECT_DESCRIPTION, 
179
 
      it.USER_PROJECT_PI_NAME,
180
 
      it.USER_CONFIRMATION_CODE,
181
 
      it.USER_CERTIFICATE_CODE,
182
 
      it.USER_IS_APPROVED, 
183
 
      it.USER_IS_CONFIRMED, 
184
 
      it.USER_IS_ENABLED, 
185
 
      it.USER_IS_ADMIN, 
186
 
      it.PASSWORD_EXPIRES );
187
 
  EntityWrapper<UserInfo> dbUser = new EntityWrapper<UserInfo>();
188
 
  try { 
189
 
    dbUser.add( user ); 
190
 
    userGroupInfo = dbUser.getUnique( new UserGroupInfo("all") );
191
 
    userGroupInfo.getUsers().add( user );
192
 
    dbUser.commit();
193
 
  } catch( Throwable t ) { 
194
 
    t.printStackTrace();
195
 
    dbUser.rollback();
196
 
  }
197
 
 
198
 
  CredentialProvider.addUser(it.USER_NAME,it.USER_IS_ADMIN,it.USER_QUERY_ID,it.USER_SECRETKEY);
199
 
  db.rows("SELECT cert.* FROM user_has_certificates has_certs LEFT OUTER JOIN cert_info cert on cert.cert_info_id=has_certs.cert_info_id WHERE has_certs.user_id=${ it.USER_ID }").each{  cert_info ->
200
 
    println "-> certificate: ${cert_info.CERT_INFO_ALIAS}";
201
 
    CredentialProvider.addCertificate( it.USER_NAME, cert_info.CERT_INFO_ALIAS, Hashes.getPemCert( UrlBase64.decode( cert_info.CERT_INFO_VALUE.getBytes( ) ) ) );
202
 
  }
203
 
  db.rows("SELECT kp.* FROM user_has_sshkeys has_keys LEFT OUTER JOIN ssh_keypair kp on kp.ssh_keypair_id=has_keys.ssh_keypair_id WHERE has_keys.user_id=${ it.USER_ID }").each{  keypair ->
204
 
    println "-> keypair: ${keypair.SSH_KEYPAIR_NAME}";
205
 
    EntityWrapper<SshKeyPair> dbKp = KeyPairUtil.getEntityWrapper( );
206
 
    try {
207
 
      dbKp.add( new SshKeyPair( it.USER_NAME, keypair.SSH_KEYPAIR_NAME, keypair.SSH_KEYPAIR_PUBLIC_KEY, keypair.SSH_KEYPAIR_FINGER_PRINT ) );
208
 
      dbKp.commit( );
209
 
    } catch ( Throwable t ) {
210
 
      t.printStackTrace();
211
 
      dbKp.rollback( );
212
 
    }
213
 
  }
214
 
  db.rows("SELECT net.* FROM user_has_network_groups has_net LEFT OUTER JOIN network_group net on net.network_group_id=has_net.network_group_id WHERE has_net.user_id=${ it.USER_ID }").each{  net ->
215
 
    println "-> network: ${net.NETWORK_GROUP_NAME}"
216
 
    EntityWrapper<NetworkRulesGroup> dbNet = NetworkGroupUtil.getEntityWrapper();
217
 
    try {
218
 
      NetworkRulesGroup group = new NetworkRulesGroup( it.USER_NAME,net.NETWORK_GROUP_NAME, net.NETWORK_GROUP_DESCRIPTION );
219
 
      dbNet.add( group );
220
 
      db.rows("SELECT rule.* FROM network_group_has_rules has_thing LEFT OUTER JOIN network_rule rule on rule.network_rule_id=has_thing.network_rule_id WHERE has_thing.network_group_id=${ net.NETWORK_GROUP_ID }").each{  rule ->
221
 
      println "--> rule: ${rule.NETWORK_RULE_PROTOCOL}, ${rule.NETWORK_RULE_LOW_PORT}, ${rule.NETWORK_RULE_HIGH_PORT}"
222
 
        NetworkRule netRule = new NetworkRule(rule.NETWORK_RULE_PROTOCOL,rule.NETWORK_RULE_LOW_PORT, rule.NETWORK_RULE_HIGH_PORT);
223
 
        group.getNetworkRules().add( netRule );
224
 
        db.rows("SELECT o.* FROM network_rule_has_peer_network has_thing LEFT OUTER JOIN network_rule_peer_network o on o.network_rule_peer_network_id=has_thing.network_rule_peer_network_id WHERE has_thing.network_rule_id=${ rule.NETWORK_RULE_ID }").each{  peer ->
225
 
          println "---> peer: ${peer.NETWORK_RULE_PEER_NETWORK_USER_QUERY_KEY}, ${peer.NETWORK_RULE_PEER_NETWORK_USER_GROUP}" 
226
 
          netRule.getNetworkPeers().add( new NetworkPeer( peer.NETWORK_RULE_PEER_NETWORK_USER_QUERY_KEY, peer.NETWORK_RULE_PEER_NETWORK_USER_GROUP ) );
227
 
        }
228
 
        db.rows("SELECT o.* FROM network_rule_has_ip_range has_thing LEFT OUTER JOIN network_rule_ip_range o on o.network_rule_ip_range_id=has_thing.network_rule_ip_range_id WHERE has_thing.network_rule_id=${ rule.NETWORK_RULE_ID }").each{  ip ->
229
 
          println "---> ip-range: ${ip.NETWORK_RULE_IP_RANGE_VALUE}" 
230
 
          netRule.getIpRanges().add( new IpRange( ip.NETWORK_RULE_IP_RANGE_VALUE ) )
231
 
        }
232
 
      }      
233
 
      dbNet.commit();
234
 
    } catch (Throwable t) {
235
 
      t.printStackTrace();
236
 
      dbNet.rollback();
237
 
    }
238
 
  }
239
 
};
240
 
 
241
 
db.rows("SELECT image.* FROM images image").each{  image ->
242
 
  println "Adding images: ${image.IMAGE_NAME}";
243
 
  ImageInfo imgInfo = new ImageInfo( image.IMAGE_ARCH, image.IMAGE_NAME, image.IMAGE_PATH, image.IMAGE_OWNER_ID, image.IMAGE_AVAILABILITY, image.IMAGE_TYPE, image.IMAGE_IS_PUBLIC, image.IMAGE_KERNEL_ID, image.IMAGE_RAMDISK_ID );
244
 
  EntityWrapper<ImageInfo> dbImg = new EntityWrapper<ImageInfo>( );
245
 
  try {
246
 
    dbImg.add( imgInfo );
247
 
    db.rows("SELECT pc.* FROM image_has_product_codes has_pc LEFT OUTER JOIN image_product_code pc on pc.image_product_code_id=has_pc.image_product_code_id WHERE has_pc.image_id=${ image.IMAGE_ID }").each{  
248
 
      imgInfo.getProductCodes( ).add( new ProductCode( it.IMAGE_PRODUCT_CODE_VALUE ) );
249
 
    }
250
 
    /*
251
 
    db.rows("SELECT p.* FROM image_has_perms has_p LEFT OUTER JOIN users p on p.user_id=has_p.user_id WHERE has_p.image_id=${ image.IMAGE_ID }").each{  
252
 
      UserInfo u = dbImg.getUnique( new UserInfo( db.rows("SELECT u.user_name FROM users u WHERE u.user_name=${it.USER_NAME}")[0] ) );
253
 
      imgInfo.getPermissions( ).add( u );
254
 
    }
255
 
    */
256
 
    userGroupInfo = dbImg.getUnique( userGroupInfo );
257
 
    imgInfo.getUserGroups().add(userGroupInfo);
258
 
    dbImg.commit();
259
 
  } catch( Throwable t ) {
260
 
    t.printStackTrace();
261
 
    dbImg.rollback();
262
 
  }
263
 
}
264
 
 
265
 
dbVolumes.rows("SELECT * FROM VOLUME").each{
266
 
  println "Adding volume: ${it.DISPLAYNAME}"
267
 
  EntityWrapper<Volume> dbVol = VolumeManager.getEntityWrapper();
268
 
  try {
269
 
    Volume v = new Volume(it.USERNAME, it.DISPLAYNAME, it.SIZE, it.CLUSTER, it.PARENTSNAPSHOT );
270
 
//    v.setLocalDevice(it.LOCALDEVICE);
271
 
//    v.setRemoteDevice(it.REMOTEDEVICE);
272
 
    dbVol.add( v );
273
 
    dbVol.commit();
274
 
  } catch (Throwable t) {
275
 
    t.printStackTrace();
276
 
    dbVol.rollback();
277
 
  }
278
 
}
279
 
 
280
 
db.rows('SELECT * FROM BUCKETS').each{
281
 
  println "Adding bucket: ${it.BUCKET_NAME}"
282
 
 
283
 
  EntityWrapper<BucketInfo> dbBucket = WalrusControl.getEntityWrapper();
284
 
  try {
285
 
        BucketInfo b = new BucketInfo(it.OWNER_ID,it.BUCKET_NAME,it.BUCKET_CREATION_DATE);
286
 
        b.setOwnerId(it.OWNER_ID);
287
 
        b.setLocation(it.BUCKET_LOCATION);
288
 
        b.setGlobalRead(it.GLOBAL_READ);
289
 
        b.setGlobalWrite(it.GLOBAL_WRITE);
290
 
        b.setGlobalReadACP(it.GLOBAL_READ_ACP);
291
 
        b.setGlobalWriteACP(it.GLOBAL_WRITE_ACP);
292
 
        b.setBucketSize(it.BUCKET_SIZE);
293
 
        b.setHidden(false);
294
 
        /**
295
 
         * CREATE MEMORY TABLE BUCKET_HAS_OBJECTS(
296
 
         * BUCKET_ID BIGINT NOT NULL,
297
 
         * OBJECT_ID BIGINT NOT NULL)
298
 
         * 
299
 
         * CREATE MEMORY TABLE OBJECTS(OBJECT_ID BIGINT GENERATED BY DEFAULT AS IDENTITY(START WITH 1) NOT NULL PRIMARY KEY
300
 
         * ,OWNER_ID VARCHAR(255)
301
 
         * ,OBJECT_NAME VARCHAR(255)
302
 
         * ,GLOBAL_READ BOOLEAN,GLOBAL_WRITE BOOLEAN,GLOBAL_READ_ACP BOOLEAN,GLOBAL_WRITE_ACP BOOLEAN,ETAG VARCHAR(255)
303
 
         * ,LAST_MODIFIED TIMESTAMP,SIZE BIGINT,STORAGE_CLASS VARCHAR(255)
304
 
         * ,OBJECT_KEY VARCHAR(255))
305
 
         */
306
 
    db.rows("SELECT g.* FROM bucket_has_grants has_thing LEFT OUTER JOIN grants g on g.grant_id=has_thing.grant_id WHERE has_thing.bucket_id=${ it.BUCKET_ID }").each{  grant ->
307
 
    println "--> grant: ${it.BUCKET_NAME}/${grant.USER_ID}"
308
 
      GrantInfo grantInfo = new GrantInfo();
309
 
      grantInfo.setUserId(grant.USER_ID);
310
 
      grantInfo.setGrantGroup(grant.GRANT_GROUP);
311
 
      grantInfo.setCanWrite(grant.WRITE);
312
 
      grantInfo.setCanRead(grant.READ);
313
 
      grantInfo.setCanReadACP(grant.READ_ACP);
314
 
      grantInfo.setCanWriteACP(grant.WRITE_ACP);
315
 
      b.getGrants().add(grantInfo);
316
 
    }
317
 
        dbBucket.add(b);
318
 
        dbBucket.commit();
319
 
  } catch (Throwable t) {
320
 
            t.printStackTrace();
321
 
                  dbBucket.rollback();
322
 
  }
323
 
    db.rows("SELECT o.* FROM bucket_has_objects has_thing LEFT OUTER JOIN objects o on o.object_id=has_thing.object_id WHERE has_thing.bucket_id=${ it.BUCKET_ID }").each{  obj ->
324
 
      println "--> object: ${it.BUCKET_NAME}/${obj.OBJECT_NAME}"
325
 
      //Do bucket object stuff here.
326
 
      EntityWrapper<ObjectInfo> dbObject = WalrusControl.getEntityWrapper();
327
 
      try {
328
 
        ObjectInfo objectInfo = new ObjectInfo(it.BUCKET_NAME, obj.OBJECT_KEY);
329
 
        objectInfo.setObjectName(obj.OBJECT_NAME);
330
 
        objectInfo.setOwnerId(obj.OWNER_ID);
331
 
        objectInfo.setGlobalRead(obj.GLOBAL_READ);
332
 
        objectInfo.setGlobalWrite(obj.GLOBAL_WRITE);
333
 
        objectInfo.setGlobalReadACP(obj.GLOBAL_READ_ACP);
334
 
        objectInfo.setGlobalWriteACP(obj.GLOBAL_WRITE_ACP);
335
 
        objectInfo.setSize(obj.SIZE);
336
 
        objectInfo.setEtag(obj.ETAG);
337
 
        objectInfo.setLastModified(new Date());
338
 
        objectInfo.setStorageClass(obj.STORAGE_CLASS);
339
 
        objectInfo.setContentType("");
340
 
        objectInfo.setContentDisposition("");
341
 
        db.rows("SELECT g.* FROM object_has_grants has_thing LEFT OUTER JOIN grants g on g.grant_id=has_thing.grant_id WHERE has_thing.object_id=${ obj.OBJECT_ID }").each{  grant ->
342
 
        println "--> grant: ${obj.OBJECT_NAME}/${grant.USER_ID}"
343
 
          GrantInfo grantInfo = new GrantInfo();
344
 
          grantInfo.setUserId(grant.USER_ID);
345
 
          grantInfo.setGrantGroup(grant.GRANT_GROUP);
346
 
          grantInfo.setCanWrite(grant.WRITE);
347
 
          grantInfo.setCanRead(grant.READ);
348
 
          grantInfo.setCanReadACP(grant.READ_ACP);
349
 
          grantInfo.setCanWriteACP(grant.WRITE_ACP);
350
 
          objectInfo.getGrants().add(grantInfo);
351
 
        }
352
 
        db.rows("SELECT m.* FROM object_has_metadata has_thing LEFT OUTER JOIN metadata m on m.metadata_id=has_thing.metadata_id WHERE has_thing.object_id=${ obj.OBJECT_ID }").each{  metadata ->
353
 
        println "--> metadata: ${obj.OBJECT_NAME}/${metadata.NAME}"
354
 
          MetaDataInfo mInfo = new MetaDataInfo();
355
 
          mInfo.setObjectName(obj.OBJECT_NAME);
356
 
          mInfo.setName(metadata.NAME);
357
 
          mInfo.setValue(metadata.VALUE);
358
 
          objectInfo.getMetaData().add(mInfo);
359
 
        }
360
 
        dbObject.add(objectInfo);
361
 
        dbObject.commit();
362
 
      } catch (Throwable t) {
363
 
        t.printStackTrace();
364
 
        dbObject.rollback();
365
 
      }
366
 
    }
367
 
}
368
 
 
369
 
db.rows('SELECT * FROM IMAGECACHE').each{ 
370
 
          println "Adding IMAGECACHE: ${it.MANIFEST_NAME}"
371
 
 
372
 
          EntityWrapper<ImageCacheInfo> dbImg = WalrusControl.getEntityWrapper(); 
373
 
          try {
374
 
                ImageCacheInfo img = new ImageCacheInfo(it.BUCKET_NAME, it.MANIFEST_NAME);
375
 
                img.setImageName(it.IMAGE_NAME);
376
 
                img.setInCache(it.IN_CACHE);
377
 
                img.setSize(it.SIZE);
378
 
                img.setUseCount(it.USE_COUNT);
379
 
                dbImg.add(img);
380
 
            dbImg.commit();
381
 
          } catch (Throwable t) {
382
 
                t.printStackTrace();
383
 
                dbImg.rollback();
384
 
          }
385
 
        }
386
 
 
387
 
 
388
 
db.rows('SELECT * FROM VOLUMES').each{ 
389
 
  println "Adding VOLUME: ${it.VOLUME_NAME}"
390
 
 
391
 
  EntityWrapper<VolumeInfo> dbVol = StorageController.getEntityWrapper(); 
392
 
  try {
393
 
        VolumeInfo v = new VolumeInfo(it.VOLUME_NAME);
394
 
        v.setScName(StorageProperties.SC_LOCAL_NAME);
395
 
        v.setUserName(it.VOLUME_USER_NAME);
396
 
        v.setSize(it.SIZE);
397
 
        v.setStatus(it.STATUS);
398
 
        v.setCreateTime(new Date());
399
 
        v.setZone(it.ZONE);
400
 
        v.setSnapshotId(it.SNAPSHOT_ID);
401
 
    dbVol.add(v);
402
 
    dbVol.commit();
403
 
  } catch (Throwable t) {
404
 
        t.printStackTrace();
405
 
        dbVol.rollback();
406
 
  }
407
 
}
408
 
 
409
 
db.rows('SELECT * FROM SNAPSHOTS').each{ 
410
 
          println "Adding snapshot: ${it.SNAPSHOT_NAME}"
411
 
 
412
 
          EntityWrapper<VolumeInfo> dbSnap = StorageController.getEntityWrapper(); 
413
 
          try {
414
 
                SnapshotInfo s = new SnapshotInfo(it.SNAPSHOT_NAME);
415
 
                s.setShouldTransfer(true);
416
 
                s.setScName(StorageProperties.SC_LOCAL_NAME);
417
 
                s.setUserName(it.SNAPSHOT_USER_NAME);
418
 
                s.setVolumeId(it.VOLUME_NAME);
419
 
                s.setStatus(StorageProperties.Status.pending.toString());
420
 
                s.setStartTime(new Date());
421
 
                s.setProgress("0");
422
 
                dbSnap.add(s);
423
 
                dbSnap.commit();
424
 
          } catch (Throwable t) {
425
 
                t.printStackTrace();
426
 
                dbSnap.rollback();
427
 
          }
428
 
        }
429
 
 
430
 
 
431
 
db.rows('SELECT * FROM LVMVOLUMES').each{
432
 
 
433
 
  println "Adding LVMVOLUME: ${it.VOLUME_NAME}"
434
 
  EntityWrapper<LVMVolumeInfo> dbVol = StorageController.getEntityWrapper();
435
 
  try {
436
 
        LVMVolumeInfo l = new LVMVolumeInfo(it.VOLUME_NAME);
437
 
        l.setScName(StorageProperties.SC_LOCAL_NAME);
438
 
        l.setLoDevName(it.LODEV_NAME);
439
 
        l.setLoFileName(it.LOFILE_NAME);
440
 
        l.setPvName(it.PV_NAME);
441
 
        l.setVgName(it.VG_NAME);
442
 
        l.setLvName(it.LV_NAME);
443
 
        l.setSize(it.SIZE);
444
 
        l.setStatus(it.STATUS);
445
 
        l.setVbladePid(it.VBLADE_PID);
446
 
        l.setSnapshotOf(it.SNAPSHOT_OF);
447
 
        l.setMajorNumber(it.MAJOR_NUMBER);
448
 
        l.setMinorNumber(it.MINOR_NUMBER);
449
 
        dbVol.add(l);
450
 
        dbVol.commit();
451
 
  } catch (Throwable t) {
452
 
        t.printStackTrace();
453
 
        dbVol.rollback();
454
 
  }
455
 
}
456
 
 
457
 
db.rows('SELECT * FROM LVMMETADATA').each{
458
 
  println "Adding LVMMETADATA: ${it.HOSTNAME}"
459
 
  EntityWrapper<LVMMetaInfo> dbVol = StorageController.getEntityWrapper(); 
460
 
  try {
461
 
          LVMMetaInfo lvmmeta = new LVMMetaInfo(it.HOSTNAME);
462
 
          lvmmeta.setMajorNumber(it.MAJOR_NUMBER);
463
 
          lvmmeta.setMinorNumber(it.MINOR_NUMBER);
464
 
          dbVol.add(lvmmeta);
465
 
          dbVol.commit();
466
 
  } catch (Throwable t) {
467
 
        t.printStackTrace();
468
 
        dbVol.rollback();
469
 
  }
470
 
}
471
 
 
472
 
def clusterName = "testCluster";
473
 
 
474
 
db.rows('SELECT * FROM CLUSTERS').each{ 
475
 
  println "Adding CLUSTER: name=${it.CLUSTER_NAME} host=${it.CLUSTER_HOST} port=${it.CLUSTER_PORT}"
476
 
  clusterName = it.CLUSTER_NAME;
477
 
  EntityWrapper<ClusterConfiguration> dbClusterConfig = Configuration.getEntityWrapper();
478
 
  try {
479
 
    ClusterConfiguration clusterConfig = new ClusterConfiguration(it.CLUSTER_NAME, it.CLUSTER_HOST, it.CLUSTER_PORT);
480
 
    dbClusterConfig.add(clusterConfig);
481
 
    dbClusterConfig.commit();
482
 
  } catch (Throwable t) {
483
 
        t.printStackTrace();
484
 
        dbClusterConfig.rollback();
485
 
  }
486
 
}
487
 
 
488
 
X509Cert certInfo = new X509Cert("cc-" + clusterName);
489
 
certInfo.setPemCertificate(System.getenv('EUCALYPTUS_CLUSTER_CERT'))
490
 
X509Cert ncCertInfo = new X509Cert("nc-" + clusterName);
491
 
ncCertInfo.setPemCertificate(System.getenv('EUCALYPTUS_NODE_CERT'))
492
 
ClusterCredentials clusterCreds = new ClusterCredentials(clusterName);
493
 
clusterCreds.setClusterCertificate(certInfo);
494
 
clusterCreds.setNodeCertificate(ncCertInfo);
495
 
EntityWrapper<X509Cert> dbCert = Credentials.getEntityWrapper();
496
 
dbCert.add(certInfo);
497
 
dbCert.add(ncCertInfo);
498
 
EntityWrapper<ClusterCredentials> dbClusterCreds = dbCert.recast(ClusterCredentials.class);
499
 
dbClusterCreds.add(clusterCreds);
500
 
dbCert.commit();
501
 
 
502
 
dbVolumes.rows("SELECT * FROM SNAPSHOT").each{
503
 
          println "Adding snapshot: ${it.DISPLAYNAME}"
504
 
          
505
 
          EntityWrapper<Snapshot> dbSnap = SnapshotManager.getEntityWrapper( );
506
 
          try {
507
 
            Snapshot s = new Snapshot(it.USERNAME,it.DISPLAYNAME);
508
 
            s.setBirthday(it.BIRTHDAY);
509
 
            s.setState(State.valueOf(it.STATE));
510
 
            s.setParentVolume(it.PARENTVOLUME);
511
 
            s.setCluster(clusterName);
512
 
            s.setMappedState(StorageProperties.Status.pending.toString());
513
 
            dbSnap.add(s);
514
 
            dbSnap.commit();
515
 
          } catch (Throwable t) {
516
 
            t.printStackTrace();
517
 
            dbSnap.rollback();
518
 
          }
519
 
}
520
 
 
521
 
def getInterface() {
522
 
  def oldEucaConf = new File("${System.getenv('EUCALYPTUS')}/etc/eucalyptus/eucalyptus.conf-1.5");
523
 
    oldEucaConf.text.find(/VNET_INTERFACE="(.*)"/) { fullline, iface ->      
524
 
          return iface.toString()
525
 
    }
526
 
}
527
 
 
528
 
db.rows('SELECT * FROM SYSTEM_INFO').each{
529
 
        URI uri = new URI(it.SYSTEM_INFO_STORAGE_URL)
530
 
        println "Adding Walrus: name=walrus host=${uri.getHost()} port=${uri.getPort()}"
531
 
        EntityWrapper<WalrusConfiguration> dbWalrusConfig = Configuration.getEntityWrapper();
532
 
        EntityWrapper<WalrusInfo> dbWalrus = WalrusControl.getEntityWrapper();
533
 
        try {
534
 
          WalrusConfiguration walrusConfig = new WalrusConfiguration("walrus", uri.getHost(), uri.getPort());
535
 
          dbWalrusConfig.add(walrusConfig);
536
 
          dbWalrusConfig.commit();
537
 
          try {
538
 
            WalrusInfo walrusInfo = dbWalrus.getUnique(new WalrusInfo());
539
 
            walrusInfo.setStorageDir(it.SYSTEM_STORAGE_DIR)
540
 
            walrusInfo.setStorageMaxBucketsPerUser(it.SYSTEM_STORAGE_MAX_BUCKETS_PER_USER)
541
 
            walrusInfo.setStorageMaxBucketSizeInMB((int)(it.SYSTEM_STORAGE_MAX_BUCKET_SIZE_MB / WalrusProperties.M))
542
 
            walrusInfo.setStorageMaxCacheSizeInMB((int)(it.SYSTEM_STORAGE_CACHE_SIZE_MB / WalrusProperties.M))
543
 
            walrusInfo.setStorageMaxTotalSnapshotSizeInGb(it.SYSTEM_STORAGE_SNAPSHOT_SIZE_GB)
544
 
          } catch(Throwable t) {                 
545
 
            WalrusInfo walrusInfo = new WalrusInfo(WalrusProperties.NAME,
546
 
                          it.SYSTEM_STORAGE_DIR,
547
 
                          it.SYSTEM_STORAGE_MAX_BUCKETS_PER_USER,
548
 
                          (int)(it.SYSTEM_STORAGE_MAX_BUCKET_SIZE_MB / WalrusProperties.M),
549
 
                          (int)(it.SYSTEM_STORAGE_CACHE_SIZE_MB / WalrusProperties.M),
550
 
                          it.SYSTEM_STORAGE_SNAPSHOT_SIZE_GB)
551
 
            dbWalrus.add(walrusInfo)        
552
 
          }
553
 
          dbWalrus.commit();
554
 
        } catch(Throwable t) {
555
 
          t.printStackTrace();
556
 
          dbWalrusConfig.rollback();
557
 
          dbWalrus.rollback();
558
 
        }
559
 
        println "Adding SC: name=StorageController-local host=${uri.getHost()} port=${uri.getPort()}"
560
 
        EntityWrapper<StorageControllerConfiguration> dbSCConfig = Configuration.getEntityWrapper();
561
 
        EntityWrapper<StorageInfo> dbSC = StorageController.getEntityWrapper();         
562
 
        try {
563
 
          StorageControllerConfiguration storageConfig = new StorageControllerConfiguration(clusterName, uri.getHost(), uri.getPort());
564
 
          dbSCConfig.add(storageConfig);
565
 
          dbSCConfig.commit();
566
 
          StorageInfo storageInfo = new StorageInfo(StorageProperties.SC_LOCAL_NAME,
567
 
                          it.SYSTEM_STORAGE_MAX_VOLUME_SIZE_GB,
568
 
                          getInterface(),
569
 
                          it.SYSTEM_STORAGE_VOLUME_SIZE_GB,
570
 
                          it.SYSTEM_STORAGE_VOLUMES_DIR,
571
 
                          false);
572
 
          dbSC.add(storageInfo);
573
 
          dbSC.commit();
574
 
    } catch(Throwable t) {
575
 
          t.printStackTrace();
576
 
          dbSCConfig.rollback();
577
 
          dbSC.rollback();
578
 
        }
579
 
}
580
 
 
581
 
//flush
582
 
DatabaseUtil.closeAllEMFs();
583
 
//the db will not sync to disk even after a close in some cases. Wait a bit.
584
 
Thread.sleep(5000);
 
 
b'\\ No newline at end of file'