WebSVN – clockwerk-opensim-stable – Blame – Rev 1 – /OpenSim/Region/CoreModules/Avatar/Inventory/Archiver/InventoryArchiverModule.cs

                    "-m|--merge is an option which merges the loaded IAR with existing inventory folders where possible, rather than always creating new ones"

120

+ "<first> is user's first name." + Environment.NewLine

121

+ "<last> is user's last name." + Environment.NewLine

122

                    + "<inventory path> is the path inside the user's inventory where the IAR should be loaded." + Environment.NewLine

123

+ "<password> is the user's password." + Environment.NewLine

124

+ "<IAR path> is the filesystem path or URI from which to load the IAR."

125

                    + string.Format("  If this is not given then the filename {0} in the current directory is used", DEFAULT_INV_BACKUP_FILENAME),

126

HandleLoadInvConsoleCommand);

127

128

scene.AddCommand(

129

"Archiving", this, "save iar",

130

                    "save iar [-h|--home=<url>] [--noassets] <first> <last> <inventory path> <password> [<IAR path>] [-c|--creators] [-e|--exclude=<name/uuid>] [-f|--excludefolder=<foldername/uuid>] [-v|--verbose]",

131

"Save user inventory archive (IAR).",

132

"<first> is the user's first name.\n"

133

+ "<last> is the user's last name.\n"

134

+ "<inventory path> is the path inside the user's inventory for the folder/item to be saved.\n"

135

+ "<IAR path> is the filesystem path at which to save the IAR."

136

                    + string.Format("  If this is not given then the filename {0} in the current directory is used.\n", DEFAULT_INV_BACKUP_FILENAME)

137

+ "-h|--home=<url> adds the url of the profile service to the saved user information.\n"

138

+ "-c|--creators preserves information about foreign creators.\n"

139

+ "-e|--exclude=<name/uuid> don't save the inventory item in archive" + Environment.NewLine

140

                    + "-f|--excludefolder=<folder/uuid> don't save contents of the folder in archive" + Environment.NewLine

141

+ "-v|--verbose extra debug messages.\n"

142

+ "--noassets stops assets being saved to the IAR.",

143

HandleSaveInvConsoleCommand);

m_aScene = scene;

}

m_scenes[scene.RegionInfo.RegionID] = scene;

149

}

150

151

public void RemoveRegion(Scene scene)

{

}

public void Close() {}

156

157

public void RegionLoaded(Scene scene)

{

}

public void PostInitialise()

{

}

public Type ReplaceableInterface

166

{

167

get { return null; }

168

}

169

170

public string Name { get { return "Inventory Archiver Module"; } }

#endregion

/// <summary>

/// Trigger the inventory archive saved event.

176

/// </summary>

177

protected internal void TriggerInventoryArchiveSaved(

178

Guid id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream,

179

Exception reportedException)

180

{

181

InventoryArchiveSaved handlerInventoryArchiveSaved = OnInventoryArchiveSaved;

182

if (handlerInventoryArchiveSaved != null)

183

handlerInventoryArchiveSaved(id, succeeded, userInfo, invPath, saveStream, reportedException);

184

}

185

186

public bool ArchiveInventory(

187

Guid id, string firstName, string lastName, string invPath, string pass, Stream saveStream)

188

{

189

            return ArchiveInventory(id, firstName, lastName, invPath, pass, saveStream, new Dictionary<string, object>());

190

}

191

192

public bool ArchiveInventory(

193

Guid id, string firstName, string lastName, string invPath, string pass, Stream saveStream,

194

Dictionary<string, object> options)

195

{

196

if (m_scenes.Count > 0)

197

{

198

UserAccount userInfo = GetUserInfo(firstName, lastName, pass);

199

200

if (userInfo != null)

201

{

202

// if (CheckPresence(userInfo.PrincipalID))

// {

try

{

                            new InventoryArchiveWriteRequest(id, this, m_aScene, userInfo, invPath, saveStream).Execute(options, UserAccountService);

207

}

208

catch (EntryPointNotFoundException e)

209

{

210

m_log.ErrorFormat(

211

                                "[INVENTORY ARCHIVER]: Mismatch between Mono and zlib1g library version when trying to create compression stream."

212

                                    + "If you've manually installed Mono, have you appropriately updated zlib1g as well?");

m_log.Error(e);

return false;

}

return true;

// }

// else

// {

// m_log.ErrorFormat(

223

// "[INVENTORY ARCHIVER]: User {0} {1} {2} not logged in to this region simulator",

224

// userInfo.FirstName, userInfo.LastName, userInfo.PrincipalID);

// }

}

}

return false;

}

public bool ArchiveInventory(

233

Guid id, string firstName, string lastName, string invPath, string pass, string savePath,

234

Dictionary<string, object> options)

235

{

236

// if (!ConsoleUtil.CheckFileDoesNotExist(MainConsole.Instance, savePath))

237

// return false;

238

239

if (m_scenes.Count > 0)

240

{

241

UserAccount userInfo = GetUserInfo(firstName, lastName, pass);

242

243

if (userInfo != null)

244

{

245

// if (CheckPresence(userInfo.PrincipalID))

// {

try

{

                            new InventoryArchiveWriteRequest(id, this, m_aScene, userInfo, invPath, savePath).Execute(options, UserAccountService);

250

}

251

catch (EntryPointNotFoundException e)

252

{

253

m_log.ErrorFormat(

254

                                "[INVENTORY ARCHIVER]: Mismatch between Mono and zlib1g library version when trying to create compression stream."

255

                                    + "If you've manually installed Mono, have you appropriately updated zlib1g as well?");

m_log.Error(e);

return false;

}

return true;

// }

// else

// {

// m_log.ErrorFormat(

266

// "[INVENTORY ARCHIVER]: User {0} {1} {2} not logged in to this region simulator",

267

// userInfo.FirstName, userInfo.LastName, userInfo.PrincipalID);

// }

}

}

return false;

}

        public bool DearchiveInventory(string firstName, string lastName, string invPath, string pass, Stream loadStream)

276

{

277

return DearchiveInventory(firstName, lastName, invPath, pass, loadStream, new Dictionary<string, object>());

278

}

279

280

public bool DearchiveInventory(

281

string firstName, string lastName, string invPath, string pass, Stream loadStream,

282

Dictionary<string, object> options)

283

{

284

if (m_scenes.Count > 0)

285

{

286

UserAccount userInfo = GetUserInfo(firstName, lastName, pass);

287

288

if (userInfo != null)

289

{

290

// if (CheckPresence(userInfo.PrincipalID))

291

// {

292

InventoryArchiveReadRequest request;

293

bool merge = (options.ContainsKey("merge") ? (bool)options["merge"] : false);

try

{

                            request = new InventoryArchiveReadRequest(m_aScene.InventoryService, m_aScene.AssetService, m_aScene.UserAccountService, userInfo, invPath, loadStream, merge);

298

}

299

catch (EntryPointNotFoundException e)

300

{

301

m_log.ErrorFormat(

302

                                "[INVENTORY ARCHIVER]: Mismatch between Mono and zlib1g library version when trying to create compression stream."

303

                                    + "If you've manually installed Mono, have you appropriately updated zlib1g as well?");

m_log.Error(e);

return false;

}

UpdateClientWithLoadedNodes(userInfo, request.Execute());

return true;

// }

// else

// {

// m_log.ErrorFormat(

316

// "[INVENTORY ARCHIVER]: User {0} {1} {2} not logged in to this region simulator",

317

// userInfo.FirstName, userInfo.LastName, userInfo.PrincipalID);

// }

}

else

m_log.ErrorFormat("[INVENTORY ARCHIVER]: User {0} {1} not found",

322

firstName, lastName);

}

return false;

}

public bool DearchiveInventory(

329

string firstName, string lastName, string invPath, string pass, string loadPath,

330

Dictionary<string, object> options)

331

{

332

if (m_scenes.Count > 0)

333

{

334

UserAccount userInfo = GetUserInfo(firstName, lastName, pass);

335

336

if (userInfo != null)

337

{

338

// if (CheckPresence(userInfo.PrincipalID))

339

// {

340

InventoryArchiveReadRequest request;

341

bool merge = (options.ContainsKey("merge") ? (bool)options["merge"] : false);

try

{

                            request = new InventoryArchiveReadRequest(m_aScene.InventoryService, m_aScene.AssetService, m_aScene.UserAccountService, userInfo, invPath, loadPath, merge);

346

}

347

catch (EntryPointNotFoundException e)

348

{

349

m_log.ErrorFormat(

350

                                "[INVENTORY ARCHIVER]: Mismatch between Mono and zlib1g library version when trying to create compression stream."

351

                                    + "If you've manually installed Mono, have you appropriately updated zlib1g as well?");

m_log.Error(e);

return false;

}

UpdateClientWithLoadedNodes(userInfo, request.Execute());

return true;

// }

// else

// {

// m_log.ErrorFormat(

364

// "[INVENTORY ARCHIVER]: User {0} {1} {2} not logged in to this region simulator",

365

// userInfo.FirstName, userInfo.LastName, userInfo.PrincipalID);

// }

}

}

return false;

}

/// <summary>

/// Load inventory from an inventory file archive

375

/// </summary>

376

/// <param name="cmdparams"></param>

377

protected void HandleLoadInvConsoleCommand(string module, string[] cmdparams)

{

try

{

Dictionary<string, object> options = new Dictionary<string, object>();

382

                OptionSet optionSet = new OptionSet().Add("m|merge", delegate (string v) { options["merge"] = v != null; });

383

384

List<string> mainParams = optionSet.Parse(cmdparams);

385

386

if (mainParams.Count < 6)

387

{

388

m_log.Error(

389

                        "[INVENTORY ARCHIVER]: usage is load iar [-m|--merge] <first name> <last name> <inventory path> <user password> [<load file path>]");

return;

}

string firstName = mainParams[2];

394

string lastName = mainParams[3];

395

string invPath = mainParams[4];

396

string pass = mainParams[5];

397

string loadPath = (mainParams.Count > 6 ? mainParams[6] : DEFAULT_INV_BACKUP_FILENAME);

398

399

m_log.InfoFormat(

400

"[INVENTORY ARCHIVER]: Loading archive {0} to inventory path {1} for {2} {3}",

401

loadPath, invPath, firstName, lastName);

402

403

if (DearchiveInventory(firstName, lastName, invPath, pass, loadPath, options))

404

m_log.InfoFormat(

405

"[INVENTORY ARCHIVER]: Loaded archive {0} for {1} {2}",

406

loadPath, firstName, lastName);

407

}

408

catch (InventoryArchiverException e)

409

{

410

m_log.ErrorFormat("[INVENTORY ARCHIVER]: {0}", e.Message);

}

}

/// <summary>

/// Save inventory to a file archive

416

/// </summary>

417

/// <param name="cmdparams"></param>

418

protected void HandleSaveInvConsoleCommand(string module, string[] cmdparams)

419

{

420

Guid id = Guid.NewGuid();

421

422

Dictionary<string, object> options = new Dictionary<string, object>();

423

424

OptionSet ops = new OptionSet();

425

//ops.Add("v|version=", delegate(string v) { options["version"] = v; });

426

ops.Add("h|home=", delegate(string v) { options["home"] = v; });

427

ops.Add("v|verbose", delegate(string v) { options["verbose"] = v; });

428

ops.Add("c|creators", delegate(string v) { options["creators"] = v; });

429

ops.Add("noassets", delegate(string v) { options["noassets"] = v != null; });

430

ops.Add("e|exclude=", delegate(string v)

431

{

432

if (!options.ContainsKey("exclude"))

433

options["exclude"] = new List<String>();

434

((List<String>)options["exclude"]).Add(v);

435

});

436

ops.Add("f|excludefolder=", delegate(string v)

437

{

438

if (!options.ContainsKey("excludefolders"))

439

options["excludefolders"] = new List<String>();

440

((List<String>)options["excludefolders"]).Add(v);

441

});

442

443

List<string> mainParams = ops.Parse(cmdparams);

try

{

if (mainParams.Count < 6)

448

{

449

m_log.Error(

450

                        "[INVENTORY ARCHIVER]: save iar [-h|--home=<url>] [--noassets] <first> <last> <inventory path> <password> [<IAR path>] [-c|--creators] [-e|--exclude=<name/uuid>] [-f|--excludefolder=<foldername/uuid>] [-v|--verbose]");

return;

}

if (options.ContainsKey("home"))

455

                    m_log.WarnFormat("[INVENTORY ARCHIVER]: Please be aware that inventory archives with creator information are not compatible with OpenSim 0.7.0.2 and earlier.  Do not use the -home option if you want to produce a compatible IAR");

456

457

string firstName = mainParams[2];

458

string lastName = mainParams[3];

459

string invPath = mainParams[4];

460

string pass = mainParams[5];

461

string savePath = (mainParams.Count > 6 ? mainParams[6] : DEFAULT_INV_BACKUP_FILENAME);

462

463

m_log.InfoFormat(

464

"[INVENTORY ARCHIVER]: Saving archive {0} using inventory path {1} for {2} {3}",

465

savePath, invPath, firstName, lastName);

466

467

lock (m_pendingConsoleSaves)

468

m_pendingConsoleSaves.Add(id);

469

470

ArchiveInventory(id, firstName, lastName, invPath, pass, savePath, options);

471

}

472

catch (InventoryArchiverException e)

473

{

474

m_log.ErrorFormat("[INVENTORY ARCHIVER]: {0}", e.Message);

}

}

private void SaveInvConsoleCommandCompleted(

479

Guid id, bool succeeded, UserAccount userInfo, string invPath, Stream saveStream,

480

Exception reportedException)

481

{

482

lock (m_pendingConsoleSaves)

483

{

484

if (m_pendingConsoleSaves.Contains(id))

485

m_pendingConsoleSaves.Remove(id);

else

return;

}

if (succeeded)

{

                m_log.InfoFormat("[INVENTORY ARCHIVER]: Saved archive for {0} {1}", userInfo.FirstName, userInfo.LastName);

}

else

{

m_log.ErrorFormat(

"[INVENTORY ARCHIVER]: Archive save for {0} {1} failed - {2}",

498

userInfo.FirstName, userInfo.LastName, reportedException.Message);

}

}

/// <summary>

/// Get user information for the given name.

504

/// </summary>

505

/// <param name="firstName"></param>

506

/// <param name="lastName"></param>

507

/// <param name="pass">User password</param>

508

/// <returns></returns>

509

protected UserAccount GetUserInfo(string firstName, string lastName, string pass)

510

{

511

UserAccount account

512

= m_aScene.UserAccountService.GetUserAccount(m_aScene.RegionInfo.ScopeID, firstName, lastName);

513

514

if (null == account)

515

{

516

m_log.ErrorFormat(

517

"[INVENTORY ARCHIVER]: Failed to find user info for {0} {1}",

518

firstName, lastName);

return null;

}

try

{

string encpass = Util.Md5Hash(pass);

525

if (m_aScene.AuthenticationService.Authenticate(account.PrincipalID, encpass, 1) != string.Empty)

{

return account;

}

else

{

m_log.ErrorFormat(

"[INVENTORY ARCHIVER]: Password for user {0} {1} incorrect. Please try again.",

533

firstName, lastName);

return null;

}

}

catch (Exception e)

538

{

539

m_log.ErrorFormat("[INVENTORY ARCHIVER]: Could not authenticate password, {0}", e);

return null;

}

}

/// <summary>

/// Notify the client of loaded nodes if they are logged in

546

/// </summary>

547

/// <param name="loadedNodes">Can be empty. In which case, nothing happens</param>

548

private void UpdateClientWithLoadedNodes(UserAccount userInfo, HashSet<InventoryNodeBase> loadedNodes)

549

{

550

if (loadedNodes.Count == 0)

551

return;

552

553

foreach (Scene scene in m_scenes.Values)

554

{

555

ScenePresence user = scene.GetScenePresence(userInfo.PrincipalID);

556

557

if (user != null && !user.IsChildAgent)

558

{

559

foreach (InventoryNodeBase node in loadedNodes)

560

{

561

// m_log.DebugFormat(

562

// "[INVENTORY ARCHIVER]: Notifying {0} of loaded inventory node {1}",

563

// user.Name, node.Name);

564

565

user.ControllingClient.SendBulkUpdateInventory(node);

}

break;

}

}

}

// /// <summary>

// /// Check if the given user is present in any of the scenes.

575

// /// </summary>

576

// /// <param name="userId">The user to check</param>

577

// /// <returns>true if the user is in any of the scenes, false otherwise</returns>

578

// protected bool CheckPresence(UUID userId)

579

// {

580

// if (DisablePresenceChecks)

581

// return true;

582

//

583

// foreach (Scene scene in m_scenes.Values)

584

// {

585

// ScenePresence p;

586

// if ((p = scene.GetScenePresence(userId)) != null)

587

// {

588

// p.ControllingClient.SendAgentAlertMessage("Inventory operation has been started", false);

// return true;

// }

// }

//

// return false;

// }

}

}

clockwerk-opensim-stable – Blame information for rev 1