August 2018 – Records And Memorys

On office 190 ubuntu machine 124.82.4.190 , 9900

wget http://mirror.bit.edu.cn/apache/thrift/0.11.0/thrift-0.11.0.tar.gz

tar xvzf thrift-0.11.0.tar.gz
install pre – requirements modules , because 190 is ubantu machine , so following these steps

https://thrift.apache.org/docs/install/debian

CSharp additonal need following modules : mono-gmcs mono-devel libmono-system-web2.0-cil nunit nunit-console

Now will install them one by one

a) install mono complete by https://gist.github.com/carolynvs/4520736f6017ca252a44

wget http://download.mono-project.com/repo/xamarin.gpg
sudo apt-key add xamarin.gpg
echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee --append /etc/apt/sources.list.d/mono-xamarin.list
sudo apt-get update
sudo apt-get install mono-complete

<del>sudo certmgr -ssl -m https://go.microsoft.com
sudo certmgr -ssl -m https://nugetgallery.blob.core.windows.net
sudo certmgr -ssl -m https://nuget.org
mozroots --import --sync</del>

wget http://download.mono-project.com/repo/xamarin.gpg

sudo apt-key add xamarin.gpg

echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee --append /etc/apt/sources.list.d/mono-xamarin.list

sudo apt-get update

sudo apt-get install mono-complete

<del>sudo certmgr -ssl -m https://go.microsoft.com

sudo certmgr -ssl -m https://nugetgallery.blob.core.windows.net

sudo certmgr -ssl -m https://nuget.org

mozroots --import --sync</del>

only exec first 5 steps

b) install nunit by this command : sudo apt-get install nunit nunit-console

from https://zxtech.wordpress.com/2015/01/05/install-nunit-on-ubuntu/

Now all the pre-requirement are installed .

Build

From https://thrift.apache.org/docs/BuildingFromSource

goto /home/liuyang/thrift-0.11.0/

run command one by one :

./bootstrap.sh

1	./bootstrap.sh

./configure

1	./configure

make

make

make check    <span style="color: #0000ff;"> this step  fail </span>

1	make check <span style="color: #0000ff;"> this step fail </span>

sh test/test.sh   <span style="color: #0000ff;">this step not exec</span>

1	sh test/test.sh <span style="color: #0000ff;">this step not exec</span>

make install   <span style="color: #0000ff;">*****  very important , MUST install </span>

1	make install <span style="color: #0000ff;">***** very important , MUST install </span>

- Make a test c# project

A cSharp project which use thrift should add reference to “Thrift.dll”

goto folder : /home/liuyang/thrift-0.11.0/tutorial

run command : rm -r csharp , delete existing csharp folder

then run command : thrift -r –gen csharp tutorial.thrift

there will be a new folder named “gen-csharp” , and here is the file will be used as server and client ,But no .sln file .

Thrift will gen both server and client side code , Now try to make a server side project , it need these files :

Calculator.cs
InvalidOperation.cs
Operation.cs
SharedService.cs
SharedStruct.cs
Work.cs

Calculator.cs

InvalidOperation.cs

Operation.cs

SharedService.cs

SharedStruct.cs

Work.cs

then change server side ‘s Program.cs to

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

using System;
using System.Collections.Generic;
using Thrift.Server;
using Thrift.Transport;

namespace thriftServer
{
    public class CalculatorHandler : Calculator.Iface
    {
        Dictionary<int, SharedStruct> log;

        public CalculatorHandler()
        {
            log = new Dictionary<int, SharedStruct>();
        }

        public void ping()
        {
            //Console.WriteLine("ping()");
        }

        public int add(int n1, int n2)
        {
            //Console.WriteLine("add({0},{1})", n1, n2);
            return n1 + n2;
        }

        public int calculate(int logid, Work work)
        {
            //Console.WriteLine("calculate({0}, [{1},{2},{3}])", logid, work.Op, work.Num1, work.Num2);
            int val = 0;
            switch (work.Op)
            {
                case Operation.ADD:
                    val = work.Num1 + work.Num2;
                    break;

                case Operation.SUBTRACT:
                    val = work.Num1 - work.Num2;
                    break;

                case Operation.MULTIPLY:
                    val = work.Num1 * work.Num2;
                    break;

                case Operation.DIVIDE:
                    if (work.Num2 == 0)
                    {
                        InvalidOperation io = new InvalidOperation();
                        io.WhatOp = (int)work.Op;
                        io.Why = "Cannot divide by 0";
                        throw io;
                    }
                    val = work.Num1 / work.Num2;
                    break;

                default:
                    {
                        InvalidOperation io = new InvalidOperation();




                        
                        io.WhatOp = (int)work.Op;
                        io.Why = "Unknown operation";
                        throw io;
                    }
            }

            SharedStruct entry = new SharedStruct();
            entry.Key = logid;
            entry.Value = val.ToString();
            log[logid] = entry;

            return val;
        }

        public SharedStruct getStruct(int key)
        {
            //Console.WriteLine("getStruct({0})", key);
            return log[key];
        }

        public void zip()
        {
            //Console.WriteLine("zip()");
        }
    }

    public class Program
    {
        public static void Main()
        {
            try
            {
                CalculatorHandler handler = new CalculatorHandler();
                Calculator.Processor processor = new Calculator.Processor(handler);
                TServerTransport serverTransport = new TServerSocket(9090);
                
                
                //TServer server = new TSimpleServer(processor, serverTransport);
                TServer server = new TThreadPoolServer(processor, serverTransport);
              



                // Use this for a multithreaded server
                // server = new TThreadPoolServer(processor, serverTransport);

                Console.WriteLine("Starting the server...");
                server.Serve();
            }
            catch (Exception x)
            {
                Console.WriteLine(x.StackTrace);
            }
            Console.WriteLine("done.");
            Console.ReadLine();
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License. You may obtain a copy of the License at

* http://www.apache.org/licenses/LICENSE-2.0

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied. See the License for the

* specific language governing permissions and limitations

* under the License.

using System;

using System.Collections.Generic;

using Thrift.Server;

using Thrift.Transport;

namespace thriftServer

{

public class CalculatorHandler : Calculator.Iface

{

Dictionary<int, SharedStruct> log;

public CalculatorHandler()

{

log = new Dictionary<int, SharedStruct>();

}

public void ping()

{

//Console.WriteLine("ping()");

}

public int add(int n1, int n2)

{

//Console.WriteLine("add({0},{1})", n1, n2);

return n1 + n2;

}

public int calculate(int logid, Work work)

{

//Console.WriteLine("calculate({0}, [{1},{2},{3}])", logid, work.Op, work.Num1, work.Num2);

int val = 0;

switch (work.Op)

{

case Operation.ADD:

val = work.Num1 + work.Num2;

break;

case Operation.SUBTRACT:

val = work.Num1 - work.Num2;

break;

case Operation.MULTIPLY:

val = work.Num1 * work.Num2;

break;

case Operation.DIVIDE:

if (work.Num2 == 0)

{

InvalidOperation io = new InvalidOperation();

io.WhatOp = (int)work.Op;

io.Why = "Cannot divide by 0";

throw io;

}

val = work.Num1 / work.Num2;

break;

default:

{

InvalidOperation io = new InvalidOperation();

io.WhatOp = (int)work.Op;

io.Why = "Unknown operation";

throw io;

}

SharedStruct entry = new SharedStruct();

entry.Key = logid;

entry.Value = val.ToString();

log[logid] = entry;

return val;

}

public SharedStruct getStruct(int key)

{

//Console.WriteLine("getStruct({0})", key);

return log[key];

}

public void zip()

{

//Console.WriteLine("zip()");

}

public class Program

{

public static void Main()

{

try

{

CalculatorHandler handler = new CalculatorHandler();

Calculator.Processor processor = new Calculator.Processor(handler);

TServerTransport serverTransport = new TServerSocket(9090);

//TServer server = new TSimpleServer(processor, serverTransport);

TServer server = new TThreadPoolServer(processor, serverTransport);

// Use this for a multithreaded server

// server = new TThreadPoolServer(processor, serverTransport);

Console.WriteLine("Starting the server...");

server.Serve();

}

catch (Exception x)

{

Console.WriteLine(x.StackTrace);

}

Console.WriteLine("done.");

Console.ReadLine();

}

For client side , need same cs files with server , only it ‘s Program.cs file content is :

using System;
using Thrift;
using Thrift.Protocol;
using Thrift.Server;
using Thrift.Transport;
using log4net;
using System.Threading;

namespace thriftClient
{
    public class Program
    {
        //private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        private static readonly ILog Logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        public static void Main()
        {
            try
            {
                //Logger.Info("Hello logging world!");

                Logger.Info(DateTime.Now.ToString());
                TTransport transport = new TSocket("localhost", 9090);
                TProtocol protocol = new TBinaryProtocol(transport);
                Calculator.Client client = new Calculator.Client(protocol);

                transport.Open();
                try
                {
                    client.ping();
                    Console.WriteLine("ping()");

                    /*   original gen code 
                    int sum = client.add(1, 1);
                    Console.WriteLine("1+1={0}", sum);

                    Work work = new Work();

                    work.Op = Operation.DIVIDE;
                    work.Num1 = 1;
                    work.Num2 = 0;
                    try
                    {
                        int quotient = client.calculate(1, work);
                        Console.WriteLine("Whoa we can divide by 0");
                    }
                    catch (InvalidOperation io)
                    {
                        Console.WriteLine("Invalid operation: " + io.Why);
                    }

                    work.Op = Operation.SUBTRACT;
                    work.Num1 = 15;
                    work.Num2 = 10;
                    try
                    {
                        int diff = client.calculate(1, work);
                        Console.WriteLine("15-10={0}", diff);
                    }
                    catch (InvalidOperation io)
                    {
                        Console.WriteLine("Invalid operation: " + io.Why);
                    }

                    SharedStruct log = client.getStruct(1);
                    Console.WriteLine("Check log: {0}", log.Value);
                     */


                    /* not use thread total use 1 min

                    for (int i = 1; i < 10000; i++)
                    {
                        Work work = new Work();
                        work.Op = Operation.MULTIPLY;
                        work.Num1 = i;
                        work.Num2 = i;
                        int sum = client.calculate(i, work);
                        Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());
                    }

                    Logger.Info(DateTime.Now.ToString());
                     */

                    Thread oThreadone = new Thread(Work1);
                    Thread oThreadtwo = new Thread(Work2);
                    Thread oThreadthree = new Thread(Work3);
                    Thread oThreadfour = new Thread(Work4);
                    Thread oThreadfive = new Thread(Work5);

                    oThreadone.Start();
                    oThreadtwo.Start();
                    oThreadthree.Start();
                    oThreadfour.Start();
                    oThreadfive.Start();

                }
                finally
                {
                    transport.Close();
                }
            }
            catch (TApplicationException x)
            {
                Console.WriteLine(x.StackTrace);
            }

        }   //end of main 

        static void Work1()
        {
            TTransport transport = new TSocket("localhost", 9090);
            TProtocol protocol = new TBinaryProtocol(transport);
            Calculator.Client client = new Calculator.Client(protocol);

            transport.Open();
            Work work = new Work();

            for (int i = 1; i < 2000; i++)
            {
                //Work work = new Work();
                work.Op = Operation.MULTIPLY;
                work.Num1 = i;
                work.Num2 = i;
                int sum = client.calculate(i, work);
                //Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());
            }
            Logger.Info(DateTime.Now.ToString());

        }

        static void Work2()
        {
            TTransport transport = new TSocket("localhost", 9090);
            TProtocol protocol = new TBinaryProtocol(transport);
            Calculator.Client client = new Calculator.Client(protocol);

            transport.Open();
            Work work = new Work();
            for (int i = 2000; i < 4000; i++)
            {
                //Work work = new Work();
                work.Op = Operation.MULTIPLY;
                work.Num1 = i;
                work.Num2 = i;
                int sum = client.calculate(i, work);
               // Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());
            }
            Logger.Info(DateTime.Now.ToString());

        }

        static void Work3()
        {
            TTransport transport = new TSocket("localhost", 9090);
            TProtocol protocol = new TBinaryProtocol(transport);
            Calculator.Client client = new Calculator.Client(protocol);

            transport.Open();
            Work work = new Work();

            for (int i = 4000; i < 6000; i++)
            {
                //Work work = new Work();
                work.Op = Operation.MULTIPLY;
                work.Num1 = i;
                work.Num2 = i;
                int sum = client.calculate(i, work);
                //Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());
            }
            Logger.Info(DateTime.Now.ToString());

        }

        static void Work4()
        {
            TTransport transport = new TSocket("localhost", 9090);
            TProtocol protocol = new TBinaryProtocol(transport);
            Calculator.Client client = new Calculator.Client(protocol);

            transport.Open();
            Work work = new Work();

            for (int i = 6000; i < 8000; i++)
            {
                //Work work = new Work();
                work.Op = Operation.MULTIPLY;
                work.Num1 = i;
                work.Num2 = i;
                int sum = client.calculate(i, work);
               // Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());
            }

            Logger.Info(DateTime.Now.ToString());
        }

        static void Work5()
        {
            TTransport transport = new TSocket("localhost", 9090);
            TProtocol protocol = new TBinaryProtocol(transport);
            Calculator.Client client = new Calculator.Client(protocol);

            transport.Open();
            Work work = new Work();

            for (int i = 8000; i < 10000; i++)
            {
                //Work work = new Work();
                work.Op = Operation.MULTIPLY;
                work.Num1 = i;
                work.Num2 = i;
                int sum = client.calculate(i, work);
                //Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());
            }
            Logger.Info(DateTime.Now.ToString());

        }


    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

using System;

using Thrift;

using Thrift.Protocol;

using Thrift.Server;

using Thrift.Transport;

using log4net;

using System.Threading;

namespace thriftClient

{

public class Program

{

//private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

private static readonly ILog Logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

public static void Main()

{

try

{

//Logger.Info("Hello logging world!");

Logger.Info(DateTime.Now.ToString());

TTransport transport = new TSocket("localhost", 9090);

TProtocol protocol = new TBinaryProtocol(transport);

Calculator.Client client = new Calculator.Client(protocol);

transport.Open();

try

{

client.ping();

Console.WriteLine("ping()");

/* original gen code

int sum = client.add(1, 1);

Console.WriteLine("1+1={0}", sum);

Work work = new Work();

work.Op = Operation.DIVIDE;

work.Num1 = 1;

work.Num2 = 0;

try

{

int quotient = client.calculate(1, work);

Console.WriteLine("Whoa we can divide by 0");

}

catch (InvalidOperation io)

{

Console.WriteLine("Invalid operation: " + io.Why);

}

work.Op = Operation.SUBTRACT;

work.Num1 = 15;

work.Num2 = 10;

try

{

int diff = client.calculate(1, work);

Console.WriteLine("15-10={0}", diff);

}

catch (InvalidOperation io)

{

Console.WriteLine("Invalid operation: " + io.Why);

}

SharedStruct log = client.getStruct(1);

Console.WriteLine("Check log: {0}", log.Value);

/* not use thread total use 1 min

for (int i = 1; i < 10000; i++)

{

Work work = new Work();

work.Op = Operation.MULTIPLY;

work.Num1 = i;

work.Num2 = i;

int sum = client.calculate(i, work);

Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());

}

Logger.Info(DateTime.Now.ToString());

Thread oThreadone = new Thread(Work1);

Thread oThreadtwo = new Thread(Work2);

Thread oThreadthree = new Thread(Work3);

Thread oThreadfour = new Thread(Work4);

Thread oThreadfive = new Thread(Work5);

oThreadone.Start();

oThreadtwo.Start();

oThreadthree.Start();

oThreadfour.Start();

oThreadfive.Start();

}

finally

{

transport.Close();

}

catch (TApplicationException x)

{

Console.WriteLine(x.StackTrace);

}

} //end of main

static void Work1()

{

TTransport transport = new TSocket("localhost", 9090);

TProtocol protocol = new TBinaryProtocol(transport);

Calculator.Client client = new Calculator.Client(protocol);

transport.Open();

Work work = new Work();

for (int i = 1; i < 2000; i++)

{

//Work work = new Work();

work.Op = Operation.MULTIPLY;

work.Num1 = i;

work.Num2 = i;

int sum = client.calculate(i, work);

//Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());

}

Logger.Info(DateTime.Now.ToString());

}

static void Work2()

{

TTransport transport = new TSocket("localhost", 9090);

TProtocol protocol = new TBinaryProtocol(transport);

Calculator.Client client = new Calculator.Client(protocol);

transport.Open();

Work work = new Work();

for (int i = 2000; i < 4000; i++)

{

//Work work = new Work();

work.Op = Operation.MULTIPLY;

work.Num1 = i;

work.Num2 = i;

int sum = client.calculate(i, work);

// Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());

}

Logger.Info(DateTime.Now.ToString());

}

static void Work3()

{

TTransport transport = new TSocket("localhost", 9090);

TProtocol protocol = new TBinaryProtocol(transport);

Calculator.Client client = new Calculator.Client(protocol);

transport.Open();

Work work = new Work();

for (int i = 4000; i < 6000; i++)

{

//Work work = new Work();

work.Op = Operation.MULTIPLY;

work.Num1 = i;

work.Num2 = i;

int sum = client.calculate(i, work);

//Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());

}

Logger.Info(DateTime.Now.ToString());

}

static void Work4()

{

TTransport transport = new TSocket("localhost", 9090);

TProtocol protocol = new TBinaryProtocol(transport);

Calculator.Client client = new Calculator.Client(protocol);

transport.Open();

Work work = new Work();

for (int i = 6000; i < 8000; i++)

{

//Work work = new Work();

work.Op = Operation.MULTIPLY;

work.Num1 = i;

work.Num2 = i;

int sum = client.calculate(i, work);

// Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());

}

Logger.Info(DateTime.Now.ToString());

}

static void Work5()

{

TTransport transport = new TSocket("localhost", 9090);

TProtocol protocol = new TBinaryProtocol(transport);

Calculator.Client client = new Calculator.Client(protocol);

transport.Open();

Work work = new Work();

for (int i = 8000; i < 10000; i++)

{

//Work work = new Work();

work.Op = Operation.MULTIPLY;

work.Num1 = i;

work.Num2 = i;

int sum = client.calculate(i, work);

//Logger.Info(i.ToString() + @"'s multiply result is : " + sum.ToString());

}

Logger.Info(DateTime.Now.ToString());

}

Q&A

If anyone can call the remote procedure , No any permission limit ? or any anthentication ?
How server know how many client connect to it ?

Thrift script analyze

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

# Thrift Tutorial
# Mark Slee (mcslee@facebook.com)
#
# This file aims to teach you how to use Thrift, in a .thrift file. Neato. The
# first thing to notice is that .thrift files support standard shell comments.
# This lets you make your thrift file executable and include your Thrift build
# step on the top line. And you can place comments like this anywhere you like.
#
# Before running this file, you will need to have installed the thrift compiler
# into /usr/local/bin.

/**
 * The first thing to know about are types. The available types in Thrift are:
 *
 *  bool        Boolean, one byte
 *  i8 (byte)   Signed 8-bit integer
 *  i16         Signed 16-bit integer
 *  i32         Signed 32-bit integer
 *  i64         Signed 64-bit integer
 *  double      64-bit floating point value
 *  string      String
 *  binary      Blob (byte array)
 *  map<t1,t2>  Map from one type to another
 *  list<t1>    Ordered list of one type
 *  set<t1>     Set of unique elements of one type
 *
 * Did you also notice that Thrift supports C style comments?
 */

// Just in case you were wondering... yes. We support simple C comments too.

/**
 * Thrift files can reference other Thrift files to include common struct
 * and service definitions. These are found using the current path, or by
 * searching relative to any paths specified with the -I compiler flag.
 *
 * Included objects are accessed using the name of the .thrift file as a
 * prefix. i.e. shared.SharedObject
 */
include "shared.thrift"

/**
 * Thrift files can namespace, package, or prefix their output in various
 * target languages.
 */
namespace cpp tutorial
namespace d tutorial
namespace dart tutorial
namespace java tutorial
namespace php tutorial
namespace perl tutorial
namespace haxe tutorial
namespace netcore tutorial

/**
 * Thrift lets you do typedefs to get pretty names for your types. Standard
 * C style here.
 */
typedef i32 MyInteger

/**
 * Thrift also lets you define constants for use across languages. Complex
 * types and structs are specified using JSON notation.
 */
const i32 INT32CONSTANT = 9853
const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}

/**
 * You can define enums, which are just 32 bit integers. Values are optional
 * and start at 1 if not supplied, C style again.
 */
enum Operation {
  ADD = 1,
  SUBTRACT = 2,
  MULTIPLY = 3,
  DIVIDE = 4
}

/**
 * Structs are the basic complex data structures. They are comprised of fields
 * which each have an integer identifier, a type, a symbolic name, and an
 * optional default value.
 *
 * Fields can be declared "optional", which ensures they will not be included
 * in the serialized output if they aren't set.  Note that this requires some
 * manual management in some languages.
 */
struct Work {
  1: i32 num1 = 0,
  2: i32 num2,
  3: Operation op,
  4: optional string comment,
}

/**
 * Structs can also be exceptions, if they are nasty.
 */
exception InvalidOperation {
  1: i32 whatOp,
  2: string why
}

/**
 * Ahh, now onto the cool part, defining a service. Services just need a name
 * and can optionally inherit from another service using the extends keyword.
 */
service Calculator extends shared.SharedService {

  /**
   * A method definition looks like C code. It has a return type, arguments,
   * and optionally a list of exceptions that it may throw. Note that argument
   * lists and exception lists are specified using the exact same syntax as
   * field lists in struct or exception definitions.
   */

   void ping(),

   i32 add(1:i32 num1, 2:i32 num2),

   i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),

   /**
    * This method has a oneway modifier. That means the client only makes
    * a request and does not listen for any response at all. Oneway methods
    * must be void.
    */
   oneway void zip()

}

/**
 * That just about covers the basics. Take a look in the test/ folder for more
 * detailed examples. After you run this file, your generated code shows up
 * in folders with names gen-<language>. The generated code isn't too scary
 * to look at. It even has pretty indentation.
 */

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements. See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership. The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License. You may obtain a copy of the License at

* http://www.apache.org/licenses/LICENSE-2.0

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied. See the License for the

* specific language governing permissions and limitations

* under the License.

# Thrift Tutorial

# Mark Slee (mcslee@facebook.com)

# This file aims to teach you how to use Thrift, in a .thrift file. Neato. The

# first thing to notice is that .thrift files support standard shell comments.

# This lets you make your thrift file executable and include your Thrift build

# step on the top line. And you can place comments like this anywhere you like.

# Before running this file, you will need to have installed the thrift compiler

# into /usr/local/bin.

/**

* The first thing to know about are types. The available types in Thrift are:

* bool Boolean, one byte

* i8 (byte) Signed 8-bit integer

* i16 Signed 16-bit integer

* i32 Signed 32-bit integer

* i64 Signed 64-bit integer

* double 64-bit floating point value

* string String

* binary Blob (byte array)

* map<t1,t2> Map from one type to another

* list<t1> Ordered list of one type

* set<t1> Set of unique elements of one type

* Did you also notice that Thrift supports C style comments?

// Just in case you were wondering... yes. We support simple C comments too.

/**

* Thrift files can reference other Thrift files to include common struct

* and service definitions. These are found using the current path, or by

* searching relative to any paths specified with the -I compiler flag.

* Included objects are accessed using the name of the .thrift file as a

* prefix. i.e. shared.SharedObject

include "shared.thrift"

/**

* Thrift files can namespace, package, or prefix their output in various

* target languages.

namespace cpp tutorial

namespace d tutorial

namespace dart tutorial

namespace java tutorial

namespace php tutorial

namespace perl tutorial

namespace haxe tutorial

namespace netcore tutorial

/**

* Thrift lets you do typedefs to get pretty names for your types. Standard

* C style here.

typedef i32 MyInteger

/**

* Thrift also lets you define constants for use across languages. Complex

* types and structs are specified using JSON notation.

const i32 INT32CONSTANT = 9853

const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}

/**

* You can define enums, which are just 32 bit integers. Values are optional

* and start at 1 if not supplied, C style again.

enum Operation {

ADD = 1,

SUBTRACT = 2,

MULTIPLY = 3,

DIVIDE = 4

}

/**

* Structs are the basic complex data structures. They are comprised of fields

* which each have an integer identifier, a type, a symbolic name, and an

* optional default value.

* Fields can be declared "optional", which ensures they will not be included

* in the serialized output if they aren't set. Note that this requires some

* manual management in some languages.

struct Work {

1: i32 num1 = 0,

2: i32 num2,

3: Operation op,

4: optional string comment,

}

/**

* Structs can also be exceptions, if they are nasty.

exception InvalidOperation {

1: i32 whatOp,

2: string why

}

/**

* Ahh, now onto the cool part, defining a service. Services just need a name

* and can optionally inherit from another service using the extends keyword.

service Calculator extends shared.SharedService {

/**

* A method definition looks like C code. It has a return type, arguments,

* and optionally a list of exceptions that it may throw. Note that argument

* lists and exception lists are specified using the exact same syntax as

* field lists in struct or exception definitions.

void ping(),

i32 add(1:i32 num1, 2:i32 num2),

i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),

/**

* This method has a oneway modifier. That means the client only makes

* a request and does not listen for any response at all. Oneway methods

* must be void.

oneway void zip()

}

/**

* That just about covers the basics. Take a look in the test/ folder for more

* detailed examples. After you run this file, your generated code shows up

* in folders with names gen-<language>. The generated code isn't too scary

* to look at. It even has pretty indentation.

Month: August 2018

How to use log4net in c# console application

build thrift-0.11.0 from source on ubuntu 17

short statement

My VPS asterisk settings

Personal skill

centos 6 install vsftpd