Skip to Navigation

User login

Username: *

Password: *

• Request new password

• jigdo
• Development
• Debian jigdo mini-HOWTO

Home › jigdo › Development › jigdo API

jigdo API

Last update by Admin on 2010-05-23

• Namespaces
• Class hierarchy
• Class list
• File list
• Namespace Members
• Class Members
• File Members

job/makeimagedl.hh

Go to the documentation of this file.

/* $Id: makeimagedl.hh,v 1.13 2003/09/16 23:32:10 atterer Exp $ -*- C++ -*-
  __   _
  |_) /|  Copyright (C) 2003  |  richard@
  | \/�|  Richard Atterer     |  atterer.net
  � '` �
  This program is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License, version 2. See the file
  COPYING for details.

*/
#ifndef MAKEIMAGEDL_HH
#define MAKEIMAGEDL_HH

#include <config.h>

#include <glib.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <string>

#include <datasource.hh>
#include <ilist.hh>
#include <jigdo-io.fh>
#include <job.hh>
#include <makeimage.hh>
#include <makeimagedl.fh>
#include <md5sum.hh>
#include <nocopy.hh>
#include <single-url.hh>
#include <status.hh>
#include <url-mapping.hh>
//______________________________________________________________________

class Job::MakeImageDl : NoCopy /*, public JigdoConfig::ProgressReporter*/ {
public:
  class Child;
  friend class Child;
  class ChildListBase;
  class IO;
  IOSource<IO> io; // Points to e.g. a GtkMakeImage
  //____________________

  static const int MAX_INCLUDES = 100;

  enum State {
    DOWNLOADING_JIGDO,
    DOWNLOADING_TEMPLATE,
    FINAL_STATE, // Value isn't actually used; all below are final states:
    ERROR
  };

  //inline static const char* destDescTemplate();

  MakeImageDl(/*IO* ioPtr,*/const string& jigdoUri, const string& destination);

  ~MakeImageDl();

  void killAllChildren();

  void run();

  inline const string& jigdoUri() const;

  inline State state() const;

  inline const string& tmpDir() const;

  inline void generateError(const string& message, State newState = ERROR);
  inline bool finalState() const;

#if 0

  void childSucceeded(Child* childDl, DataSource::IO* childIo/*,
                      DataSource::IO* frontend*/);
#endif

  void childFailed(Child* childDl);

  void setImageSection(string* imageName, string* imageInfo,
                       string* imageShortInfo, PartUrlMapping* templateUrls,
                       MD5** templateMd5);
  inline bool haveImageSection() const;

  UrlMap urlMap;

  Child* childFor(const string& url, const MD5* md = 0,
                  string* leafnameOut = 0, Child* reuseChild = 0);

  inline Child* childFor(PartUrlMapping* urls, const MD5* md = 0);

  typedef IList<ChildListBase> ChildList;
  inline const ChildList& children() const;

  inline const string& imageName() const { return imageNameVal; }
  inline const string& imageShortInfo() const { return imageShortInfoVal; }
  //inline const string& templateUrl() const { return templateUrlVal; }
  inline const MD5* templateMd5() const { return templateMd5Val; }
  void imageInfo(string* output, bool escapedText,
                 const char* subst[13]) const;
  enum { B, B_, I, I_, TT, TT_, U, U_, BIG, BIG_, SMALL, SMALL_, BR };

  inline const string& imageInfoOrig() const { return imageInfoVal; }

  void jigdoFinished();

private: // To be called by Child only:

  /* Called by Child when the download has succeeded: Rename a '~' download
     to '-' to indicate that it is complete. */
  void singleUrlFinished(Child* c);
  /* Called by Child when the download has succeeded, but the expected
     content checksum was wrong: Rename from c~ContentChecksum to
     u-UrlChecksum */
  void singleUrlWrongContent(Child* c);

  // Called from Child::job_succeeded() when the template d/l has finished
  void templateFinished();

private: // Really private

  // Write a ReadMe.txt to the download dir; fails silently
  void writeReadMe();

  // Starts the initial .jigdo download
  void createJigdoDownload();

  /* Return filename for content md5sum cache entry:
     "/home/x/jigdo-blasejfwe/c-nGJ2hQpUNCIZ0fafwQxZmQ"
     @param leafnameOut String to assign cache entry leafname, or null
     @param isFinished true to use "-", false to use "~"
     @param isC true to use "c", false to use "u" */
  string cachePathnameContent(const MD5& md, string* leafnameOut = 0,
                              bool isFinished = true, bool isC = true);
  /* Return filename for URL cache entry:
     "/home/x/jigdo-blasejfwe/u-nGJ2hQpUNCIZ0fafwQxZmQ"
     @param leafnameOut String to assign cache entry leafname, or null
     @param isFinished true to use "-", false to use "~" */
  string cachePathnameUrl(const string& url, string* leafnameOut = 0,
                          bool isFinished = true);
  // Add leafname for object to arg string, e.g. "u-nGJ2hQpUNCIZ0fafwQxZmQ"
  //static void appendLeafname(string* s, bool contentMd, const MD5& md);
  /* Turn the '-' in string created by above function into a '~' or v.v.
     Works even if leafname is preceded by dirname or similar in s */
  static inline void toggleLeafname(string* s);

  // Helper methods for childFor()
  Child* childForCompletedUrl(const struct stat& fileInfo,
    const string& filename, const MD5* md, Child* reuseChild);
  Child* childForCompletedContent(const struct stat& fileInfo,
    const string& filename, const MD5* md, Child* reuseChild);
  Child* childForSemiCompleted(const struct stat& fileInfo,
    const string& filename, Child* reuseChild);

  //static const char* destDescTemplateVal;

  State stateVal; // State, e.g. "downloading jigdo file", "error"

  string jigdoUrl; // URL of .jigdo file
  Job::JigdoIO* jigdoIo; // toplevel JigdoIO, while state == DOWNLOADING_JIGDO
  ChildList childrenVal; // Child downloads

  string dest; // Destination dir. No trailing '/', empty string for root dir
  string tmpDirVal; // Temporary dir, a subdir of dest

  // Workhorse which actually generates the image from the data we feed it
  MakeImage mi;

  // Info about first image section of this .jigdo, if any
  string imageNameVal;
  string imageInfoVal, imageShortInfoVal;
  SmartPtr<PartUrlMapping> templateUrls; // Can contain a list of altern. URLs
  MD5* templateMd5Val;

  static gboolean jigdoFinished_callback(gpointer);
  void jigdoFinished2();
  int callbackId; // glib callback function ID
};
//______________________________________________________________________

class Job::MakeImageDl::IO : public Job::IO {
public:

  virtual void job_deleted() = 0;

  virtual void job_succeeded() = 0;

  virtual void job_failed(const string& message) = 0;

  virtual void job_message(const string& message) = 0;

#if 0

//   virtual Job::DataSource::IO* makeImageDl_new(
//       Job::DataSource* childDownload, const string& uri,
//       const string& destDesc) = 0;
#endif

  virtual void makeImageDl_new(Job::DataSource* childDownload,
                               const string& uri, const string& destDesc) = 0;

  virtual void makeImageDl_finished(Job::DataSource* childDownload) = 0;

  virtual void makeImageDl_haveImageSection() = 0;
};
//______________________________________________________________________

class Job::MakeImageDl::ChildListBase : public IListBase {
  friend class Job::MakeImageDl::Child;
  explicit ChildListBase() { } // Private ctor, only usable by Child
public:
  inline Child* get();
  inline const Child* get() const;
};
//____________________

class Job::MakeImageDl::Child
    : NoCopy, public ChildListBase, public Job::DataSource::IO {
  friend class MakeImageDl;
public:
  inline ~Child();

  MakeImageDl* master() const { return masterVal; }
  inline DataSource* source() const;
  inline void deleteSource();
  //inline DataSource::IO* childIo() const;

  inline Child(MakeImageDl* m, ChildList* listHead,
               DataSource* src, const MD5* expectedContent);
  //inline void setChildIo(DataSource::IO* c);

# if DEBUG
  // childFailed() or childSucceeded() MUST always be called for a Child
  bool childSuccFail;
# endif

private:

  // (Re)initialize data members, except for urls and lastUrl. Returns this
  inline Child* init(MakeImageDl* m, ChildList* list,
                     DataSource* src, const MD5* expectedContent);

  // Virtual methods from DataSource::IO.
  virtual void job_deleted();
  virtual void job_succeeded();
  virtual void job_failed(const string& message);
  virtual void job_message(const string& message);
  virtual void dataSource_dataSize(uint64 n);
  virtual void dataSource_data(const byte* data, unsigned size,
                               uint64 currentSize);
  MakeImageDl* masterVal;
  DataSource* sourceVal;
  bool checkContent; // True iff checksum of downloaded data is to be verified
  MD5 md; // Only if contentMd==true, EXPECTED checksum of the download data
  MD5Sum mdCheck; // Only if contentMd==true, used to calculate actual checksum
  SmartPtr<PartUrlMapping> urls; // Null if only a single URL (.jigdo d/l)
  vector<UrlMapping*>* lastUrl; // To record last URL output by templateUrls
};
//======================================================================

// const char* Job::MakeImageDl::destDescTemplate() {
//   return destDescTemplateVal;
// }

const string& Job::MakeImageDl::jigdoUri() const { return jigdoUrl; }

Job::MakeImageDl::State Job::MakeImageDl::state() const { return stateVal; }

void Job::MakeImageDl::generateError(const string& message, State newState) {
  if (finalState()) return;
  stateVal = newState;
  IOSOURCE_SEND(IO, io, job_failed, (message));
}

bool Job::MakeImageDl::finalState() const { return state() > FINAL_STATE; }

const string& Job::MakeImageDl::tmpDir() const { return tmpDirVal; }

void Job::MakeImageDl::toggleLeafname(string* s) {
  int off = s->length() - 23;
  Paranoid((*s)[off] == '-' || (*s)[off] == '~');
  (*s)[off] ^= ('-' ^ '~');
}

bool Job::MakeImageDl::haveImageSection() const {
  return !imageNameVal.empty();
}

const Job::MakeImageDl::ChildList& Job::MakeImageDl::children() const {
  return childrenVal;
}

Job::MakeImageDl::Child* Job::MakeImageDl::childFor(PartUrlMapping* urls,
    const MD5* md) {
  auto_ptr<vector<UrlMapping*> > lastUrl(new vector<UrlMapping*>);
  string url = urls->enumerate(lastUrl.get());
  Child* c = childFor(url, md);
  if (c != 0) {
    c->urls = urls;
    c->lastUrl = lastUrl.release();
  }
  return c;
}
//____________________

Job::MakeImageDl::Child* Job::MakeImageDl::ChildListBase::get()
  { return static_cast<MakeImageDl::Child*>(this); }
const Job::MakeImageDl::Child* Job::MakeImageDl::ChildListBase::get() const
  { return static_cast<const MakeImageDl::Child*>(this); }

Job::MakeImageDl::Child* Job::MakeImageDl::Child::init(MakeImageDl* m,
    ChildList* /*list*/, DataSource* src, const MD5* expectedContent) {
  masterVal = m;
  sourceVal = src;
  checkContent = (expectedContent != 0);
  if (expectedContent != 0) md = *expectedContent; else md.clear();
# if DEBUG
  childSuccFail = false;
# endif
  // Add ourself as listener to DataSource
  src->io.addListener(*implicit_cast<DataSource::IO*>(this));
  return this;
}

Job::MakeImageDl::Child::Child(MakeImageDl* m, ChildList* list,
                               DataSource* src, const MD5* expectedContent)
  : ChildListBase(), Job::DataSource::IO(),
    md(), mdCheck(), urls(), lastUrl(0) {
  Paranoid(list != 0);
  init(m, list, src, expectedContent);
  // Add ourself to parent's list of children
  list->push_back(*implicit_cast<ChildListBase*>(this));
  //msg("Child %1", this);
}

Job::MakeImageDl::Child::~Child() {
# if DEBUG
  //msg("~Child %1", this);
  Paranoid(childSuccFail);
# endif
  deleteSource();
  delete lastUrl;
}

Job::DataSource* Job::MakeImageDl::Child::source() const {
  return sourceVal;
}

void Job::MakeImageDl::Child::deleteSource() {
  delete sourceVal;
  sourceVal = 0;
}

#endif

---

• Photography
• Software
• jigdo
• Research
• About

© Copyright 2014 Richard Atterer

 Top of page  •  Home  •  Sitemap  •  Contact  •  About