func main() {
flag.Usage = printUsage
flag.Parse()
if flag.NArg() < 1 {
printUsage()
os.Exit(2)
}
if err := setupclient.SetupTls(true); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
objectServer := objectclient.NewObjectClient(fmt.Sprintf("%s:%d",
*objectServerHostname, *objectServerPortNum))
numSubcommandArgs := flag.NArg() - 1
for _, subcommand := range subcommands {
if flag.Arg(0) == subcommand.command {
if numSubcommandArgs < subcommand.minArgs ||
(subcommand.maxArgs >= 0 &&
numSubcommandArgs > subcommand.maxArgs) {
printUsage()
os.Exit(2)
}
subcommand.cmdFunc(objectServer, flag.Args()[1:])
os.Exit(3)
}
}
printUsage()
os.Exit(2)
}
func getClients() (*srpc.Client, *objectclient.ObjectClient) {
if imageSrpcClient == nil {
var err error
clientName := fmt.Sprintf("%s:%d",
*imageServerHostname, *imageServerPortNum)
imageSrpcClient, err = srpc.DialHTTP("tcp", clientName, 0)
if err != nil {
fmt.Fprintf(os.Stderr, "Error dialing\t%s\n", err)
os.Exit(1)
}
theObjectClient = objectclient.NewObjectClient(clientName)
}
return imageSrpcClient, theObjectClient
}
func (t *rpcType) doFetch(request sub.FetchRequest) error {
defer t.clearFetchInProgress()
objectServer := objectclient.NewObjectClient(request.ServerAddress)
defer objectServer.Close()
benchmark := false
linkSpeed, haveLinkSpeed := netspeed.GetSpeedToAddress(
request.ServerAddress)
if haveLinkSpeed {
t.logFetch(request, linkSpeed)
} else {
if t.networkReaderContext.MaximumSpeed() < 1 {
benchmark = enoughBytesForBenchmark(objectServer, request)
if benchmark {
objectServer.SetExclusiveGetObjects(true)
t.logger.Printf("Fetch(%s) %d objects and benchmark speed\n",
request.ServerAddress, len(request.Hashes))
} else {
t.logFetch(request, 0)
}
} else {
t.logFetch(request, t.networkReaderContext.MaximumSpeed())
}
}
objectsReader, err := objectServer.GetObjects(request.Hashes)
if err != nil {
t.logger.Printf("Error getting object reader: %s\n", err.Error())
return err
}
defer objectsReader.Close()
var totalLength uint64
defer t.rescanObjectCacheFunction()
timeStart := time.Now()
for _, hash := range request.Hashes {
length, reader, err := objectsReader.NextObject()
if err != nil {
t.logger.Println(err)
return err
}
r := io.Reader(reader)
if haveLinkSpeed {
if linkSpeed > 0 {
r = rateio.NewReaderContext(linkSpeed,
uint64(t.networkReaderContext.SpeedPercent()),
&rateio.ReadMeasurer{}).NewReader(reader)
}
} else if !benchmark {
r = t.networkReaderContext.NewReader(reader)
}
err = readOne(t.objectsDir, hash, length, r)
reader.Close()
if err != nil {
t.logger.Println(err)
return err
}
totalLength += length
}
duration := time.Since(timeStart)
speed := uint64(float64(totalLength) / duration.Seconds())
if benchmark {
file, err := os.Create(t.netbenchFilename)
if err == nil {
fmt.Fprintf(file, "%d\n", speed)
file.Close()
}
t.networkReaderContext.InitialiseMaximumSpeed(speed)
}
t.logger.Printf("Fetch() complete. Read: %s in %s (%s/s)\n",
format.FormatBytes(totalLength), format.Duration(duration),
format.FormatBytes(speed))
return nil
}
