Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Changes In Branch less-verbose-sync Excluding Merge-Ins

This is equivalent to a diff from 60f71ba20a to 407cd4c534

Changes to src/branch.c.

   174    174     }
   175    175   
   176    176   
   177    177     /* Commit */
   178    178     db_end_transaction(0);
   179    179   
   180    180     /* Do an autosync push, if requested */
   181         -  if( !isPrivate ) autosync(AUTOSYNC_PUSH);
          181  +  if( !isPrivate ) autosync(SYNC_PUSH);
   182    182   }
   183    183   
   184    184   /*
   185    185   ** Prepare a query that will list branches.
   186    186   **
   187    187   ** If (which<0) then the query pulls only closed branches. If
   188    188   ** (which>0) then the query pulls all (closed and opened)

Changes to src/checkin.c.

  1106   1106       g.markPrivate = 1;
  1107   1107     }
  1108   1108   
  1109   1109     /*
  1110   1110     ** Autosync if autosync is enabled and this is not a private check-in.
  1111   1111     */
  1112   1112     if( !g.markPrivate ){
  1113         -    if( autosync(AUTOSYNC_PULL) ){
         1113  +    if( autosync(SYNC_PULL) ){
  1114   1114         blob_zero(&ans);
  1115   1115         prompt_user("continue in spite of sync failure (y/N)? ", &ans);
  1116   1116         cReply = blob_str(&ans)[0];
  1117   1117         if( cReply!='y' && cReply!='Y' ){
  1118   1118           fossil_exit(1);
  1119   1119         }
  1120   1120       }
................................................................................
  1457   1457     if( testRun ){
  1458   1458       db_end_transaction(1);
  1459   1459       exit(1);
  1460   1460     }
  1461   1461     db_end_transaction(0);
  1462   1462   
  1463   1463     if( !g.markPrivate ){
  1464         -    autosync(AUTOSYNC_PUSH);
         1464  +    autosync(SYNC_PUSH);
  1465   1465     }
  1466   1466     if( count_nonbranch_children(vid)>1 ){
  1467   1467       fossil_print("**** warning: a fork has occurred *****\n");
  1468   1468     }
  1469   1469   }

Changes to src/clone.c.

    97     97   **    --ssl-identity=filename    Use the SSL identity if requested by the server
    98     98   **
    99     99   ** See also: init
   100    100   */
   101    101   void clone_cmd(void){
   102    102     char *zPassword;
   103    103     const char *zDefaultUser;   /* Optional name of the default user */
   104         -  const char *zPw;     /* The user clone password */
          104  +  const char *zPw;            /* The user clone password */
   105    105     int nErr = 0;
   106         -  int bPrivate;               /* Also clone private branches */
          106  +  int bPrivate = 0;           /* Also clone private branches */
   107    107   
   108         -  bPrivate = find_option("private",0,0)!=0;
          108  +  if( find_option("private",0,0)!=0 ) bPrivate = SYNC_PRIVATE;
   109    109     url_proxy_options();
   110    110     if( g.argc < 4 ){
   111    111       usage("?OPTIONS? FILE-OR-URL NEW-REPOSITORY");
   112    112     }
   113    113     db_open_config(0);
   114    114     if( file_size(g.argv[3])>0 ){
   115    115       fossil_panic("file already exists: %s", g.argv[3]);
................................................................................
   160    160       db_multi_exec(
   161    161         "REPLACE INTO config(name,value,mtime)"
   162    162         " VALUES('server-code', lower(hex(randomblob(20))), now());"
   163    163       );
   164    164       url_enable_proxy(0);
   165    165       url_get_password_if_needed();
   166    166       g.xlinkClusterOnly = 1;
   167         -    nErr = client_sync(0,0,1,bPrivate,CONFIGSET_ALL,0);
          167  +    nErr = client_sync(SYNC_CLONE | bPrivate,CONFIGSET_ALL,0);
   168    168       g.xlinkClusterOnly = 0;
   169    169       verify_cancel();
   170    170       db_end_transaction(0);
   171    171       db_close(1);
   172    172       if( nErr ){
   173    173         file_delete(g.argv[3]);
   174    174         fossil_fatal("server returned an error - clone aborted");

Changes to src/configure.c.

   904    904       url_parse(zServer);
   905    905       if( g.urlPasswd==0 && zPw ) g.urlPasswd = mprintf("%s", zPw);
   906    906       user_select();
   907    907       url_enable_proxy("via proxy: ");
   908    908       if( legacyFlag ) mask |= CONFIGSET_OLDFORMAT;
   909    909       if( overwriteFlag ) mask |= CONFIGSET_OVERWRITE;
   910    910       if( strncmp(zMethod, "push", n)==0 ){
   911         -      client_sync(0,0,0,0,0,mask);
          911  +      client_sync(0,0,(unsigned)mask);
   912    912       }else if( strncmp(zMethod, "pull", n)==0 ){
   913         -      client_sync(0,0,0,0,mask,0);
          913  +      client_sync(0,(unsigned)mask,0);
   914    914       }else{
   915         -      client_sync(0,0,0,0,mask,mask);
          915  +      client_sync(0,(unsigned)mask,(unsigned)mask);
   916    916       }
   917    917     }else
   918    918     if( strncmp(zMethod, "reset", n)==0 ){
   919    919       int mask, i;
   920    920       char *zBackup;
   921    921       if( g.argc!=4 ) usage("reset AREA");
   922    922       mask = configure_name_to_mask(g.argv[3], 1);

Changes to src/json_branch.c.

   303    303     }
   304    304   
   305    305     /* Commit */
   306    306     db_end_transaction(0);
   307    307     
   308    308   #if 0 /* Do an autosync push, if requested */
   309    309     /* arugable for JSON mode? */
   310         -  if( !g.isHTTP && !isPrivate ) autosync(AUTOSYNC_PUSH);
          310  +  if( !g.isHTTP && !isPrivate ) autosync(SYNC_PUSH);
   311    311   #endif
   312    312     return 0;
   313    313   }
   314    314   
   315    315   
   316    316   /*
   317    317   ** Impl of /json/branch/create.

Changes to src/sync.c.

    17     17   **
    18     18   ** This file contains code used to push, pull, and sync a repository
    19     19   */
    20     20   #include "config.h"
    21     21   #include "sync.h"
    22     22   #include <assert.h>
    23     23   
    24         -#if INTERFACE
    25         -/*
    26         -** Flags used to determine which direction(s) an autosync goes in.
    27         -*/
    28         -#define AUTOSYNC_PUSH  1
    29         -#define AUTOSYNC_PULL  2
    30         -
    31         -#endif /* INTERFACE */
    32         -
    33     24   /*
    34     25   ** If the repository is configured for autosyncing, then do an
    35     26   ** autosync.  This will be a pull if the argument is true or a push
    36     27   ** if the argument is false.
    37     28   **
    38     29   ** Return the number of errors.
    39     30   */
................................................................................
    42     33     const char *zAutosync;
    43     34     const char *zPw;
    44     35     int rc;
    45     36     int configSync = 0;       /* configuration changes transferred */
    46     37     if( g.fNoSync ){
    47     38       return 0;
    48     39     }
    49         -  if( flags==AUTOSYNC_PUSH && db_get_boolean("dont-push",0) ){
           40  +  if( flags==SYNC_PUSH && db_get_boolean("dont-push",0) ){
    50     41       return 0;
    51     42     }
    52     43     zAutosync = db_get("autosync", 0);
    53     44     if( zAutosync ){
    54         -    if( (flags & AUTOSYNC_PUSH)!=0 && memcmp(zAutosync,"pull",4)==0 ){
           45  +    if( (flags & SYNC_PUSH)!=0 && memcmp(zAutosync,"pull",4)==0 ){
    55     46         return 0;   /* Do not auto-push when autosync=pullonly */
    56     47       }
    57     48       if( is_false(zAutosync) ){
    58     49         return 0;   /* Autosync is completely off */
    59     50       }
    60     51     }else{
    61     52       /* Autosync defaults on.  To make it default off, "return" here. */
................................................................................
    79     70       ** autosync, or something?
    80     71       */
    81     72       configSync = CONFIGSET_SHUN;
    82     73     }
    83     74   #endif
    84     75     fossil_print("Autosync:  %s\n", g.urlCanonical);
    85     76     url_enable_proxy("via proxy: ");
    86         -  rc = client_sync((flags & AUTOSYNC_PUSH)!=0, 1, 0, 0, configSync, 0);
           77  +  rc = client_sync(flags, configSync, 0);
    87     78     if( rc ) fossil_warning("Autosync failed");
    88     79     return rc;
    89     80   }
    90     81   
    91     82   /*
    92     83   ** This routine processes the command-line argument for push, pull,
    93     84   ** and sync.  If a command-line argument is given, that is the URL
    94     85   ** of a server to sync against.  If no argument is given, use the
    95     86   ** most recently synced URL.  Remember the current URL for next time.
    96     87   */
    97         -static void process_sync_args(int *pConfigSync, int *pPrivate){
           88  +static void process_sync_args(unsigned *pConfigFlags, unsigned *pSyncFlags){
    98     89     const char *zUrl = 0;
    99     90     const char *zPw = 0;
   100         -  int configSync = 0;
           91  +  unsigned configSync = 0;
   101     92     int urlOptional = find_option("autourl",0,0)!=0;
   102     93     g.dontKeepUrl = find_option("once",0,0)!=0;
   103         -  *pPrivate = find_option("private",0,0)!=0;
           94  +  if( find_option("private",0,0)!=0 ){
           95  +    *pSyncFlags |= SYNC_PRIVATE;
           96  +  }
           97  +  if( find_option("verbose","v",0)!=0 ){
           98  +    *pSyncFlags |= SYNC_VERBOSE;
           99  +  }
   104    100     url_proxy_options();
   105    101     db_find_and_open_repository(0, 0);
   106    102     db_open_config(0);
   107    103     if( g.argc==2 ){
   108    104       zUrl = db_get("last-sync-url", 0);
   109    105       zPw = unobscure(db_get("last-sync-pw", 0));
   110    106       if( db_get_boolean("auto-shun",1) ) configSync = CONFIGSET_SHUN;
................................................................................
   125    121     }
   126    122     if( !g.dontKeepUrl ){
   127    123       db_set("last-sync-url", g.urlCanonical, 0);
   128    124       if( g.urlPasswd ) db_set("last-sync-pw", obscure(g.urlPasswd), 0);
   129    125     }
   130    126     user_select();
   131    127     if( g.argc==2 ){
   132         -    fossil_print("Server:    %s\n", g.urlCanonical);
          128  +    if( ((*pSyncFlags) & (SYNC_PUSH|SYNC_PULL))==(SYNC_PUSH|SYNC_PULL) ){
          129  +      fossil_print("Sync with %s\n", g.urlCanonical);
          130  +    }else if( (*pSyncFlags) & SYNC_PUSH ){
          131  +      fossil_print("Push to %s\n", g.urlCanonical);
          132  +    }else if( (*pSyncFlags) & SYNC_PULL ){
          133  +      fossil_print("Pull from %s\n", g.urlCanonical);
          134  +    }
   133    135     }
   134    136     url_enable_proxy("via proxy: ");
   135         -  *pConfigSync = configSync;
          137  +  *pConfigFlags |= configSync;
   136    138   }
   137    139   
   138    140   /*
   139    141   ** COMMAND: pull
   140    142   **
   141    143   ** Usage: %fossil pull ?URL? ?options?
   142    144   **
................................................................................
   154    156   **
   155    157   ** Use the --private option to pull private branches from the
   156    158   ** remote repository.
   157    159   **
   158    160   ** See also: clone, push, sync, remote-url
   159    161   */
   160    162   void pull_cmd(void){
   161         -  int syncFlags;
   162         -  int bPrivate;
   163         -  process_sync_args(&syncFlags, &bPrivate);
   164         -  client_sync(0,1,0,bPrivate,syncFlags,0);
          163  +  unsigned configFlags = 0;
          164  +  unsigned syncFlags = SYNC_PULL;
          165  +  process_sync_args(&configFlags, &syncFlags);
          166  +  client_sync(syncFlags, configFlags, 0);
   165    167   }
   166    168   
   167    169   /*
   168    170   ** COMMAND: push
   169    171   **
   170    172   ** Usage: %fossil push ?URL? ?options?
   171    173   **
................................................................................
   183    185   **
   184    186   ** Use the --private option to push private branches to the
   185    187   ** remote repository.
   186    188   **
   187    189   ** See also: clone, pull, sync, remote-url
   188    190   */
   189    191   void push_cmd(void){
   190         -  int syncFlags;
   191         -  int bPrivate;
   192         -  process_sync_args(&syncFlags, &bPrivate);
          192  +  unsigned configFlags = 0;
          193  +  unsigned syncFlags = SYNC_PUSH;
          194  +  process_sync_args(&configFlags, &syncFlags);
   193    195     if( db_get_boolean("dont-push",0) ){
   194    196       fossil_fatal("pushing is prohibited: the 'dont-push' option is set");
   195    197     }
   196         -  client_sync(1,0,0,bPrivate,0,0);
          198  +  client_sync(syncFlags, 0, 0);
   197    199   }
   198    200   
   199    201   
   200    202   /*
   201    203   ** COMMAND: sync
   202    204   **
   203    205   ** Usage: %fossil sync ?URL? ?options?
................................................................................
   221    223   **
   222    224   ** Use the --private option to sync private branches with the
   223    225   ** remote repository.
   224    226   **
   225    227   ** See also:  clone, push, pull, remote-url
   226    228   */
   227    229   void sync_cmd(void){
   228         -  int syncFlags;
   229         -  int bPrivate;
   230         -  int pushFlag = 1;
   231         -  process_sync_args(&syncFlags, &bPrivate);
   232         -  if( db_get_boolean("dont-push",0) ) pushFlag = 0;
   233         -  client_sync(pushFlag,1,0,bPrivate,syncFlags,0);
   234         -  if( pushFlag==0 ){
          230  +  unsigned configFlags = 0;
          231  +  unsigned syncFlags = SYNC_PUSH|SYNC_PULL;
          232  +  process_sync_args(&configFlags, &syncFlags);
          233  +  if( db_get_boolean("dont-push",0) ) syncFlags &= ~SYNC_PUSH;
          234  +  client_sync(syncFlags, configFlags, 0);
          235  +  if( (syncFlags & SYNC_PUSH)==0 ){
   235    236       fossil_warning("pull only: the 'dont-push' option is set");
   236    237     }
   237    238   }
   238    239   
   239    240   /*
   240    241   ** COMMAND: remote-url
   241    242   **

Changes to src/update.c.

   121    121     debugFlag = find_option("debug",0,0)!=0;
   122    122     setmtimeFlag = find_option("setmtime",0,0)!=0;
   123    123     db_must_be_within_tree();
   124    124     vid = db_lget_int("checkout", 0);
   125    125     if( vid==0 ){
   126    126       fossil_fatal("cannot find current version");
   127    127     }
   128         -  if( !nochangeFlag && !internalUpdate ) autosync(AUTOSYNC_PULL);
          128  +  if( !nochangeFlag && !internalUpdate ) autosync(SYNC_PULL);
   129    129     
   130    130     /* Create any empty directories now, as well as after the update,
   131    131     ** so changes in settings are reflected now */
   132    132     if( !nochangeFlag ) ensure_empty_dirs_created();
   133    133   
   134    134     if( internalUpdate ){
   135    135       tid = internalUpdate;

Changes to src/xfer.c.

  1264   1264   }
  1265   1265   
  1266   1266   /*
  1267   1267   ** Format strings for progress reporting.
  1268   1268   */
  1269   1269   static const char zLabelFormat[] = "%-10s %10s %10s %10s %10s\n";
  1270   1270   static const char zValueFormat[] = "\r%-10s %10d %10d %10d %10d\n";
         1271  +static const char zBriefFormat[] =
         1272  +   "Round-trips: %d   Artifacts sent: %d  received: %d\r";
  1271   1273   
         1274  +#if INTERFACE
         1275  +/*
         1276  +** Flag options for controlling client_sync()
         1277  +*/
         1278  +#define SYNC_PUSH      0x0001
         1279  +#define SYNC_PULL      0x0002
         1280  +#define SYNC_CLONE     0x0004
         1281  +#define SYNC_PRIVATE   0x0008
         1282  +#define SYNC_VERBOSE   0x0010
         1283  +#endif
  1272   1284   
  1273   1285   /*
  1274   1286   ** Sync to the host identified in g.urlName and g.urlPath.  This
  1275   1287   ** routine is called by the client.
  1276   1288   **
  1277   1289   ** Records are pushed to the server if pushFlag is true.  Records
  1278   1290   ** are pulled if pullFlag is true.  A full sync occurs if both are
  1279   1291   ** true.
  1280   1292   */
  1281   1293   int client_sync(
  1282         -  int pushFlag,           /* True to do a push (or a sync) */
  1283         -  int pullFlag,           /* True to do a pull (or a sync) */
  1284         -  int cloneFlag,          /* True if this is a clone */
  1285         -  int privateFlag,        /* True to exchange private branches */
  1286         -  int configRcvMask,      /* Receive these configuration items */
  1287         -  int configSendMask      /* Send these configuration items */
         1294  +  unsigned syncFlags,     /* Mask of SYNC_* flags */
         1295  +  unsigned configRcvMask, /* Receive these configuration items */
         1296  +  unsigned configSendMask /* Send these configuration items */
  1288   1297   ){
  1289   1298     int go = 1;             /* Loop until zero */
  1290   1299     int nCardSent = 0;      /* Number of cards sent */
  1291   1300     int nCardRcvd = 0;      /* Number of cards received */
  1292   1301     int nCycle = 0;         /* Number of round trips to the server */
  1293   1302     int size;               /* Size of a config value */
  1294   1303     int origConfigRcvMask;  /* Original value of configRcvMask */
................................................................................
  1302   1311     Xfer xfer;              /* Transfer data */
  1303   1312     int pctDone;            /* Percentage done with a message */
  1304   1313     int lastPctDone = -1;   /* Last displayed pctDone */
  1305   1314     double rArrivalTime;    /* Time at which a message arrived */
  1306   1315     const char *zSCode = db_get("server-code", "x");
  1307   1316     const char *zPCode = db_get("project-code", 0);
  1308   1317     int nErr = 0;           /* Number of errors */
         1318  +  int nRoundtrip= 0;      /* Number of HTTP requests */
         1319  +  int nArtifactSent = 0;  /* Total artifacts sent */
         1320  +  int nArtifactRcvd = 0;  /* Total artifacts received */
         1321  +  const char *zOpType = 0;/* Push, Pull, Sync, Clone */
  1309   1322   
  1310         -  if( db_get_boolean("dont-push", 0) ) pushFlag = 0;
  1311         -  if( pushFlag + pullFlag + cloneFlag == 0 
         1323  +  if( db_get_boolean("dont-push", 0) ) syncFlags &= ~SYNC_PUSH;
         1324  +  if( (syncFlags & (SYNC_PUSH|SYNC_PULL|SYNC_CLONE))==0 
  1312   1325        && configRcvMask==0 && configSendMask==0 ) return 0;
  1313   1326   
  1314   1327     transport_stats(0, 0, 1);
  1315   1328     socket_global_init();
  1316   1329     memset(&xfer, 0, sizeof(xfer));
  1317   1330     xfer.pIn = &recv;
  1318   1331     xfer.pOut = &send;
  1319   1332     xfer.mxSend = db_get_int("max-upload", 250000);
  1320         -  if( privateFlag ){
         1333  +  if( syncFlags & SYNC_PRIVATE ){
  1321   1334       g.perm.Private = 1;
  1322   1335       xfer.syncPrivate = 1;
  1323   1336     }
  1324   1337   
  1325         -  assert( pushFlag | pullFlag | cloneFlag | configRcvMask | configSendMask );
  1326   1338     db_begin_transaction();
  1327   1339     db_record_repository_filename(0);
  1328   1340     db_multi_exec(
  1329   1341       "CREATE TEMP TABLE onremote(rid INTEGER PRIMARY KEY);"
  1330   1342     );
  1331   1343     blobarray_zero(xfer.aToken, count(xfer.aToken));
  1332   1344     blob_zero(&send);
................................................................................
  1333   1345     blob_zero(&recv);
  1334   1346     blob_zero(&xfer.err);
  1335   1347     blob_zero(&xfer.line);
  1336   1348     origConfigRcvMask = 0;
  1337   1349   
  1338   1350   
  1339   1351     /* Send the send-private pragma if we are trying to sync private data */
  1340         -  if( privateFlag ) blob_append(&send, "pragma send-private\n", -1);
         1352  +  if( syncFlags & SYNC_PRIVATE ){
         1353  +    blob_append(&send, "pragma send-private\n", -1);
         1354  +  }
  1341   1355   
  1342   1356     /*
  1343   1357     ** Always begin with a clone, pull, or push message
  1344   1358     */
  1345         -  if( cloneFlag ){
         1359  +  if( syncFlags & SYNC_CLONE ){
  1346   1360       blob_appendf(&send, "clone 3 %d\n", cloneSeqno);
  1347         -    pushFlag = 0;
  1348         -    pullFlag = 0;
         1361  +    syncFlags &= ~(SYNC_PUSH|SYNC_PULL);
  1349   1362       nCardSent++;
  1350   1363       /* TBD: Request all transferable configuration values */
  1351   1364       content_enable_dephantomize(0);
  1352         -  }else if( pullFlag ){
         1365  +    zOpType = "Clone";
         1366  +  }else if( syncFlags & SYNC_PULL ){
  1353   1367       blob_appendf(&send, "pull %s %s\n", zSCode, zPCode);
  1354   1368       nCardSent++;
         1369  +    zOpType = "Pull";
  1355   1370     }
  1356         -  if( pushFlag ){
         1371  +  if( syncFlags & SYNC_PUSH ){
  1357   1372       blob_appendf(&send, "push %s %s\n", zSCode, zPCode);
  1358   1373       nCardSent++;
         1374  +    if( (syncFlags & SYNC_PULL)==0 ) zOpType = "Push";
  1359   1375     }
  1360   1376     manifest_crosslink_begin();
  1361   1377     transport_global_startup();
  1362         -  fossil_print(zLabelFormat, "", "Bytes", "Cards", "Artifacts", "Deltas");
         1378  +  if( syncFlags & SYNC_VERBOSE ){
         1379  +    fossil_print(zLabelFormat, "", "Bytes", "Cards", "Artifacts", "Deltas");
         1380  +  }
  1363   1381   
  1364   1382     while( go ){
  1365   1383       int newPhantom = 0;
  1366   1384       char *zRandomness;
  1367   1385   
  1368   1386       /* Send make the most recently received cookie.  Let the server
  1369   1387       ** figure out if this is a cookie that it cares about.
................................................................................
  1372   1390       if( zCookie ){
  1373   1391         blob_appendf(&send, "cookie %s\n", zCookie);
  1374   1392       }
  1375   1393       
  1376   1394       /* Generate gimme cards for phantoms and leaf cards
  1377   1395       ** for all leaves.
  1378   1396       */
  1379         -    if( pullFlag || (cloneFlag && cloneSeqno==1) ){
         1397  +    if( (syncFlags & SYNC_PULL)!=0
         1398  +     || ((syncFlags & SYNC_CLONE)!=0 && cloneSeqno==1)
         1399  +    ){
  1380   1400         request_phantoms(&xfer, mxPhantomReq);
  1381   1401       }
  1382         -    if( pushFlag ){
         1402  +    if( syncFlags & SYNC_PUSH ){
  1383   1403         send_unsent(&xfer);
  1384   1404         nCardSent += send_unclustered(&xfer);
  1385         -      if( privateFlag ) send_private(&xfer);
         1405  +      if( syncFlags & SYNC_PRIVATE ) send_private(&xfer);
  1386   1406       }
  1387   1407   
  1388   1408       /* Send configuration parameter requests.  On a clone, delay sending
  1389   1409       ** this until the second cycle since the login card might fail on 
  1390   1410       ** the first cycle.
  1391   1411       */
  1392         -    if( configRcvMask && (cloneFlag==0 || nCycle>0) ){
         1412  +    if( configRcvMask && ((syncFlags & SYNC_CLONE)==0 || nCycle>0) ){
  1393   1413         const char *zName;
         1414  +      if( zOpType==0 ) zOpType = "Pull";
  1394   1415         zName = configure_first_name(configRcvMask);
  1395   1416         while( zName ){
  1396   1417           blob_appendf(&send, "reqconfig %s\n", zName);
  1397   1418           zName = configure_next_name(configRcvMask);
  1398   1419           nCardSent++;
  1399   1420         }
  1400   1421         if( (configRcvMask & (CONFIGSET_USER|CONFIGSET_TKT))!=0
................................................................................
  1405   1426         }
  1406   1427         origConfigRcvMask = configRcvMask;
  1407   1428         configRcvMask = 0;
  1408   1429       }
  1409   1430   
  1410   1431       /* Send configuration parameters being pushed */
  1411   1432       if( configSendMask ){
         1433  +      if( zOpType==0 ) zOpType = "Push";
  1412   1434         if( configSendMask & CONFIGSET_OLDFORMAT ){
  1413   1435           const char *zName;
  1414   1436           zName = configure_first_name(configSendMask);
  1415   1437           while( zName ){
  1416   1438             send_legacy_config_card(&xfer, zName);
  1417   1439             zName = configure_next_name(configSendMask);
  1418   1440             nCardSent++;
................................................................................
  1428   1450       ** be unique.
  1429   1451       */
  1430   1452       zRandomness = db_text(0, "SELECT hex(randomblob(20))");
  1431   1453       blob_appendf(&send, "# %s\n", zRandomness);
  1432   1454       free(zRandomness);
  1433   1455   
  1434   1456       /* Exchange messages with the server */
  1435         -    fossil_print(zValueFormat, "Sent:",
  1436         -                 blob_size(&send), nCardSent+xfer.nGimmeSent+xfer.nIGotSent,
  1437         -                 xfer.nFileSent, xfer.nDeltaSent);
         1457  +    if( syncFlags & SYNC_VERBOSE ){
         1458  +      fossil_print(zValueFormat, "Sent:",
         1459  +                   blob_size(&send), nCardSent+xfer.nGimmeSent+xfer.nIGotSent,
         1460  +                   xfer.nFileSent, xfer.nDeltaSent);
         1461  +    }else{
         1462  +      nRoundtrip++;
         1463  +      nArtifactSent += xfer.nFileSent + xfer.nDeltaSent;
         1464  +      fossil_print(zBriefFormat, nRoundtrip, nArtifactSent, nArtifactRcvd);
         1465  +    }
  1438   1466       nCardSent = 0;
  1439   1467       nCardRcvd = 0;
  1440   1468       xfer.nFileSent = 0;
  1441   1469       xfer.nDeltaSent = 0;
  1442   1470       xfer.nGimmeSent = 0;
  1443   1471       xfer.nIGotSent = 0;
  1444         -    if( !g.cgiOutput && !g.fQuiet ){
         1472  +    if( syncFlags & SYNC_VERBOSE ){
  1445   1473         fossil_print("waiting for server...");
  1446   1474       }
  1447   1475       fflush(stdout);
  1448         -    if( http_exchange(&send, &recv, cloneFlag==0 || nCycle>0) ){
         1476  +    if( http_exchange(&send, &recv, (syncFlags & SYNC_CLONE)==0 || nCycle>0) ){
  1449   1477         nErr++;
  1450   1478         break;
  1451   1479       }
  1452   1480       lastPctDone = -1;
  1453   1481       blob_reset(&send);
  1454   1482       rArrivalTime = db_double(0.0, "SELECT julianday('now')");
  1455   1483   
  1456   1484       /* Send the send-private pragma if we are trying to sync private data */
  1457         -    if( privateFlag ) blob_append(&send, "pragma send-private\n", -1);
         1485  +    if( syncFlags & SYNC_PRIVATE ){
         1486  +      blob_append(&send, "pragma send-private\n", -1);
         1487  +    }
  1458   1488   
  1459   1489       /* Begin constructing the next message (which might never be
  1460   1490       ** sent) by beginning with the pull or push cards
  1461   1491       */
  1462         -    if( pullFlag ){
         1492  +    if( syncFlags & SYNC_PULL ){
  1463   1493         blob_appendf(&send, "pull %s %s\n", zSCode, zPCode);
  1464   1494         nCardSent++;
  1465   1495       }
  1466         -    if( pushFlag ){
         1496  +    if( syncFlags & SYNC_PUSH ){
  1467   1497         blob_appendf(&send, "push %s %s\n", zSCode, zPCode);
  1468   1498         nCardSent++;
  1469   1499       }
  1470   1500       go = 0;
  1471   1501   
  1472   1502       /* Process the reply that came back from the server */
  1473   1503       while( blob_line(&recv, &xfer.line) ){
................................................................................
  1491   1521             }
  1492   1522           }
  1493   1523           nCardRcvd++;
  1494   1524           continue;
  1495   1525         }
  1496   1526         xfer.nToken = blob_tokenize(&xfer.line, xfer.aToken, count(xfer.aToken));
  1497   1527         nCardRcvd++;
  1498         -      if( !g.cgiOutput && !g.fQuiet && recv.nUsed>0 ){
         1528  +      if( (syncFlags & SYNC_VERBOSE)!=0 && recv.nUsed>0 ){
  1499   1529           pctDone = (recv.iCursor*100)/recv.nUsed;
  1500   1530           if( pctDone!=lastPctDone ){
  1501   1531             fossil_print("\rprocessed: %d%%         ", pctDone);
  1502   1532             lastPctDone = pctDone;
  1503   1533             fflush(stdout);
  1504   1534           }
  1505   1535         }
................................................................................
  1506   1536   
  1507   1537         /*   file UUID SIZE \n CONTENT
  1508   1538         **   file UUID DELTASRC SIZE \n CONTENT
  1509   1539         **
  1510   1540         ** Receive a file transmitted from the server.
  1511   1541         */
  1512   1542         if( blob_eq(&xfer.aToken[0],"file") ){
  1513         -        xfer_accept_file(&xfer, cloneFlag);
         1543  +        xfer_accept_file(&xfer, (syncFlags & SYNC_CLONE)!=0);
         1544  +        nArtifactRcvd++;
  1514   1545         }else
  1515   1546   
  1516   1547         /*   cfile UUID USIZE CSIZE \n CONTENT
  1517   1548         **   cfile UUID DELTASRC USIZE CSIZE \n CONTENT
  1518   1549         **
  1519   1550         ** Receive a compressed file transmitted from the server.
  1520   1551         */
  1521   1552         if( blob_eq(&xfer.aToken[0],"cfile") ){
  1522   1553           xfer_accept_compressed_file(&xfer);
         1554  +        nArtifactRcvd++;
  1523   1555         }else
  1524   1556   
  1525   1557         /*   gimme UUID
  1526   1558         **
  1527   1559         ** Server is requesting a file.  If the file is a manifest, assume
  1528   1560         ** that the server will also want to know all of the content files
  1529   1561         ** associated with the manifest and send those too.
  1530   1562         */
  1531   1563         if( blob_eq(&xfer.aToken[0], "gimme")
  1532   1564          && xfer.nToken==2
  1533   1565          && blob_is_uuid(&xfer.aToken[1])
  1534   1566         ){
  1535         -        if( pushFlag ){
         1567  +        if( syncFlags & SYNC_PUSH ){
  1536   1568             int rid = rid_from_uuid(&xfer.aToken[1], 0, 0);
  1537   1569             if( rid ) send_file(&xfer, rid, &xfer.aToken[1], 0);
  1538   1570           }
  1539   1571         }else
  1540   1572     
  1541   1573         /*   igot UUID  ?PRIVATEFLAG?
  1542   1574         **
................................................................................
  1557   1589           int rid;
  1558   1590           int isPriv = xfer.nToken>=3 && blob_eq(&xfer.aToken[2],"1");
  1559   1591           rid = rid_from_uuid(&xfer.aToken[1], 0, 0);
  1560   1592           if( rid>0 ){
  1561   1593             if( !isPriv ) content_make_public(rid);
  1562   1594           }else if( isPriv && !g.perm.Private ){
  1563   1595             /* ignore private files */
  1564         -        }else if( pullFlag || cloneFlag ){
         1596  +        }else if( (syncFlags & (SYNC_PULL|SYNC_CLONE))!=0 ){
  1565   1597             rid = content_new(blob_str(&xfer.aToken[1]), isPriv);
  1566   1598             if( rid ) newPhantom = 1;
  1567   1599           }
  1568   1600           remote_has(rid);
  1569   1601         }else
  1570   1602       
  1571   1603         
................................................................................
  1572   1604         /*   push  SERVERCODE  PRODUCTCODE
  1573   1605         **
  1574   1606         ** Should only happen in response to a clone.  This message tells
  1575   1607         ** the client what product to use for the new database.
  1576   1608         */
  1577   1609         if( blob_eq(&xfer.aToken[0],"push")
  1578   1610          && xfer.nToken==3
  1579         -       && cloneFlag
         1611  +       && (syncFlags & SYNC_CLONE)!=0
  1580   1612          && blob_is_uuid(&xfer.aToken[1])
  1581   1613          && blob_is_uuid(&xfer.aToken[2])
  1582   1614         ){
  1583   1615           if( blob_eq_str(&xfer.aToken[1], zSCode, -1) ){
  1584   1616             fossil_fatal("server loop");
  1585   1617           }
  1586   1618           if( zPCode==0 ){
................................................................................
  1602   1634             && blob_is_int(&xfer.aToken[2], &size) ){
  1603   1635           const char *zName = blob_str(&xfer.aToken[1]);
  1604   1636           Blob content;
  1605   1637           blob_zero(&content);
  1606   1638           blob_extract(xfer.pIn, size, &content);
  1607   1639           g.perm.Admin = g.perm.RdAddr = 1;
  1608   1640           configure_receive(zName, &content, origConfigRcvMask);
  1609         -        nCardSent++;
         1641  +        nCardRcvd++;
         1642  +        nArtifactRcvd++;
  1610   1643           blob_reset(&content);
  1611   1644           blob_seek(xfer.pIn, 1, BLOB_SEEK_CUR);
  1612   1645         }else
  1613   1646   
  1614   1647         
  1615   1648         /*    cookie TEXT
  1616   1649         **
................................................................................
  1653   1686         **
  1654   1687         ** If the "login failed" message is seen, clear the sync password prior
  1655   1688         ** to the next cycle.
  1656   1689         */        
  1657   1690         if( blob_eq(&xfer.aToken[0],"message") && xfer.nToken==2 ){
  1658   1691           char *zMsg = blob_terminate(&xfer.aToken[1]);
  1659   1692           defossilize(zMsg);
  1660         -        if( pushFlag && zMsg && strglob("pull only *", zMsg) ){
  1661         -          pushFlag = 0;
         1693  +        if( (syncFlags & SYNC_PUSH) && zMsg && strglob("pull only *", zMsg) ){
         1694  +          syncFlags &= ~SYNC_PUSH;
  1662   1695             zMsg = 0;
  1663   1696           }
  1664   1697           fossil_print("\rServer says: %s\n", zMsg);
  1665   1698         }else
  1666   1699   
  1667   1700         /*    pragma NAME VALUE...
  1668   1701         **
................................................................................
  1681   1714         ** first message exchange because the project-code is unknown
  1682   1715         ** and so the login card on the request was invalid.  The project-code
  1683   1716         ** is returned in the reply before the error card, so second and 
  1684   1717         ** subsequent messages should be OK.  Nevertheless, we need to ignore
  1685   1718         ** the error card on the first message of a clone.
  1686   1719         */        
  1687   1720         if( blob_eq(&xfer.aToken[0],"error") && xfer.nToken==2 ){
  1688         -        if( !cloneFlag || nCycle>0 ){
         1721  +        if( (syncFlags & SYNC_CLONE)==0 || nCycle>0 ){
  1689   1722             char *zMsg = blob_terminate(&xfer.aToken[1]);
  1690   1723             defossilize(zMsg);
  1691   1724             if( fossil_strcmp(zMsg, "login failed")==0 ){
  1692   1725               if( nCycle<2 ){
  1693   1726                 if( !g.dontKeepUrl ) db_unset("last-sync-pw", 0);
  1694   1727                 go = 1;
  1695   1728               }
................................................................................
  1725   1758       }
  1726   1759       if( (configRcvMask & (CONFIGSET_USER|CONFIGSET_TKT))!=0
  1727   1760        && (configRcvMask & CONFIGSET_OLDFORMAT)!=0
  1728   1761       ){
  1729   1762         configure_finalize_receive();
  1730   1763       }
  1731   1764       origConfigRcvMask = 0;
  1732         -    if( nCardRcvd>0 ){
         1765  +    if( nCardRcvd>0 && (syncFlags & SYNC_VERBOSE) ){
  1733   1766         fossil_print(zValueFormat, "Received:",
  1734   1767                      blob_size(&recv), nCardRcvd,
  1735   1768                      xfer.nFileRcvd, xfer.nDeltaRcvd + xfer.nDanglingFile);
         1769  +    }else{
         1770  +      fossil_print(zBriefFormat, nRoundtrip, nArtifactSent, nArtifactRcvd);
  1736   1771       }
  1737   1772       blob_reset(&recv);
  1738   1773       nCycle++;
  1739   1774   
  1740   1775       /* If we received one or more files on the previous exchange but
  1741   1776       ** there are still phantoms, then go another round.
  1742   1777       */
  1743   1778       nFileRecv = xfer.nFileRcvd + xfer.nDeltaRcvd + xfer.nDanglingFile;
  1744   1779       if( (nFileRecv>0 || newPhantom) && db_exists("SELECT 1 FROM phantom") ){
  1745   1780         go = 1;
  1746   1781         mxPhantomReq = nFileRecv*2;
  1747   1782         if( mxPhantomReq<200 ) mxPhantomReq = 200;
  1748         -    }else if( cloneFlag && nFileRecv>0 ){
         1783  +    }else if( (syncFlags & SYNC_CLONE)!=0 && nFileRecv>0 ){
  1749   1784         go = 1;
  1750   1785       }
  1751   1786       nCardRcvd = 0;
  1752   1787       xfer.nFileRcvd = 0;
  1753   1788       xfer.nDeltaRcvd = 0;
  1754   1789       xfer.nDanglingFile = 0;
  1755   1790   
................................................................................
  1757   1792       ** another round 
  1758   1793       */
  1759   1794       if( xfer.nFileSent+xfer.nDeltaSent>0 ){
  1760   1795         go = 1;
  1761   1796       }
  1762   1797   
  1763   1798       /* If this is a clone, the go at least two rounds */
  1764         -    if( cloneFlag && nCycle==1 ) go = 1;
         1799  +    if( (syncFlags & SYNC_CLONE)!=0 && nCycle==1 ) go = 1;
  1765   1800   
  1766   1801       /* Stop the cycle if the server sends a "clone_seqno 0" card and
  1767   1802       ** we have gone at least two rounds.  Always go at least two rounds
  1768   1803       ** on a clone in order to be sure to retrieve the configuration
  1769   1804       ** information which is only sent on the second round.
  1770   1805       */
  1771   1806       if( cloneSeqno<=0 && nCycle>1 ) go = 0;   
  1772   1807     };
  1773   1808     transport_stats(&nSent, &nRcvd, 1);
  1774         -  fossil_print("Total network traffic: %lld bytes sent, %lld bytes received\n",
  1775         -               nSent, nRcvd);
         1809  +  if( (syncFlags & SYNC_VERBOSE)==0 ) fossil_print("\n");
         1810  +  fossil_print(
         1811  +     "%s finished with %lld bytes sent, %lld bytes received\n",
         1812  +     zOpType, nSent, nRcvd);
  1776   1813     transport_close();
  1777   1814     transport_global_shutdown();
  1778   1815     db_multi_exec("DROP TABLE onremote");
  1779   1816     manifest_crosslink_end();
  1780   1817     content_enable_dephantomize(1);
  1781   1818     db_end_transaction(0);
  1782   1819     return nErr;
  1783   1820   }